MisarMail

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

Annotations are all false and provide no safety hints. The description compensates by disclosing a critical behavioral constraint: the domain cannot send until DNS records are live and verify_domain succeeds. This adds value beyond the annotations, though it does not cover potential errors or idempotency details.

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

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

Two sentences, front-loaded with the action and output. The second sentence adds the essential conditional about sending. Every word earns its place; no fluff or repetition.

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

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

Despite having no output schema, the description explicitly states the return value (DNS records) and the required next step (verify_domain). For a single-parameter tool with simple semantics, this is complete and 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?

Schema coverage is 100% with a self-explanatory parameter 'domain' described as 'Domain to add, e.g. example.com'. The description adds no additional meaning to the parameter itself, 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 states a specific action 'Add a sending domain' and the primary output 'return the DNS records to publish'. It clearly distinguishes from sibling tools like verify_domain and configure_inbound_domain by positioning this as the initial addition step.

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

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

The description clearly implies when to use this tool (before verification) by stating that sending is blocked until records are live and verify_domain succeeds. It names verify_domain as a follow-up step, but does not explicitly list alternatives or exclusions, so it falls short of a 5.

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

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

Annotations already include destructiveHint=false and readOnlyHint=false, and the description adds the explicit behavioral guarantee that the operation is reversible and the message is not deleted. This provides additional context beyond the simple hints, explaining the non-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, direct sentence that conveys the action and a key behavioral property without wasted words. It is concise and efficiently 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 tool with one parameter, no output schema, and annotations covering safety, the description sufficiently states the action and its reversibility. The behavioral note fully addresses the primary context an agent needs to know.

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 id parameter described as 'Email ID to archive'. The tool description adds no extra parameter semantics, so it relies on the schema's existing clarity. This meets the baseline for full schema coverage.

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

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

The description uses a specific verb ('Move') and resource ('email to the archive folder'), clearly identifying the action and distinguishing it from siblings like send_email or reply_to_email. It fully states what the tool does.

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

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

The description implies usage (archiving an email) but does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions or prerequisites. No sibling tool archives, so usage is inferable, but not explicitly guided.

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 note not present in annotations: 'Consumes AI credits'. This is valuable cost-related context. Since annotations already cover idempotency and non-destructiveness, the added credit disclosure elevates transparency beyond the baseline.

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: the first states the action and result, the second adds a cost warning and usage guidance. No redundant phrasing, and the key information is front-loaded.

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

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

Given the tool's simplicity (one param, annotations present, no output schema), the description covers purpose, cost, and input selection advice. It could mention output format or side effects on emails, but these are not critical for a low-parameter tool with good 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 schema description already fully covers the single parameter (email_ids) with a max count. The description's 'batch' and 'only the emails you need' reinforce usage but do not add new semantic detail about the parameter itself, so baseline 3 is appropriate.

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

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

The description uses a specific verb ('Run AI categorisation') and identifies the resource ('inbox emails') and the outcome ('label intent and priority'). This clearly distinguishes it from sibling tools, none of which offer categorization.

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 use for triaging emails and explicitly advises to 'pass only the emails you actually need triaged'. It lacks an explicit comparison to alternative tools, but no sibling offers similar categorization, making the context clear.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds value beyond these by specifying the check is 'live' and that output includes the 'exact record to publish,' which gives the agent a clearer expectation of behavior. No contradiction with annotations.

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

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

The description is only two sentences, front-loads the main action, and includes the key scope qualifier. Every word adds value; no fluff.

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

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

For a tool with one simple parameter and strong annotations, the description is complete: it states the action, the records checked, the output, and the domain scope. It does not detail output formatting, but that is not critical given the simple nature and 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?

Schema coverage for the single parameter 'domain' is 100% and includes an example. The description does not add extra meaning 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 clearly states a specific verb ('Check') and a resource ('live SPF, DKIM, and DMARC DNS records') and adds output details ('report alignment problems with the exact record to publish'). The scope 'Works for any domain, not only your own' distinguishes it from ownership-verification tools like verify_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 when to use it (to check email authentication DNS records and get actionable fixes) and the 'any domain' note differentiates it from tools requiring domain ownership. However, it does not explicitly name alternative tools or describe when not to use it, so it falls short of a 5.

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

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

While annotations already mark the tool as destructive, the description adds crucial context: it affects only intercepted test messages and never real sent mail. This goes beyond the destructive hint and provides a safety guarantee.

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 short sentences, front-loaded with the action and no redundant information. 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 simple, parameterless tool with annotations covering safety, the description fully covers purpose and scope. There is no output schema, but none is needed because the tool has no return value 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?

There are no parameters, so the baseline is 4. The description explains the action without needing parameter details, which is appropriate for a parameterless 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 action: 'Delete every captured sandbox email.' It uses a specific verb and resource, and the qualifier 'never real sent mail' distinguishes it from email deletion tools that affect actual messages.

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 clearing intercepted test messages and clarifies scope, but does not explicitly name alternatives or say when not to use this tool. However, the context is clear given sibling tools like list_sandbox_sends.

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

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

Annotations already indicate idempotent and non-destructive behavior. The description adds that the tool returns an MX record to publish, implying DNS changes are not made by the tool. However, it does not disclose side effects like whether existing routing is replaced or how webhook_url interacts.

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: the first states the purpose and outcome, the second states the return value. 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?

The description covers the main purpose and return value (MX record), which is especially important since there is no output schema. It lacks detail on errors or webhook behavior, but schema covers parameters and the tool is simple.

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 parameters are already documented in the schema with clear descriptions (domain, subdomain, webhook_url). The description doesn't add much beyond stating the subdomain is for inbound replies, so a 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 configures inbound email routing for a subdomain and returns the MX record to publish. This specific verb+resource combination distinguishes it from sibling tools like add_domain or verify_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 provides clear context: configuring inbound routing so replies land in the unified inbox. It implies a specific use case but does not explicitly mention alternatives or when not to use, which is a minor gap.

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 key behavioral trait beyond annotations: the tool immediately sends a sample percentage to part of the audience and later sends the remainder to the winner. This is not captured by the annotations (readOnlyHint=false, destructiveHint=false) and adds important context about side effects and the test flow.

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 that lead with the primary purpose and then add a brief, useful behavioral detail. There is no redundancy or fluff, and every sentence earns its place.

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

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

For a tool with 5 parameters and no output schema, the description covers the main action and the high-level flow. It does not explicitly mention the need for a complementary action like select_ab_test_winner, but the phrase 'once selected' implies it. The description is complete enough for an agent to understand the tool's role, though slightly more context about the overall workflow would help.

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 reinforces that variants must be two or more and mentions the sample percentage, but it does not add meaning beyond what the schema already provides. All parameters are well-described in the schema itself.

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: 'Create an A/B test on a campaign with two or more variants.' The verb 'create' and resource 'A/B test on a campaign' are specific, and the description distinguishes it from siblings like list_ab_tests and select_ab_test_winner by focusing on the creation step.

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 within a multi-step workflow ('A sample percentage is sent first; the winner goes to the remainder once selected'), hinting that a later selection step is needed. However, it does not explicitly name select_ab_test_winner as an alternative or provide when/when-not guidance, so usage 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?

The annotations already indicate a write operation (readOnlyHint=false) and non-idempotent behavior. The description adds a non-obvious behavioral detail: the automation starts paused, and it recommends the activation tool. This goes beyond what annotations alone convey, though it doesn't mention all side effects or return values.

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

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

The description is two sentences long, with the first sentence front-loading the core function and the second sentence adding critical default-state behavior. 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?

The description captures the tool's purpose and its most important behavioral nuance (paused default), but given the tool's complexity and lack of an output schema, the agent might miss details about return values or validation. Overall, it's sufficiently complete for selection and basic invocation.

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

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

The schema has 100% coverage with descriptions for all 5 parameters, including the nested 'steps' object. The description adds no substantive parameter details beyond what the schema already provides, 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 uses a specific verb ('Create') and resource ('automation workflow'), and specifies the inputs ('from a trigger and an ordered list of steps'). This clearly distinguishes it from sibling tools like get_automation, list_automations, and toggle_automation.

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 usage context by stating that automations are 'Created paused by default' and directs the agent to 'call toggle_automation to activate once the steps are reviewed.' This explicitly names an alternative tool and the appropriate follow-up action, giving strong guidance.

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

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

Annotations indicate readOnlyHint false, but the description adds critical behavioral context: creating never sends. This is a meaningful disclosure beyond the structured hints. It does not, however, detail how scheduled_at interacts with the draft state, which would have been even more 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?

A single, front-loaded sentence that states purpose and provides the key alternative tool. No wasted words, and the distinction from send_campaign is essential.

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 11 parameters and no output schema, the description does not cover everything, but the schema documents all parameters. It addresses the core behavior (draft vs. send) and mentions the companion send_campaign. A minor gap: how scheduled_at relates to the 'never sends' rule is left ambiguous, preventing a 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 description coverage is 100% for all 11 parameters, so the description does not need to re-explain them. It adds only high-level context (content/audience confirmation) and no param-specific semantics. Baseline of 3 is appropriate since the schema carries the burden.

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

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

Description clearly states it creates a new email marketing campaign as a draft. It uses a specific verb ('create') plus a resource ('email marketing campaign') and explicitly differentiates from sibling send_campaign by noting it never sends.

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 says to create a draft, and explicitly instructs to call send_campaign separately once content and audience are confirmed. This provides a clear when-to-use and names the alternative tool, satisfying the guidelines dimension.

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 valuable behavioral context beyond the annotations: it states that adding a contact records consent to email them and warns about sender reputation damage and legal liability under CAN-SPAM/GDPR. This is a significant side effect not captured by the readOnly/destructive/idempotent hints, and it directly informs safe usage.

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: the first front-loads the core action, and the second provides a critical legal/reputational warning. There is no redundant information or 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?

Given the tool's moderate complexity (9 params, nested custom_fields) and no output schema, the description covers the essential purpose and a crucial legal constraint. The schema handles parameter details, but the description could be more complete by mentioning behavior on duplicate emails or what the response contains; these are minor omissions.

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 covers all 9 parameters with descriptions (100% coverage), so the baseline is 3. The description adds meaning to the email parameter by linking it to consent requirements, but it does not add semantic detail for tags, custom_fields, or other fields beyond what the schema provides.

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

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

The description begins with 'Add a single contact,' which states a specific verb and resource, clearly distinguishing it from bulk import tools like import_contacts and update tools like update_contact. The singular 'single' makes its scope unambiguous.

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

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

The phrase 'only add addresses that opted in' provides an explicit condition for when to use the tool, and 'single contact' implies it is for individual adds rather than bulk import. However, it does not explicitly name alternative tools (e.g., import_contacts for bulk), so it stops short of a full when/when-not comparison.

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 behavioral context beyond the annotations by stating that 'subscribers flow straight into your contact list' and that it returns a public URL. However, it does not disclose more nuanced behaviors such as idempotency (though annotations say false), potential side effects on existing contacts, or any other operational characteristics. Given the annotations are sparse, the description carries some burden but falls short of rich 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 two sentences long, front-loaded with the main verb and resource, and every word earns its place. No fluff or redundancy. It is appropriately sized for the tool's complexity.

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 create tool with a well-described schema and no output schema, the description is nearly complete: it communicates the purpose, the key outcome (public URL), and the side effect (subscriber flow). The only gap is usage guidance, which is covered in a separate dimension. Without needing to explain return types (since none specified), this 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 provides 100% coverage with descriptions for all six parameters, so the baseline is 3. The description does not add any parameter-specific meaning beyond what the schema already states. It mentions the 'email capture form' but does not elaborate on parameters like cta_text or tags, leaving schema to handle that.

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

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

The description clearly states the tool creates a 'hosted landing page with an email capture form' and mentions returning the public URL. This distinguishes it from siblings like create_campaign or create_contact, which have different resources. The verb 'create' and specific resource make the purpose 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?

No guidance is provided on when to use this tool versus alternatives. The description only explains what it does, leaving the agent to infer when it is appropriate. It does not mention exclusions, prerequisites, or scenarios where another tool (e.g., create_campaign) would be preferred.

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

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

With annotations all set to false, the description carries the burden of disclosing behavior. It adds the valuable context that variables are substituted at send time and can be previewed via render_template. However, it omits other behavioral traits like duplicate handling, return values, or permission 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 exceptionally concise—two short sentences that front-load the core purpose and immediately provide actionable detail about variable placeholders and preview capability. 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 rich schema coverage (100%) and the tool's moderate complexity, the description adds the essential non-obvious behavior (variable substitution and preview path). While it does not describe return values or edge cases, it is sufficient for correct use in most scenarios.

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 of all 6 parameters, so the baseline is 3. The description reinforces the {{variable}} syntax but does not go beyond the schema's own parameter descriptions, offering no additional semantic insight.

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

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

The description clearly states the tool creates a reusable email template, distinguishing it from related tools like create_campaign. It also highlights the key variable substitution feature, making the purpose specific and 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 explicit guidance on when to use this tool over alternatives such as create_campaign or create_automation. The mention of render_template for previewing is useful but does not establish a clear selection criterion 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, covering safety. The description adds context about date-range scoping and report types, but does not detail output format or internal behavior beyond what the schema provides. No contradiction with annotations.

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

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

Two sentences, direct and informative. The first states the core function, the second lists the report types compactly. 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?

The tool has a simple schema fully described, and the description covers purpose, report types, and date range. It lacks an explicit statement about return value or format, but given the read-only and idempotent annotations, the missing detail is minor and the overall picture is clear.

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 covers all three parameters with descriptions, but the tool description adds semantic value by explaining that send_time_heatmap identifies 'the best hour/day to send' and linking the date range to report generation. This goes beyond the raw enum values in the schema.

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

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

The description uses the specific verb 'Generate' with resource 'structured analytics report' and scope 'over a date range', and enumerates four distinct report types. This clearly distinguishes it from sibling tools like get_analytics, which retrieve data rather than generate reports.

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

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

The description implies usage context by listing report types but does not explicitly state when to prefer this over sibling tools such as get_analytics, nor does it provide exclusions or prerequisites. The decision to use this tool is left to the agent's inference.

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

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

Annotations already indicate readOnlyHint=false, openWorldHint=true, and idempotentHint=false, covering the safety profile. The description adds 'AI' suggesting non-determinism, but provides no additional behavioral details such as side effects, return format, or rate limits. This is adequate but not rich.

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

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

Two sentences, front-loaded with the core purpose, and zero wasted words. The description is efficiently structured and easy to parse.

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

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

For a generation tool with no output schema, the description explains what it does and offers a use case ('Good input for create_ab_test'). It lacks explicit return structure (e.g., 'returns a list of strings') but the name and description make that reasonably clear. Overall, it is complete enough for a straightforward tool.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description's mention of 'tuned to a tone and audience' simply restates two schema properties without adding new meaning. It does not compensate with additional context for count or topic beyond what is already present.

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 'Generate', the resource 'AI subject-line variants', and the context 'for a campaign topic'. This distinguishes it from sibling tools like render_template or create_ab_test by focusing specifically on subject line generation.

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 'Good input for create_ab_test' provides explicit workflow guidance, telling the agent when this tool's output is useful. It also mentions optional tuning for tone and audience, which indicates flexibility. However, it does not explicitly exclude alternatives or state when not to use it, so it falls short of a 5.

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

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

Annotations already establish read-only, idempotent, and non-destructive behavior. The description adds valuable context by specifying grouping options (day/week/month) and scope flexibility (account or campaign), going beyond the annotations without contradiction.

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

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

The description is a single, well-structured sentence that front-loads the main action and includes key details (metrics, scope, grouping) without any redundant or vague wording.

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

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

For a read-only analytics tool with all parameters documented and strong annotations, the description covers the essential purpose and scope. There is no output schema, but listing the expected metrics provides some insight into return values. Minor gaps such as timezone handling or explicit parameter interaction are acceptable given the overall 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?

Schema description coverage is 100%, so the parameters are fully documented. The description reinforces the meaning of campaign_id and group_by but does not add extra detail beyond what the schema already provides.

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

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

The description clearly identifies the tool as retrieving delivery and engagement analytics, naming specific metrics (sent, delivered, opened, clicked, bounced, complained) and scope options (account- or campaign-wide, grouped by day/week/month). This distinguishes it from sibling analytics tools like get_deliverability_score.

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—when delivery/engagement metrics are needed—and clearly states scope options (account or campaign). It does not explicitly name alternatives or exclusions, but the context is sufficient given the sibling list.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, covering the safety profile. The description adds value by disclosing what 'full' means (trigger, steps with delays, per-step stats), which is beyond what annotations provide. It does not contradict any annotation.

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

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

The description is a single sentence, front-loaded with the core action ('Get one automation workflow in full'), then efficiently lists the details. No filler or redundant information—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 simple get-by-ID tool with one parameter, strong annotations, and no output schema, the description is complete. It clearly specifies the depth of the response (trigger, all steps with delays, per-step stats), which fully informs the agent of what to expect. The existence of list_automations as a sibling reinforces the scope.

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

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

The input schema covers 100% of the parameter (automation_id) with a description 'Automation ID (UUID)'. The tool description adds no additional parameter semantics beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description uses the specific verb 'Get' and identifies the resource as 'one automation workflow in full', clearly distinguishing it from sibling tools like list_automations. It enumerates the specific components (trigger, every step with delay, per-step completion stats), leaving no ambiguity about what the tool does.

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

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

The phrase 'in full' implies this is for retrieving comprehensive details of a single automation, contrasting with list_automations for summaries, but it does not explicitly name alternatives or state when not to use it. The context is clear enough for an agent to infer usage, though explicit exclusions would improve it.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds value by listing the exact data returned (content, audience, schedule, delivery stats), giving behavioral transparency about output. No mention of errors or auth, but for a read-only get with one param, 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 concise sentence that front-loads the action and resource, then lists included details. Every word earns its place with no redundancy or fluff.

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

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

For a simple get-by-id tool with one parameter, no output schema, and strong annotations, this description is complete. It tells the agent what the tool does and what the response will contain at a high level, making it sufficient for invocation.

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

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

The input schema describes campaign_id as 'Campaign ID (UUID)' with 100% coverage. The description does not add any parameter semantics beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Get full details for one campaign' with a specific verb ('Get') and resource ('campaign'). It enumerates the detail categories (content, audience, schedule, delivery stats), which distinguishes it from sibling tools like list_campaigns (list all) and create_campaign (create).

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 is for retrieving details of a single campaign by ID, which is the appropriate use case. It does not explicitly name alternatives or exclusions, but the context is clear enough that an agent can infer when to use it (when a specific campaign_id is known).

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the bar is lower. The description adds the key behavioral trait of returning lowest-engagement contacts when contact_id is omitted, and identifies the return fields. No contradictions with annotations.

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

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

Two sentences pack a clear definition, conditional behavior, and usage context with zero fluff. 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 a single optional parameter and no output schema, the description sufficiently explains purpose, return values, and use case. Minor gap: it does not specify ordering or count of the lowest-engagement list, but this does not hinder correct invocation.

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

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

Schema covers contact_id fully (100% coverage), so baseline is 3. The description adds significant meaning by explaining that omitting the parameter changes the operation's output from a single contact score to a list of low-engagement contacts, going beyond the schema's bare description.

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

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

The description uses specific verbs ('Get', 'return') and resources ('engagement score, engagement tier, churn risk') while clearly distinguishing between per-contact and list-scope behavior. It differentiates from sibling tools like get_deliverability_score and get_analytics by naming exact outputs.

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

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

Explicitly states when to use ('before a re-engagement campaign') and explains the conditional behavior with or without contact_id. It does not name alternatives or exclusions, but the context is clear enough for an agent to select it appropriately.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is known. The description adds behavioral context by specifying the return structure (score, letter grade, factors), which is especially valuable given there is no output schema. It does not contradict annotations.

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

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

The description is two concise sentences. The first sentence front-loads the primary function and output, and the second gives usage context. 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?

With no output schema, the description adequately explains what the tool returns (score, grade, factors). It also provides the primary use case. It could optionally mention more detailed alternatives, but for a simple read-only tool, the coverage 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 tool has zero parameters, so the baseline is 4. There are no parameter semantics to explain, but the description clarifies that the score is account-level, which is useful context beyond the empty 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's function: retrieving the account deliverability score (0–100), letter grade (A–F), and the factors impacting it. It uses a specific verb ('Get') and resource ('account deliverability score') with explicit output details, making it distinct from sibling tools like run_deliverability_audit.

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 instruction 'Start here when asked why emails are landing in spam' provides explicit context for when to use this tool. It does not mention alternatives or exclusions, but the 'start here' phrasing clearly positions it as the initial diagnostic step.

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

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

The description explicitly discloses the side effect 'marks the email as read', which goes beyond the annotations. Annotations already indicate non-read-only (readOnlyHint=false) and idempotent (idempotentHint=true), but the description specifies the exact side effect, adding valuable context. No contradictions with annotations.

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

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

The description is two sentences: one stating the core purpose and content, the second disclosing the side effect. It is concise, front-loaded, and every sentence adds value 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?

For a simple single-parameter tool with no output schema, the description completely covers the return contents (headers, body, attachments metadata) and the side effect. It also distinguishes from siblings. No additional context seems necessary for correct invocation.

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

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

The input schema has full coverage for the single parameter 'id' with description 'Email ID (UUID)'. The description's phrase 'by ID' adds no additional meaning beyond the schema. Since schema coverage is 100%, baseline 3 is appropriate.

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

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

The description clearly states the tool reads a single email by ID and lists the content components (headers, body, attachments metadata). This distinguishes it from siblings like list_emails (which lists) and archive_email (which modifies). The verb 'Read' is specific and the resource is well-defined.

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: use this tool when you have an email ID and need the full content of that specific email. It does not explicitly mention alternatives or exclusions, but the 'single email by ID' phrasing implies usage compared to listing tools. Sibling tools like list_emails are naturally differentiated, though not explicitly named.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description's safety burden is low. It adds behavioral context by specifying the returned components (fields, embed code, redirect behaviour), which is useful but does not cover error handling or change behavior beyond the safety profile provided by annotations.

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

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

The description is a single concise sentence, front-loaded with the verb and object, and adds only relevant modifiers. It earns every word without unnecessary elaboration.

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

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

For a single-parameter read tool with strong annotations and no output schema, the description covers what the agent will receive (fields, embed code, redirect behaviour). There are no critical gaps given the tool's simplicity and the existing 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 schema describes form_id as a UUID with 100% coverage, so the description does not need to add parameter details. It adds no extra meaning beyond what is already in the schema, which carries the full burden of describing the parameter.

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

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

The description specifically says 'Get one signup form' and lists the included content, clearly distinguishing it from list_forms and get_form_submissions. The verb 'Get' plus the resource 'signup form' with expected fields makes 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 word 'one' indicates this is for retrieving a single specific form, contrasting with list_forms which lists multiple forms. It does not explicitly name alternatives or exclusions, but the context is clear enough for an agent to select it when a form_id is known.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds value by disclosing that the output includes field values and timestamps, but it does not mention pagination behavior, ordering, or any other operational details beyond what annotations and schema provide.

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 purpose and key output. No filler or repetitive content, and it is front-loaded with the core 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?

Given the tool's low complexity, annotations cover safety, and schema covers all parameters, the description is reasonably complete. It mentions the output content (field values and timestamps), though it could be slightly more explicit about the return format or pagination. Overall, it is sufficient for a straightforward read-only list tool.

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

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

Schema description coverage is 100% with all three parameters (page, limit, form_id) described. The description adds no additional meaning to the parameters, so the baseline of 3 is appropriate since the schema fully carries the burden.

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

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

The description clearly states the tool lists submissions for a signup form, using the specific verb 'List' and resource 'submissions for a signup form'. It also specifies the returned content (field values and timestamps), which distinguishes it from sibling tools like get_form or list_forms that focus on form configuration or listing forms themselves.

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 needing submission data for a specific form, but it does not explicitly state when to use this tool versus alternatives like list_forms or get_form. No exclusions or alternative tools are mentioned, so guidance is only 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?

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds valuable behavioral context by stating the tool returns all messages in chronological order and includes sender/timestamp fields, which goes beyond the annotations. It does not mention limits or pagination, but 'every message' implies completeness.

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 communicates the verb, resource, ordering, and fields without any 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?

For a simple read-only tool with one parameter and strong annotations, the description fully covers what the agent needs to know: what it returns, how it is ordered, and what fields are included. No output schema exists, but the description effectively conveys the return content, making it contextually 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 input schema already provides 100% coverage of the single parameter (conversation_id as UUID), so the description does not add further parameter semantics. Baseline of 3 is appropriate because the schema fully documents the parameter.

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

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

The description clearly specifies the action ('Get'), the resource ('every message in one inbox conversation'), and unique details ('oldest first', 'with sender and timestamps') that distinguish it from sibling tools like list_inbox_conversations or get_email.

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

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

The description conveys that this tool is used for retrieving all messages from a specific conversation, providing clear context for when to use it. However, it does not explicitly mention alternatives or when not to use it, stopping 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds context by specifying exactly what data is returned (configuration, scopes, last sync result), which goes beyond the annotations. No contradictions found.

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 with no redundant words. It states the verb, object, and scope in a compact form. Excessive brevity is not a problem here because the tool is simple.

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 get operation with one parameter and no output schema, the description covers the primary return categories. It lacks details on error responses or response format, but given the simplicity and annotations, it is reasonably complete.

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

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

The schema fully documents integration_id with a description ('Integration ID'), and the parameter count is 1 with 100% schema coverage. The description adds no additional parameter context, but the schema is sufficient, so 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 verb 'Get' with a specific resource ('one integration') and enumerates the returned data ('configuration, scopes, and last sync result'). This clearly distinguishes it from sibling list_integrations (which would return multiple) and toggle_integration (which modifies).

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 explicit when/when-not guidance or alternative tool references are provided. The usage context is implied: use when you need a single integration's details. However, there is no mention of list_integrations for listing or toggle_integration for modifications, so it falls short of explicit guideline.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful context about the return contents (preview, author, install count), but does not disclose potential error behavior, auth requirements, or what 'full preview' includes.

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 states the action and the key return fields without any filler or redundancy. Every word adds value.

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

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

For a simple one-parameter, read-only tool with strong annotations, the description adequately conveys what the tool returns. The mention of 'full preview, author, and install count' partially compensates for the absence of an output schema, though 'full preview' is somewhat ambiguous.

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 single parameter item_id with a description ('Marketplace item ID'), so the description adds no additional parameter semantics. Baseline 3 is appropriate given 100% 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?

Uses a specific verb ('Get') and identifies the exact resource ('one marketplace listing') plus the key data returned (full preview, author, install count). This clearly distinguishes it from the sibling list_marketplace_items tool, which retrieves multiple items.

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 use when a single marketplace item is needed, but it does not explicitly state when to use this tool versus list_marketplace_items or other get_* tools. No when-not-to-use guidance or alternative references 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, so the safety profile is covered. The description adds context about the period scope and returned metrics, but doesn't disclose any additional behaviors like authentication requirements or potential latency. No contradiction.

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

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

A single, well-structured sentence front-loaded with the action and resource. Every word earns its place, listing metrics without redundancy.

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

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

For a simple read-only tool with a single optional parameter, the description covers the core purpose and expected data. It doesn't explain return format or aggregation details, but given no output schema and minimal complexity, the level of description is adequate. However, it could explicitly mention scope (all newsletters) or timezone, so not a full 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 already documents the 'period' parameter with an enum and description (100% coverage). The description's phrase 'for the period' merely echoes this, adding no new meaning. 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 ('Get') and resource ('newsletter monetization stats'), enumerating concrete metrics (paid subscribers, MRR, churn, sponsorship revenue). This clearly distinguishes it from broader analytics siblings like get_analytics and get_revenue_attribution.

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 offers no guidance on when to choose this tool over alternatives. It doesn't mention exclusions or scenarios (e.g., use get_analytics for overall traffic). Agents must 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe read. The description adds 'tracked conversions' context but does not detail return structure, data freshness, or scope limitations beyond what annotations imply.

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, well-structured sentence that front-loads the primary purpose and lists key metrics. Every word earns its place, with no redundancy or filler.

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

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

Given no output schema, the description provides a high-level overview of return values (revenue per campaign, per contact, AOV). It is adequate for a read-only reporting tool with optional parameters, though it omits details like default period behavior and data source specifics.

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 descriptions in the schema. The tool description adds context about output metrics (per campaign, per contact, AOV) but does not enrich the meaning of the period or campaign_id parameters 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's purpose: attributing ecommerce revenue to email, with specific metrics (revenue per campaign, per contact, AOV). It is distinct from generic analytics tools, though it does not explicitly name sibling tools for differentiation.

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

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

No explicit guidance on when to use this tool versus alternatives like get_analytics or get_monetization_stats. The purpose implies its use case, but the description lacks direct usage direction 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable context about the consequences of exceeding warm-up capacity, enriching the behavioral understanding beyond the annotations.

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

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

The description is exactly two sentences: the first states the function, the second provides an important warning. Every word earns its place with no redundancy or fluff.

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

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

For a zero-parameter, read-only getter with no output schema, the description is fully complete. It names the exact data returned (warm-up progress, remaining capacity) and provides a critical usage caution, leaving no significant gaps.

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 100% (empty schema). With no parameters to explain, the baseline score of 4 applies; the description correctly avoids adding unnecessary 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 states a specific verb and resource: 'Get IP/domain warm-up progress and today's remaining send capacity.' This clearly distinguishes it from sibling tools like get_deliverability_score or verify_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 provides clear context by warning that exceeding warm-up capacity leads to throttling or blocklisting, implying the tool should be used to check capacity before sending. However, it does not explicitly name alternatives 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?

The description discloses key behavioral traits beyond annotations: the 5,000-call limit, the update-rather-than-duplicate semantics, and the per-row result with rejection reasons. Since annotations only contain false hints and don't describe behavior, the description carries the full burden and does so well.

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 that efficiently communicate the core action, limits, behavior, and return format. No redundant or 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?

The description is sufficient given the tool's moderate complexity (2 params, nested array) and lack of output schema. It explains what the tool returns (per-row results), handles the upsert behavior, and sets expectations for scale, covering the main context an agent needs.

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

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

The input schema already provides complete descriptions for both parameters (contacts with max 5000, update_existing with default true), covering 100% of the schema. The description reinforces the update behavior but adds little specific parameter semantics beyond what the schema 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 a specific action ('Bulk-import up to 5,000 contacts') and resource (contacts). It differentiates from sibling tools like create_contact and update_contact by emphasizing the bulk nature and the upsert behavior of updating existing addresses.

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 for when to use the tool: for bulk import of many contacts at once, noting it updates existing contacts rather than creating duplicates. However, it doesn't explicitly mention alternatives like using create_contact for single imports or update_contact for individual updates, so it lacks explicit exclusions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable context about what is returned (per-variant results and winner selection status), which is absent from annotations. However, it does not disclose behavioral details such as pagination behavior or potential performance implications, though the schema partially covers pagination via page/limit parameters.

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

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

The description is a single, concise sentence that is front-loaded with the action ('List') and resource. It contains no filler, redundant words, or restatement of the title. Every word adds value, making it an efficient and well-structured description.

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

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

The tool has no output schema, so the description's mention of 'per-variant results and whether a winner has been selected yet' provides essential return-value context. Combined with 100% schema coverage for parameters and annotations confirming read-only/idempotent behavior, the description is mostly complete for a simple list operation. A minor gap is the lack of explicit mention of sort order or default aggregation, but these are not critical for a listing 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%, meaning all three parameters (page, type, limit) already have descriptions. The tool description adds no additional meaning about parameter semantics, such as syntax, defaults, or relationships. Baseline 3 applies because the schema does the heavy lifting, and the description does not detract or add beyond it.

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

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

The description clearly states the action ('List') and the resource ('A/B tests'), and adds specific details about the return content ('per-variant results and whether a winner has been selected yet'). This distinguishes it from sibling tools like create_ab_test (creation) and select_ab_test_winner (selection), as well as other list_* tools.

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

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

The description does not explicitly provide when-to-use or when-not-to-use guidance, nor does it mention alternatives. However, as the only list operation for A/B tests among siblings, its use is implied. The readOnlyHint annotation signals a safe read operation, but the description itself lacks explicit exclusion criteria or comparative context.

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

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

The description adds a critical behavioral trait not covered by annotations: 'Key secrets are never returned — only metadata.' This is important security-related context that goes beyond the readOnlyHint and idempotentHint annotations, giving the agent confidence about safe usage and output limitations.

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 crisp sentences. The first states the primary action and result, the second adds a crucial caveat. No wasted words, front-loaded with the verb and resource.

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 parameters, no output schema, and simple list behavior, the description fully covers what the agent needs: it names the output fields (scopes, last-used time) and explicitly states what is not included (secrets). The tool is inherently simple, so nothing more 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?

There are no parameters, and the schema is an empty object, so the baseline is 4. The description adds meaning by specifying the implicit scope ('on the account'), which is the only relevant semantic in a parameterless context. No parameter-level detail is needed because there are no 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 uses a specific verb ('List') and resource ('API keys'), and further clarifies the scope ('on the account') and what info is returned (scopes, last-used time). This clearly distinguishes it from the many other list_* sibling tools by naming a unique resource type.

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 alternative tool is named, the description clearly implies this is for retrieving API key metadata when needed, and the account-level scope provides context. There are no sibling tools for API keys, so the absence of an 'instead use X' clause is acceptable, but it doesn't explicitly 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?

The annotations already declare this as a safe, read-only, idempotent operation. The description adds context that the response includes trigger type and active state, which is useful but limited. No contradiction with annotations, but no further behavioral details (e.g., pagination behavior) 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?

A single, front-loaded sentence that immediately states the action and resource. Every word earns its place, with examples in parentheses for clarity. 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 simple list tool with good annotations and full schema coverage, the description is sufficiently complete. It names the resource, gives examples, and indicates two key response fields. It could optionally mention that results are paginated, but the schema already covers this.

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

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

Schema description coverage is 100%, and all three parameters (page, limit, status) have clear descriptions in the schema. The tool description does not add additional parameter meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly states it lists automation workflows, with specific examples (welcome series, re-engagement, drip sequences) and mentions key return fields. This distinguishes it from siblings like get_automation (single) and create_automation/toggle_automation (mutations).

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

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

Usage context is implied by the verb 'list' and the resource 'automation workflows', but the description does not explicitly mention alternatives or when not to use it. It could name get_automation for single automations or toggle_automation for state changes, but it doesn't.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds minor context by mentioning the returned metrics but does not disclose additional behavioral details like pagination limits or response format. This meets the baseline for annotation-covered tools but no more.

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

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

The description is two concise sentences with no redundant information. The verb 'List' is front-loaded, and the content is directly relevant to the tool's purpose and primary use case. 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 list tool with no output schema, the description sufficiently covers the core functionality: what is returned (status, audience size, headline metrics) and how to filter. Combined with the schema's complete parameter documentation and safety annotations, this is nearly complete. Minor omissions like explicit output format are not critical for this scope.

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 all three parameters (page, limit, status) are already documented. The description reinforces the status filter with a practical example ('drafts ready to send or campaigns still sending') but does not add syntactic or semantic details beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool lists email marketing campaigns and specifies the included fields (status, audience size, headline metrics). This distinguishes it from sibling list tools like list_emails or list_automations by clearly focusing on campaigns as the 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 gives a concrete use case: filtering by status to find drafts ready to send or campaigns still sending. This implies when the tool is useful, though it does not explicitly name alternatives or exclusions. For a list tool, this level of contextual guidance is adequate.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is known. The description adds context about returned fields (status, metrics) and filter purpose but doesn't disclose pagination behavior or response structure. With annotations covering safety, a 3 is appropriate.

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

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

Two sentences, front-loaded with the action, and no wasted words. The first sentence states the core function, and the second gives a practical use case.

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

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

For a read-only list tool with good annotations and full schema parameter coverage, the description covers the purpose and a primary use case. It doesn't explicitly mention pagination behavior or response format, but the schema's page/limit params and annotations fill most gaps. Overall, it is complete enough for an agent to select and invoke 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 descriptions cover all 4 parameters at 100%, so the baseline is 3. The description reinforces the status parameter's purpose with a use case but adds no syntax or format details beyond what the schema already provides.

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

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

The description clearly states the action ('List contacts') and the resource ('contacts'), with specific details on what is included (subscription status, engagement metrics). This distinguishes it from sibling list_* tools and other contact-related operations.

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

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

The description provides an explicit use case: filtering by status to find unsubscribed or bounced addresses to exclude from sends. This gives clear context for when to use the tool, though it doesn't 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description does not need to restate safety. It adds context about what is returned (verification status, DKIM/SPF/DMARC records), which is useful for the agent. However, it does not disclose other behavioral traits such as pagination behavior, ordering, or potential errors beyond what the schema implies. With annotations covering the core safety profile, a 3 is appropriate.

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

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

The description is exactly two sentences, front-loaded with the core purpose and a practical use-case. Every word earns its place—no fluff or repetition. It is highly concise while conveying necessary context.

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 paginated list tool with no output schema, the description adequately covers what the tool does and what it returns (verification status and DNS records). It lacks an explicit mention of pagination behavior, but the schema parameters cover that. Given the simplicity and good annotations, the description is nearly complete, though it could be improved by noting the default pagination or that it returns only verified/unverified domains. A 4 is suitable.

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

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

Schema description coverage is 100%, with both 'page' and 'limit' already described in the schema, including defaults. The description does not add any additional parameter semantics or constraints. Since the schema does the heavy lifting, the baseline of 3 is correct.

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 sending domains with verification status and DNS records (DKIM/SPF/DMARC). It uses a specific verb ('List') and resource ('sending domains'), and distinguishes from sibling tools like verify_domain or check_dmarc by focusing on listing rather than verifying or checking. The additional use-case ('Check here first when a send fails with an unverified-sender error') further clarifies its 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 explicit context for when to use this tool: 'Check here first when a send fails with an unverified-sender error.' This gives clear guidance on a specific scenario. However, it does not mention alternatives or explicitly state when not to use it, though the instruction 'first' implies it takes precedence over other diagnostic tools. This is clear context without exclusions, warranting a 4.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, covering safety and idempotency. The description adds the capability of full-text search across subject and body, which is useful. It does not disclose pagination, return format, or rate limits, but given the strong annotations, a score of 3 is appropriate.

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

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

The description is two sentences long, front-loaded with the core action and scope, followed by a purposeful usage note. Every word earns its place with no redundancy or fluff.

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

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

With only three optional parameters, no required parameters, and no output schema, the description covers the essential behavior and use case. It does not describe the return format, but the tool name and purpose imply a list of emails. The guidance on when to use it (unified inbox) adds valuable context, making it sufficiently 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 input schema has 100% description coverage, with all three parameters clearly documented (limit, folder, search). The description does not add additional parameter-level meaning beyond what the schema provides, but it reinforces the search capability ('optional full-text search across subject and body'). Baseline 3 is correct.

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 ('List'), a resource ('emails'), and scope ('from a mailbox folder', 'optional full-text search'). It also explicitly distinguishes itself from the sibling tool list_campaigns ('use list_campaigns for marketing sends'), making it unambiguous which tool to use for email listing.

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: 'Use this for reading the unified inbox' and names an alternative tool for a different use case. It lacks an explicit 'when not to use' statement but effectively excludes marketing sends by pointing to list_campaigns. This is clear enough for an agent to choose correctly.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds context about what the response contains (embed status and conversion counts), which goes beyond annotations. However, it does not disclose pagination limits or default behavior, but given the annotations, the bar is lower and the added context is sufficient.

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 core purpose without any wasted words. It includes the essential information (list signup forms, relevant data fields) and is appropriately sized for the tool's simplicity.

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

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

For a simple list tool with rich annotations and no required parameters, the description is mostly complete. It mentions return fields (embed status, conversion counts) which is useful. It lacks explicit mention of pagination behavior, but the schema parameters (page, limit) imply this. Overall, sufficient for a competent agent.

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

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

Schema description coverage is 100%, so all three parameters (page, limit, status) are already well-documented. The description does not add any additional parameter meaning; in fact, 'embed status' could be confused with the 'status' parameter, since they are different concepts. Baseline 3 is appropriate because the schema carries the load.

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 identifies the resource ('signup forms') along with the key output fields (embed status and conversion counts). This distinguishes it from sibling tools like get_form which retrieves a single form, and get_form_submissions which focuses on submissions. The scope is unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives such as get_form or get_form_submissions. The description implies general use for listing forms but does not specify pagination, filtering scenarios, or trade-offs. There is no when/when-not or alternative naming.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is clear. The description adds behavioral context by specifying that the tool returns conversation threads (not individual messages) and includes status and detected intent — useful details not present in annotations. It does not contradict annotations.

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

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

The description is two sentences: the first states the core action and result, the second gives usage guidance and an alternative. Every word earns its place, and the most important information is front-loaded.

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

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

For a read-only list tool with six optional parameters fully covered in the schema and clear annotations, the description provides sufficient context: it indicates the output shape (threads with status and intent) and the typical use case (triage). No output schema exists, but the description covers the essentials without requiring additional clarifications.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add new parameter semantics beyond the schema, as it only mentions 'status' and 'detected intent' which correspond to the 'status' and 'intent' fields already documented in the schema. It does not explain parameter syntax, defaults, or additional nuances.

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 ('unified-inbox conversations (threads)') and adds the key scope detail that these are threads with status and detected intent. It also explicitly distinguishes from list_emails, making the tool's purpose unambiguous and differentiating it from a sibling.

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

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

The description provides explicit when-to-use guidance: 'Use this for triage; use list_emails for individual messages in a folder.' This clearly states the intended use case and names the alternative tool for a different scenario, offering direct decision support.

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

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

Annotations already provide the safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false). The description adds the detail about sync status but does not disclose additional behavioral traits such as pagination behavior or data freshness. No contradiction with annotations.

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

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

The description is a single, front-loaded sentence that directly states the tool's purpose and included information. There is no redundant or extraneous text.

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

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

The tool is simple, with pagination parameters well-documented in the schema and safety covered by annotations. The description mentions 'sync status', giving the agent a clear idea of the expected output content. It could be slightly more explicit about the return format, but overall it is sufficiently complete for a list 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?

Both parameters (page, limit) are fully described in the input schema with default values. The description does not add any additional parameter context, so the schema carries the full burden, resulting in the baseline score of 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 states the verb 'List', the resource 'connected third-party integrations', and the outcome 'sync status'. It distinguishes itself from sibling tools like get_integration (singular) and toggle_integration by focusing on the collective listing of integrations.

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 communicates its purpose (enumerate all connected integrations and their sync status), making its use case obvious. However, it does not explicitly mention when to use this tool versus alternatives like get_integration, or provide any exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safe read-only nature is covered. The description adds 'ready-made' but does not disclose additional behaviors like pagination limits or search behavior, which are left to the schema. No contradiction with annotations.

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

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

The description is a single, focused sentence that front-loads the action and resource. No unnecessary words, and it earns its place.

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

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

For a simple, optional-parameter listing tool with strong annotations and full schema coverage, the description is adequately complete. It does not explain return format, but that is not essential for this low-complexity tool.

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

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

Schema description coverage is 100%, with clear descriptions for page, limit, search, and category. The description adds no additional parameter semantics beyond what the schema already provides, so it meets 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 uses a specific verb 'Browse' and clearly identifies the resource: 'MisarMail template marketplace for ready-made email and automation templates.' It distinguishes from sibling tools like `list_templates` (likely user's own templates) and `get_marketplace_item` (single item).

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 this is for discovering public marketplace templates, which sets context against sibling tools. However, it does not explicitly state when not to use it or name alternatives, so it lacks explicit exclusions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, indicating a safe read operation. The description adds valuable behavioral context by explaining that sandbox intercepts sends instead of delivering them, and that the emails are 'captured', which goes beyond the annotation metadata.

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

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

The description is two sentences with no wasted words. The first sentence clearly states the action, and the second adds actionable purpose without redundancy. It is well-structured and front-loaded.

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

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

For a zero-parameter listing tool with no output schema, the description is complete. It explains what it does, why it exists (sandbox behavior), and when to use it, making it self-sufficient for an agent to select and invoke 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 tool has zero parameters, so the schema fully covers parameter semantics. The description doesn't need to add parameter details, and the baseline for zero-parameter tools 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 clearly states the tool lists emails captured by sandbox mode, using the specific verb 'list' and resource 'sandbox sends'. It distinguishes itself from sibling tools like list_emails by explicitly mentioning 'sandbox mode', 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 explicit usage context: 'use it to verify templates and automations without emailing anyone.' While it doesn't explicitly name alternatives like list_emails, the sandbox mode framing clearly implies when to use this tool instead of standard email list tools.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, covering the safety profile. The description adds context by noting that it returns variable placeholders, which is useful for template selection. No additional behavioral traits are disclosed, but the bar is lower due to annotations.

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

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

The description is two sentences, with the primary action stated first. Every word earns its place; there is no redundancy or filler. It is appropriately sized for the tool's complexity.

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

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

The tool is a simple read-only list operation with no output schema. The description explains what it does and why, while the annotations cover safety aspects. Pagination and filtering are handled by the schema. It is complete enough 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?

The input schema has 100% description coverage for all three parameters (page, type, limit). The description itself does not add parameter-specific details beyond the schema, but it reinforces the tool's purpose. Given the high schema coverage, 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's function: 'List saved email templates with their variable placeholders.' It uses a specific verb ('List') and resource ('saved email templates'), and further clarifies the use case ('pick one for a campaign or transactional send'). This distinguishes it from sibling tools like create_template or render_template.

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 by stating the purpose is to pick a template for a campaign or transactional send. It does not explicitly mention alternatives or when not to use it, but the provided context is sufficient for a simple list 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?

Annotations already declare read-only and idempotent. Description adds that it returns HTML and subject, clarifying the behavioral output without contradicting annotations.

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

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

Two sentences, direct, with no filler. Front-loads the primary function and adds usage context.

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

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

Given the simple tool, annotations, and full schema, the description covers purpose, usage, and output. No missing critical context.

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

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

Schema fully describes both parameters with examples; description adds little beyond schema, aligning with baseline 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?

Clearly states the action (render), the resource (template), the input (sample variables), and the output (HTML and subject). Distinguishes from sibling creation/sending tools by framing it as a preview.

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

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

Explicitly says to use for previewing personalisation before sending, which indicates the appropriate context. Does not name alternative tools but the 'before sending anything' provides clear when-to-use guidance.

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

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

The description adds behavioral context beyond annotations by explaining that sender/threading headers are auto-derived from the original message, so the caller doesn't need to supply them. Annotations indicate a non-read-only, non-idempotent, non-destructive operation, and the description does not contradict this. It doesn't disclose the immediate send behavior, but that's reasonably implied by 'reply'.

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 short sentences, front-loaded with the core purpose and then a helpful detail. No wasted words. It is concise and well-structured.

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

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

For a simple tool with 3 parameters and no output schema, the description covers the essential context: it replies to an existing thread, derives sender/threading, and requires only the body. Annotations handle side-effect expectations. It doesn't explain the response format or what happens if both html and text are provided, but that's not critical for a straightforward reply action. Overall, it's adequately 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 input schema already covers all three parameters with descriptions (html, text, email_id). The description adds that only the body is required, implying that html/text are the body and email_id identifies the original thread. However, this is somewhat redundant with the schema, and the phrase 'only the body is required' could be slightly misleading since email_id is also required. The description adds marginal value over 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's function: 'Reply to an existing email thread.' This distinguishes it from sending a new email, especially given the sibling send_email. It also specifies the resource (existing email thread) and the action (reply). This is specific and unambiguous.

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

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

The description gives clear context for use: replying to an existing thread. It also notes that sender and threading headers are derived, so only the body is needed, which guides the user on what to provide. However, it does not explicitly mention when not to use it (e.g., for new emails, use send_email), though the phrase 'existing email thread' implies that.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds meaningful context about the audit's scope and the 'prioritized findings' return, but does not disclose additional side effects or edge-case behaviors. Given the strong annotations, 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 two sentences, front-loaded with the core action ('Run a full deliverability audit'), followed by a clear list of covered areas and the return value. Every sentence earns its place with no filler.

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

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

For a tool with no parameters, strong annotations, and no output schema, this description is sufficient. It explains the tool's purpose, scope, and return type ('prioritized findings'), giving an agent enough context 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 input schema has zero parameters, so the description does not need to document parameter semantics. The baseline for 0 params is 4, and the description adds no irrelevant param info, instead focusing on the tool's purpose and output.

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 and resource: 'Run a full deliverability audit' and enumerates the exact areas covered (authentication, domain reputation, list hygiene, content signals, blocklist status). This differentiates it from sibling tools like check_dmarc or get_deliverability_score by emphasizing comprehensiveness and prioritized findings.

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 explicit guidance is given on when to use this tool versus alternatives like check_dmarc or get_deliverability_score. The word 'full' implies a comprehensive audit, but the description does not name alternatives or exclusions, leaving usage as 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?

The description explicitly discloses that this triggers a real send to held-back recipients and cannot be undone, going beyond the bare destructiveHint and idempotentHint flags. It adds crucial behavioral context about what get destroyed (the holdout audience's state).

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

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

Two sentences, front-loaded with the core action and followed by the critical irreversible consequence. Every word earns its place with zero waste.

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

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

The description is complete for a simple destructive action, covering purpose and key consequences. It omits output/error details, but with no output schema and effective annotations, this is a minor gap.

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

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

The input schema fully documents all three parameters, including the metric enum, with 100% coverage. The description adds no additional parameter-specific meaning, 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 clearly states the action (select winning variant) and its consequence (send to remaining audience). It distinguishes itself from sibling tools like create_ab_test and send_campaign by specifying the A/B test context and the real send.

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 (after deciding a winner in an A/B test) and emphasizes the irreversible send, but it does not explicitly name alternatives or when not to use. The context is clear enough for an AI agent to select it appropriately.

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

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

Annotations already indicate destructiveHint=true, and the description adds important context: this sends real email that cannot be undone once started. It also advises pre-confirming the audience, which goes beyond the annotation and helps the agent understand consequences.

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

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

Two sentences with no fluff. The primary action and key caveat are front-loaded, making it easy to scan and understand.

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 destructive nature and 2 parameters, the description covers the essential actions, scheduling option, and irreversible consequence. It doesn't explain what happens after scheduling or possible errors, but no output schema exists and the annotations fill safety gaps, so it is sufficiently complete for typical 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?

Schema description coverage is 100%, so the schema already documents both campaign_id and scheduled_at. The description rephrases scheduled_at's purpose ('schedule it for a future time') but adds little beyond the schema's own 'ISO 8601 timestamp to schedule instead of sending immediately'.

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: sending a campaign immediately or scheduling it via scheduled_at. It distinguishes from siblings like send_email by emphasizing 'real email to real recipients' and campaign-specific context, and it references get_campaign for 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 provides clear usage context: use to send or schedule a campaign, with scheduled_at for future sends. It advises confirming the audience with get_campaign first, but does not explicitly name alternative tools like send_email for single emails, so exclusions are not fully 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?

Annotations already define this as a write, non-idempotent operation. The description adds the return behavior ('Returns the message ID and queue status') and reiterates the verification requirement, but doesn't disclose rate limits, delivery guarantees, or queuing specifics beyond the phrase 'queue status.'

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 efficient sentences: the first states purpose and prerequisite, the second provides a cross-tool reference and return value. No wasted words, and key information is front-loaded.

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

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

Given the tool's complexity (12 params, nested objects, no output schema), the description covers purpose, prerequisite, and return value. It could mention that HTML/text bodies must be provided, but the schema handles parameter-level detail, making the description sufficiently complete.

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

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

Schema description coverage is 100%, so the baseline applies. The description reinforces the from.email verification requirement already present in the schema, but adds no new parameter syntax or relationships beyond what the schema 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 uses a specific verb+resource ('Send a transactional email') and clearly states the action. The word 'transactional' distinguishes it from sibling tools like send_campaign or reply_to_email, 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 clear context by specifying 'transactional email' and gives a concrete prerequisite: 'from.email must match an email account you have already verified — use list_domains to check which sender domains are available.' It doesn't explicitly exclude campaigns, but the transactional label effectively differentiates from send_campaign.

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

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

Annotations already declare non-read-only, non-destructive, and idempotent. The description adds valuable behavioral context by stating that activating starts enrolling contacts and sending, which is a side effect beyond the schema. No contradiction with annotations.

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

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

Two concise sentences, front-loaded with the main action and immediately followed by a clarifying behavioral detail. No redundant words or 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 toggle tool with two well-documented parameters, non-destructive/idempotent annotations, and no output schema, the description sufficiently conveys purpose and key side effects. It lacks only explicit mention of pausing behavior, but 'pause' is clear enough.

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

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

Schema coverage is 100%, with both 'automation_id' and 'active' fully described in the schema. The description adds no additional parameter details, so it meets the baseline for high schema coverage without needing to 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?

Description uses specific verb 'Activate or pause' with resource 'automation' and clarifies the effect of activating: 'starts enrolling contacts and sending on the configured schedule.' This clearly distinguishes from sibling tools like create, get, or list automations.

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

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

The description clearly states the tool changes the active state of an automation, indicating when to use it. It does not explicitly list alternatives or exclusions, but the purpose is unambiguous enough that an agent can infer appropriate usage.

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

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

Annotations already indicate idempotent and non-destructive behavior. The description adds valuable context beyond annotations by explaining that disabling stops all syncing but preserves stored credentials, providing a more complete safety profile without contradicting the annotations.

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

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

The description is two concise sentences, front-loaded with the primary action and immediately followed by the key side effect. Every word earns its place with no repetition of schema details.

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

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

For a simple toggle tool with two parameters and no output schema, the description is nearly complete. It covers the core behavior and a significant side effect. The only minor gap is not mentioning what happens on unsuccessful toggles (e.g., invalid integration ID), but this is not essential for correct invocation.

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

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

The input schema fully describes both parameters (integration_id and enabled). The description goes further by explaining the consequence of 'false' for enabled, saying disabling stops syncing but preserves credentials, which enriches the parameter semantics beyond the schema's simple 'true to enable, false to disable'.

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 'Enable or disable an integration' with a specific verb and resource. It distinguishes from sibling tools like toggle_automation by explicitly targeting integrations, and the added side effect (stops syncing, preserves credentials) further clarifies the scope.

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

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

The description implies when to use this tool (when you want to toggle an integration's enabled state) but does not explicitly mention alternatives or when not to use it. The context is clear enough for basic selection, yet it lacks the explicit guidance seen in top-tier descriptions.

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

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

Annotations already indicate readOnly=false, idempotent=true, and destructive=false. The description adds a specific behavioral consequence: setting status to 'unsubscribed' immediately excludes the contact from every future campaign, which is not captured by annotations or schema.

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

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

Two sentences, front-loaded with the core action and a key side effect. No fluff or repetition of schema details. 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?

Given the 9 parameters, nested objects, and no output schema, the description covers the essential purpose and the most important behavioral consequence. It doesn't explain the return value, but for an update tool, the absence is acceptable given the annotations and schema coverage.

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 meaningful context beyond schema by explaining the real-world effect of the 'status' parameter, particularly the unsubscribed option. It also reinforces the identifying role of 'email'.

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

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

The description states a clear action ('Update an existing contact') with a specific identifier ('by email address') and highlights a key capability ('including changing subscription status'). This distinguishes it from sibling tools like create_contact and list_contacts.

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 (use when updating a contact) and mentions the identifier requirement, but it does not explicitly state when to prefer this over alternatives or provide exclusions. No direct references to 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?

Annotations already declare the tool as read-only, open-world, idempotent, and non-destructive. The description adds value by explaining the 'open=true' behavior (opens checkout page) and detailing the informational content (plan, quotas, upgrade unlocks). This goes beyond the annotations without contradicting them.

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

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

The description is concise (two sentences) and front-loaded with the primary purpose. The second sentence adds the usage guidance and parameter hint without 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 tool's simplicity (2 optional params, no output schema), the description covers the essential aspects: what it shows, when to call it, and how to optionally open checkout. It provides enough context for an agent to invoke the tool appropriately.

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

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

Schema description coverage is 100%, with both parameters ('open' and 'plan') already described in the input schema. The description mentions the 'open' parameter but adds no additional meaning beyond the schema. Baseline of 3 is appropriate given the schema's thoroughness.

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: 'Show the current MisarMail plan, how much of each quota is left, and what upgrading unlocks.' It uses a specific verb ('Show') and specific resources (plan, quotas, upgrade benefits), making it distinct from 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?

The description provides explicit usage context: 'Call it any time — not only after hitting a limit.' This indicates when to use the tool. However, it does not mention alternatives or when not to use it, though the tool's unique purpose makes exclusions less critical.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, establishing a safe, non-mutating profile. The description adds valuable context about the specific validation checks (syntax, MX, disposable, role-account) without contradicting annotations. It doesn't mention rate limits or output format, but for a read-only validation tool this is acceptable.

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 front-load the purpose and include a practical usage tip. Every word earns its place, with no filler or redundant restatement of the title or annotations.

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

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

With only one parameter, no output schema, and complete annotations, the description covers the tool's behavior, usage scenario, and validation scope. It is fully adequate 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% for the single 'email' parameter, which is described as 'Email address to validate'. The description offers no additional parameter-level details (e.g., format, length, normalization), but the schema already fully explains the parameter. 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 a specific verb ('validate') and resource ('email address'), and enumerates the exact checks performed (syntax, MX records, disposable-domain and role-account detection). This distinguishes it from sibling tools like check_dmarc or verify_domain, 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 a clear use case: 'before sending' and 'to protect sender reputation on imported lists.' It does not explicitly name alternatives, but the context is sufficient to infer when to use this tool versus others. This is clear guidance even 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?

The description discloses the side effect of marking the domain as verified if DNS resolves, and notes DNS propagation time. These go beyond the annotations, which only state idempotency and non-destructiveness. It complements the annotations without contradiction.

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

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

Two sentences, no fluff. The first sentence states the action; the second provides retry guidance. Perfectly sized.

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

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

For a simple, single-parameter idempotent tool, the description covers the core behavior, side effect, and retry timing. It doesn't describe the return value, but given the absence of an output schema, the description's coverage is adequate for an agent to invoke correctly.

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

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

The input schema has a single parameter with a description ('Domain ID returned by add_domain') covering 100% of the schema. The description adds no extra parameter semantics, which is acceptable given the schema's clarity; baseline of 3 applies.

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

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

The description states 'Re-check a domain's DNS records and mark it verified if they resolve' which is a specific verb ('re-check', 'mark') and resource ('domain's DNS records'). It clearly distinguishes from siblings like check_dmarc which targets a specific record type. The purpose is 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 phrase 'Safe to retry — DNS propagation can take up to 48 hours' provides clear context for when to use this tool: after adding a domain or if prior verification failed, as DNS may not have propagated yet. It does not explicitly name alternatives, but gives a clear usage scenario, so it earns a 4.

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