MisarMail MCP Server

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

Annotations indicate a write operation (readOnlyHint=false), and the description confirms by stating it adds a domain. It additionally reveals the return value (DNS records) and a critical temporal constraint (cannot send until verification), going well 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 two sentences, front-loading the core action and output in the first sentence, with an important qualification in the second. Every sentence adds value with no redundancy.

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

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

For a simple, single-parameter tool with no output schema, the description fully covers what the tool does, what it returns, and the follow-up required. It is complete given the low complexity and rich structural information from the schema and 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 already provides a clear description for the single parameter ('Domain to add, e.g. example.com') with 100% coverage. The description adds no extra meaning for the parameter, meeting the baseline expectation but not exceeding 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 uses a specific verb ('Add') and resource ('sending domain') and clearly states the additional output ('return the DNS records to publish'). It distinguishes from sibling tools like verify_domain and check_dmarc by focusing on 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 provides explicit post-condition context ('The domain cannot send until those records are live and verify_domain succeeds'), guiding the agent to follow up with verify_domain. However, it does not explicitly contrast with alternatives or state when not to use this tool.

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

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

The description goes well beyond annotations (readOnlyHint: false, destructiveHint: false, idempotentHint: true) by detailing the reversible nature, that content is unchanged, the message can be found again, it doesn't mark read or reply, and it requires an API key. This adds substantial behavioral context not available from annotations alone.

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 and well-structured. It opens with the core action, then provides usage context, safety details, and constraints in a logical flow. Every sentence adds value without redundancy, and the length is appropriate 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 simple tool with one parameter and no output schema, the description is complete. It covers the effect, side effects (non-destructive, reversible), repeatability, API key requirement, and scope (exactly one message), giving the agent all necessary context to use 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 single parameter 'id' is already well-described in the schema ('Email ID to archive') with 100% coverage. The description does not add additional parameter meaning beyond confirming the action, but the schema adequately covers it, 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 tool's function: 'Move one email out of the inbox and into the archive.' This is a specific verb+resource action that distinguishes it from siblings like get_email, reply_to_email, or send_email, which perform different operations on emails.

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

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

Explicit usage guidance is provided: 'Use it to clear handled mail from the working inbox.' The description also clarifies what it does NOT do (mark read, reply, notify sender), and notes it is reversible, non-destructive, and safe to repeat, helping the agent decide when to invoke it vs. alternatives.

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

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

Annotations already convey idempotentHint=true (safe to retry) and destructiveHint=false (no destruction). The description adds important behavioral context: it consumes AI credits (a cost/resource implication) and implies it processes a batch (max 50). No contradiction with annotations.

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

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

Two concise, front-loaded sentences. The first sentence states the core function, the second provides critical usage guidance. Every word adds value; 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?

Given the low complexity (1 param, no output schema), the description is sufficient. The agent understands input, behavior (AI credit consumption), and constraints (max 50). A minor gap: the output format (returned labels/priority) is not described, but since there is no output schema, this is a soft miss rather than a hard requirement.

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% (only one parameter, 'email_ids', well-described with array type, string items, and max 50 limit). The description reinforces that these are emails 'to categorise' and adds the consumption cost context, which helps the agent decide which IDs to pass. No additional parameter documentation is needed beyond what's already provided.

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 resource ('batch of inbox emails') and states the outcome ('label intent and priority'). This clearly distinguishes it from siblings like 'archive_email', 'reply_to_email', or 'get_email', which handle different operations on emails.

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

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

The description explicitly advises to only pass emails that need triaging due to AI credit consumption. This provides clear when-to-use guidance. However, it does not explicitly mention when NOT to use this tool (e.g., for already categorized emails) or name specific alternative tools, though the sibling list provides implicit 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?

Annotations already convey read-only, idempotent, and non-destructive behavior. The description adds context beyond annotations by noting the check is 'live,' and that it 'report[s] alignment problems with the exact record to publish.' This provides actionable insight into what the tool does with the data it fetches, which is not covered 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 two sentences long, front-loads the core purpose, and contains no filler or redundancy. Every sentence contributes critical information: what records are checked, what is reported, and scope of applicability.

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 full annotations and a single parameter, the description is largely complete. It covers the DNS record types checked, the output (alignment problems and publishable record), and domain scope. The absence of an output schema is acceptable since the description adequately describes what the tool returns.

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 single parameter described as 'Domain to check, e.g. example.com.' The description adds value by stating 'Works for any domain, not only your own,' which clarifies that the domain parameter is not restricted to the user's own domains—a meaningful addition beyond the schema 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 clearly states the tool checks live SPF, DKIM, and DMARC DNS records for a domain and reports alignment problems with the exact record to publish. It uses specific verbs ('Check', 'report') and identifies the resource (DNS records for a domain), distinguishing it from sibling tools like verify_domain or 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 description states 'Works for any domain, not only your own,' clarifying domain scope and implying broad applicability. However, it does not explicitly mention when to use this tool versus alternatives (e.g., verify_domain), nor does it provide any 'when not to use' guidance or prerequisites.

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

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

Annotations already declare destructiveHint and idempotentHint, but the description adds critical nuance: it affects only sandbox mail (not sent campaigns/contacts), irreversibility is emphasized, and clearing an empty sandbox is harmless. This goes beyond the structured hints and fully discloses side effects and scope.

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

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

The description is moderately long but every sentence adds value: action, context, warning, scope, parameter confirmation, prerequisite (API key), idempotence note, and advice. It is front-loaded with the action and then logically expands. Slightly verbose but not wasteful, so 4 is fair.

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 destructive tool with no parameters, this description is fully complete: purpose, effect, scope limitations, irreversibility, prerequisite (API key), idempotence, and recommended pre-call action are all covered. It even addresses the edge case of an already-empty sandbox. Nothing essential is missing.

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

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

There are zero parameters, and the description explicitly states 'Takes no parameters and offers no filter,' which is redundant but reassuring given the zero-parameter schema. Since there is nothing to explain, the baseline of 4 is appropriate without any parameter-specific guidance needed.

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

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

The description opens with a specific, action-oriented statement ('Delete every email captured in the sandbox') that clearly identifies the resource and operation. It distinguishes itself from sibling read tools like list_sandbox_sends by emphasizing the destructive nature and all-or-nothing 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 explains when the sandbox is used (testing interception) and explicitly advises reading needed data before calling. It also clarifies there is no filter or parameter, making the all-or-nothing trigger unambiguous. This is better than a typical 'use when you need to delete' and directly addresses preconditions.

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 idempotentHint=true and destructiveHint=false, so the description need not restate those. The description adds value by stating the return value (MX record) and the overall behavior (configuring routing). However, it does not disclose side effects like overwriting existing routing or DNS requirements, so transparency is adequate but not enhanced.

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 wasted words. The first sentence immediately states the purpose and outcome, the second sentence declares the return value. Highly efficient.

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

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

With 100% schema coverage, annotations, and no output schema, the description covers the core purpose and return value. It is nearly complete, though it could mention prerequisites like domain verification. Given the context signals, this is a strong description.

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

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

Schema coverage is 100% with clear descriptions for all three parameters. The description's text ('Configure inbound email routing for a subdomain') aligns with the schema but does not add new meaning beyond what the parameter descriptions already provide. 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 verb 'Configure' and the resource 'inbound email routing for a subdomain', and specifies the outcome 'replies land in the MisarMail unified inbox' and the return value 'MX record'. This distinguishes it from siblings like add_domain, verify_domain, and send_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?

No guidance is provided on when to use this tool versus alternatives. It does not mention prerequisites (e.g., domain must be added via add_domain or verified via verify_domain), nor does it indicate when not to use it. The agent has no explicit context for decision-making.

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

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

Annotations provide readOnlyHint=false and destructiveHint=false, which are consistent with a creation tool. The description adds value by disclosing the two-phase behavior (sample sent first, winner later) and implicitly that the tool does not automatically select the winner. 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 with no wasted words. The first sentence states the purpose, the second describes the process. Information is front-loaded and easy to parse.

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

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

No output schema is provided, and the description does not mention the return value (e.g., test ID). Prerequisites like campaign existence are not mentioned. The description explains the process but omits key context about what the tool actually returns.

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 parameter descriptions. The description adds minimal value beyond the schema, only hinting at the process. Baseline 3 is appropriate as the schema already documents the parameters well.

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 'Create' and the resource 'A/B test on a campaign', and explains the two-phase process (sample then winner). It distinguishes from sibling tools like 'select_ab_test_winner' and 'list_ab_tests' by describing the creation action.

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

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

The description implies the tool is used to start an A/B test and mentions the process flow, but it does not explicitly state when to use this tool versus alternatives (e.g., using 'select_ab_test_winner' later). No exclusions or prerequisites are given.

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

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

Annotations indicate a write operation (readOnlyHint=false) but provide no other behavioral clues. The description adds critical behavior: 'Created paused by default'. This is a key trait that influences when and how the tool should be used. It doesn't disclose return value or error cases, but the paused behavior is significant and well-stated.

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

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

The description is two sentences with no wasted words. The first sentence states the purpose, the second adds the critical behavioral note. Front-loaded and efficient – 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, 2 required, nested objects, and no output schema, the description covers the primary purpose and the important paused-by-default behavior. However, it lacks mention of the return value (likely the created automation ID) and doesn't clarify that steps are optional despite being referenced as a core component. Still, the schema fills many gaps, making this description adequate.

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

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

Schema coverage is 100%, so baseline is 3. The description does not add meaning beyond the schema; it simply restates 'trigger and an ordered list of steps' which is already present in the schema descriptions. It provides no examples, clarifies optional fields (steps is not required but is implied), or explains trigger_config. No extra semantic value is added.

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

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

The description clearly states the action ('Create an automation workflow') and specifies the key components ('from a trigger and an ordered list of steps'). It distinguishes the tool from siblings like toggle_automation by noting that the automation is created paused by default, requiring a separate activation 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 explicitly tells the agent when to use this tool (to create an automation workflow) and what to do afterwards ('call toggle_automation to activate once the steps are reviewed'). It also implies a workflow: create, review, then activate. This provides clear context for usage compared to alternatives.

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

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

The description discloses a critical behavior: 'Creating never sends' and that the campaign is created as a draft. This adds context beyond the annotations (which only indicate non-read-only, non-idempotent, non-destructive) and clarifies the lack of immediate sending side effects.

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

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

The description is extremely concise—two sentences—and clearly conveys the core purpose and the key behavior (no sending). It avoids superfluous words and is well-structured for quick understanding.

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 operation with no output schema, the description adequately explains that it creates a draft and does not send, but it omits details about the return value (e.g., campaign ID) and any expected side effects. Given the tool's simplicity, this is acceptable but not highly complete.

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

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

The schema already provides per-parameter descriptions covering all 11 parameters (100% coverage), and the overall description does not add granular details about parameters. It only generically refers to 'content and audience,' which is already implied by the schema. Thus, it adds minimal value 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 'Create a new email marketing campaign as a draft' and explicitly distinguishes it from sending by noting 'Creating never sends — call send_campaign separately.' This makes the purpose unambiguous and differentiates it from the sibling tool send_campaign.

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 guidance to call send_campaign separately once content and audience are confirmed, implying the intended workflow. However, it does not explicitly mention when not to use other related tools (e.g., list_campaigns, update_campaign), but given the context, the guidance is sufficient.

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 implies a write operation ('Add') and mentions a side effect ('records consent'), but does not describe the return value or error behavior. The annotations (readOnlyHint: false) confirm mutation, but idempotency and reversibility are not addressed.

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

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

The description is two concise sentences, front-loaded with the primary action, and includes essential context without unnecessary verbosity.

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

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

The description covers the core action, relevant constraints (consent requirement), and legal implications. Combined with the complete parameter schema and annotations, the context is sufficient for correct usage.

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

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

All 9 parameters have descriptions with types and constraints (e.g., max lengths for phone, source, company, job_title, last_name, first_name). The descriptions are clear enough for an agent to understand each parameter's purpose.

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 'Add a single contact' with a specific verb and resource, and distinguishes it from sibling tools like update_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 provides explicit usage guidance: 'only add addresses that opted in' and warns about sender reputation and legal compliance (CAN-SPAM/GDPR), which helps the agent decide when to use the tool.

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

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

The description discloses that subscribers flow into your contact list, which is an important side effect beyond the immediate creation. Annotations confirm readOnlyHint=false and destructiveHint=false, so the description aligns and adds value by clarifying the side effect. However, it does not mention other potential behaviors like whether it's idempotent, if landing pages have usage limits, or what happens on failure (e.g., duplicate name). With annotations already signaling a write operation, the description does enough to satisfy the bar.

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, efficient and front-loaded: the first sentence states the core action and resource, the second provides the key outcome and side effect. Every sentence adds unique value 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?

There is no output schema, so the description compensates by noting the return of a public URL, which is adequate for a creation tool. However, it does not mention any required permissions, error scenarios (e.g., duplicate name), or behavior of related contacts. Given the moderate complexity (6 parameters) and good schema coverage, the description is sufficient but leaves some questions unanswered.

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 itself documents all parameters thoroughly. The description only adds value by explaining the output ('Returns the public URL') and the side effect ('subscribers flow straight into your contact list'), but does not elaborate on any parameter meaning beyond what is in the schema. Baseline of 3 is appropriate as the description does not need to repeat schema info but also does not add depth.

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 ('Create a hosted landing page with an email capture form' ) and a unique resource type ('hosted landing page'). It mentions a key outcome ('subscribers flow into your contact list'), which adds specificity. However, among siblings there are 'create_form' and 'create_campaign', and the description doesn't explicitly distinguish this landing page tool from those form or campaign creation tools.

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

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

No guidance is given about when to use this tool versus siblings like 'create_form' (for standalone forms) or 'create_campaign'. It does not state prerequisites (e.g., a verified domain) or when not to use it. The context is implied by the name and description, but explicit exclusions or alternatives are absent.

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

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

Annotations mark this as a non-read-only write operation; the description adds context beyond annotations by explaining variable substitution at send time and previewability via render_template. 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 with front-loaded action ('Create a reusable email template') and a follow-up sentence that explains variable behavior and links to a sibling tool. Every sentence earns its place with no redundancy.

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

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

For a create tool with 6 parameters and no output schema, the description covers the core purpose and a key behavioral nuance (variable substitution). It doesn't explain return values, but that's less critical without an output schema; the schema handles parameter details.

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

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

The input schema has 100% coverage with descriptions for all six parameters, so the baseline is 3. The description reinforces the {{variable}} placeholder concept but does not add parameter-specific semantics beyond what the schema already documents.

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

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

The description clearly states 'Create a reusable email template', using a specific verb and resource. It distinguishes itself from siblings like render_template by focusing on creation, and introduces the key personalization feature via {{variable}} placeholders.

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 (to create templates) and explicitly names render_template as the tool for previewing, providing a useful alternative. However, it does not explicitly state when not to use it or compare with other creation tools like create_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?

The description adds minimal behavioral context beyond the existing annotations (readOnlyHint, idempotentHint). It does not disclose aspects like response format, data freshness, or limitations, which are important for a report generation tool.

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

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

The description is two sentences, front-loaded with the core purpose, and wastes no words. Each 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?

Given no output schema, the description should hint at return format (e.g., JSON) or example usage. It covers input well but leaves agents uncertain about output structure, making it minimally complete.

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

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

With 100% schema coverage, the description adds value by explaining the enum options (especially 'send_time_heatmap' with a parenthetical hint) and reinforces the date range concept. This goes beyond the raw 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 generates structured analytics reports over a date range and lists four specific report types. However, it does not differentiate from the sibling 'get_analytics', which may have overlapping functionality, slightly diminishing clarity.

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

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

No guidance is provided on when to use this tool versus alternatives like get_analytics. The description only explains what it does without contextual usage advice.

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 is false and destructiveHint is false, suggesting this is a non-destructive but potentially state-changing operation (generation). The description does not add behavioral details beyond what annotations imply, such as rate limits, token consumption, or whether output is persisted. Without richer annotation context, a moderate score 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, front-loading the core action ('Generate AI subject-line variants') and immediately providing context for downstream use. Every word is functional, and there is no redundancy or filler.

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

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

Given the tool has four parameters, one required, no output schema, and annotations that are present but minimal, the description adequately covers the key use case and suggests integration with 'create_ab_test'. It could be more complete by noting the default tone is 'professional' (implied by schema default), but overall it provides sufficient context for an agent to use the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds value by clarifying that 'topic' is the core input ('what the email is about') and that 'tone' and 'audience' are optional tunings, which aligns with the schema. It reinforces the purpose of 'count' as variant generation quantity but doesn't add novel semantics beyond the schema's own descriptions.

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 generates AI subject-line variants for a campaign topic, with optional tone and audience tuning. It distinguishes itself from siblings like 'create_ab_test' by positioning its output as input for that tool, though it could more explicitly differentiate from other generation or suggestion 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 clear when-to-use context by stating the output is good input for 'create_ab_test', which suggests a specific workflow. However, it does not mention when not to use this tool or indicate alternatives for other subject line generation methods.

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 the specific metrics returned and the grouping behavior, which is consistent with the annotations. It does not contradict them and provides additional context about the nature of the response, though it could mention that the operation is non-modifying (already covered 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 sentence of 25 words that front-loads the core purpose ('Get delivery and engagement analytics'), then enumerates metrics and constraints without redundancy. Every clause adds essential information, making it highly efficient for an agent to parse quickly.

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

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

Given that there is no output schema, the description adequately covers what the tool returns (list of metrics), how data can be scoped (account/campaign), and the grouping options. It does not describe the response structure (e.g., JSON format, nesting) or behavior when no data exists, but for a read-only analytics tool with well-defined parameters, this is sufficient for an agent to decide whether to invoke it.

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 its 5 parameters, so the baseline is 3. The description adds semantic value by listing the exact metrics (sent, delivered, opened, etc.) that the tool returns—information not present in the schema—and by clarifying that campaign_id is optional and defaults to account-wide. This helps the agent understand what kind of data to expect beyond parameter definitions.

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 'Get', the resource 'delivery and engagement analytics', and specifies exact metrics (sent, delivered, opened, clicked, bounced, complained). It also defines scope ('account or one campaign') and grouping ('day/week/month'), which distinguishes it from sibling tools like get_deliverability_score or get_monetization_stats that cover different or narrower aspects.

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

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

The description explains what data the tool returns and the two scopes (account-wide vs. per campaign), but it does not explicitly contrast with similar tools (e.g., get_deliverability_score, get_monetization_stats) or state when not to use it. The agent must infer usage from the listed metrics and parameters; no exclusion criteria or alternatives 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 mark readOnly/idempotent/non-destructive, but the description adds valuable context beyond those hints: 'reading a workflow does not enrol anyone or trigger a step', 'Requires an API key', and the caveat that an automation can be defined but inactive so its state should be checked. This is meaningful behavioral disclosure.

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

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

The description is efficiently written, front-loaded with the main purpose, and every sentence adds useful context. It avoids redundancy and does not drone on, making it appropriately sized for a simple read tool.

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

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

For a one-parameter read-only tool with no output schema, the description is complete: it summarizes the returned content (trigger, steps, settings, counts), gives usage context, notes side-effect-free behavior, and warns about inactive automations. No important gaps remain.

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 single automation_id parameter already described as 'Automation ID (UUID)'. The description reinforces what the tool returns but does not add new parameter-level 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 uses a specific verb and resource: 'Get one automation workflow in full' and details what is included (trigger, steps, enrolment counts). It also distinguishes itself from list_automations by explicitly naming the sibling for listing all 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?

It states exactly when to use the tool ('to understand exactly what an automation will do to contacts before activating it') and provides clear alternatives: list_automations for listing and toggle_automation for starting/pausing. This gives explicit when/alternative guidance.

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

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

Annotations already establish read-only, idempotent, and non-destructive behavior. The description adds return-content context but no additional behavioral traits such as error handling, authentication needs, or rate limits. No contradiction exists.

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

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

The description is a single, focused sentence that front-loads the action and object, then lists the included detail categories efficiently. Every phrase adds value 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 one-parameter read-only tool with no output schema, the description adequately conveys what the caller receives. It could mention error behavior or exact output structure, but the listed categories are sufficient for a tool of this simplicity.

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

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

The schema already fully documents the single parameter campaign_id with type and description. The tool description adds no further parameter-level detail, so the baseline score of 3 applies 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?

The description uses a specific verb and resource ('Get full details for one campaign') and enumerates the returned content categories: content, audience segment, schedule, and delivery statistics. This clearly distinguishes it from list_campaigns and other getter 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 implies use when needing full details of a single campaign, but it does not explicitly state when not to use it or mention alternatives such as list_campaigns. Usage context is clear but exclusionary guidance is absent.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds behavioral context by explaining the two modes of operation (single contact vs. list-wide) and the output fields (engagement score, tier, churn risk), which goes beyond the annotations.

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

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

The description is two sentences, front-loaded with the core purpose, and includes a usage hint. Every word earns its place; no fluff or redundancy.

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

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

Given the tool's simplicity (one optional parameter, no output schema), the description is complete enough. It explains the two modes, the output fields, and the recommended usage context. The only minor gap is that it doesn't specify the format of the output (e.g., JSON structure), but that's acceptable without an output schema.

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

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

The schema already provides 100% coverage for the single parameter (contact_id) with a clear description. The tool description adds value by explaining the behavior when contact_id is omitted, which is not fully captured in the schema. This is a good complement to 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: it retrieves engagement score, tier, and churn risk for a contact, or the lowest-engagement contacts when contact_id is omitted. This is specific and distinguishes it from sibling tools like get_deliverability_score or get_analytics.

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

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

The description provides clear context for when to use the tool ('Use before a re-engagement campaign') and explains the dual behavior based on contact_id presence. It doesn't explicitly mention alternatives, but the context is sufficient for an agent to decide when to invoke 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, fully covering the safety profile. The description adds the return content (score, grade, factors) but no additional behavioral traits beyond what is obvious from the name and schema. The description does not contradict annotations.

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

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

Two sentences, zero wasted words. The first sentence defines the tool's output, and the second gives a clear use case. 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 simple read-only tool with no parameters and no output schema, the description is nearly complete. It specifies the output and a typical use case. It could be slightly more complete by explicitly stating it returns account-level data, but the current text 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?

There are no parameters, so schema coverage is 100% by default. The description adds value by explaining the tool's output (score range, grade, factors) beyond the empty schema. Baseline for 0 parameters is 4, and the description meets that by providing purpose and return details.

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

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

The description clearly states the tool retrieves the account deliverability score (0–100) and letter grade (A–F) along with contributing factors. It explicitly names the output format and scope, and the 'Start here' hint differentiates it from more detailed 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 description includes explicit usage guidance: 'Start here when asked why emails are landing in spam.' This clearly indicates the primary use case. However, it does not explicitly mention when not to use this tool or name alternatives, leaving room for slight ambiguity.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false. The description adds the key side effect 'marks the email as read', which is crucial. It also enumerates what content is returned. It doesn't mention authentication or rate limits, but those are not critical for a simple read-like operation. No contradiction with annotations.

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

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

The description is two short sentences. The first states the purpose and content coverage, the second reveals the side effect. It is front-loaded and contains no filler. 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?

With only one parameter, no output schema, and low complexity, the description fully captures what the tool does, what it returns, and its side effect. Annotations cover safety profile. Nothing essential is missing.

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

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

The schema covers 100% of parameters (only 'id' with description 'Email ID (UUID)'). The description merely repeats the parameter name and doesn't add extra meaning, such as where the ID comes from or format nuances. Baseline 3 is appropriate since the schema already documents 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 (read full content), the resource (single email), and the scope (by ID, including headers, body, attachments metadata). It distinguishes from sibling tools like list_emails which likely provide summary metadata without full content.

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 full content of a specific email is needed). It doesn't explicitly mention alternatives or exclusions, but the context with siblings like 'list_emails' and 'archive_email' makes the usage obvious. A brief 'use this instead of list_emails when you need full content' would be 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?

The description clearly states 'Reads only; the form is not modified and no submission is created,' reinforcing and expanding on the readOnlyHint and destructiveHint annotations. It also adds context that an API key is required and that returning the embed code does not publish anything by itself, which reduces potential misuse concerns.

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

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

The description is front-loaded with the primary purpose and return contents, then moves to usage guidance and safety notes. It is slightly longer than strictly necessary, but every sentence provides useful context—no filler or duplication.

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 no output schema, the description fully covers what is returned (fields, embed code, redirect), when to use it, and why it is safe. The annotations and parameter schema cover the remaining structural details, so nothing important is missing.

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

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

The only parameter, form_id, is already fully described in the schema as 'Form ID (UUID)', giving 100% schema description coverage. The description adds little beyond confirming the tool retrieves one signup form, but since the schema covers the parameter adequately, 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 opens with a specific verb and resource: 'Get one signup form in full,' and enumerates exactly what is returned (fields, embed code, redirect target). It also distinguishes itself from siblings by naming get_form_submissions and list_forms as alternatives for different needs.

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

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

It explicitly states when to use the tool: when needing the embed snippet to install the form or to know which fields are collected before interpreting submissions. It also provides direct exclusions: use get_form_submissions for submitted data and list_forms for the list of forms.

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?

Beyond annotations' read-only/idempotent/destructive hints, description adds important context: personal data sensitivity, no side effects (no deletion, email subscription), API key requirement, and empty-result semantics. This enriches agent understanding beyond structured hints.

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?

Well-structured and front-loaded with purpose. Each sentence adds value (data warning, alternative, read-only, API key, empty result), though slightly longer than minimal. No wasted words.

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

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

For a simple read-only list tool with no output schema, description covers purpose, usage, behavior, prerequisites, and edge cases. Agent has enough to decide correct invocation and expectations.

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

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

Input schema covers all parameters (page, limit, form_id) with descriptions, and schema coverage is 100%. Description adds no additional parameter-level detail, so baseline 3 applies.

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

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

States clearly it lists form submissions with field values. Specific verb+resource and distinguishes from get_form by noting it's for submissions, not form definition.

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?

Provides clear context ('see who signed up and what they told you') and names an alternative (get_form for form definition). Lacks explicit when-not-to-use but conveys usage via the stated purpose and empty-result note.

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, destructiveHint=false, and the description adds genuinely useful behavior beyond that: authentication needs ('Requires an API key'), data-sensitivity handling ('real customer correspondence... treat the contents as confidential'), and payload characteristics ('Returns the whole thread rather than a page, so long conversations return a lot of text'). The description's 'Reads only' claim is fully consistent with annotations — 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?

Five short sentences, each earning its place: purpose, when-to-use, non-behavior, auth, confidentiality, and payload warning. Information is front-loaded and paragraphs are used for scannability. No fluff, no restating of the tool name.

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

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

For a low-complexity tool (1 param, no output schema, no nested objects), the description is entirely sufficient. It covers ordering, scope, confidentiality, authentication, and response-size expectations. There's little left unknown, making this description more than complete for its complexity level.

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

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

With 100% schema coverage, baseline is 3, but the description adds meaningful orientation for conversation_id by clarifying its granularity ('one inbox conversation'), the full-fetch semantics ('every message'), and the chronological ordering ('oldest first'). This preemptively answers the pagination and scope questions an agent would otherwise need to infer.

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?

"Get every message in one inbox conversation, oldest first, with sender and timestamp" uses a specific verb + resource with precise scoping and output ordering. It explicitly contrasts itself with the sibling listing tool ('it is the detail view behind a conversation listing'), and excludes behaviors of mutation siblings ('does not send, reply, or mark anything as read'), unmistakably differentiating it from list_inbox_conversations, send_email, and reply_to_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?

Gives excellent when-to-use guidance ('read a thread in full before replying or summarising') and clear when-not-to-use boundaries ('does not send, reply, or mark anything as read'). It would reach 5 if it explicitly named an alternative tool (e.g., list_inbox_conversations or send_email) as the recommended path for those adjacent tasks.

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?

Beyond the readOnlyHint and idempotentHint annotations, the description adds concrete behavioral guarantees: it reads only, does not re-run a sync, and does not change any setting. It also clarifies that the response indicates permissions, not actual success, which is a valuable nuance.

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

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

The description is well-structured with a clear primary statement, usage guidance, and clarifying caveats. It is slightly verbose but every sentence adds value, so it remains efficient and readable.

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 adequately explains what the response contains (configuration, scopes, last sync result) and notes the read-only behavior. Since no output schema is provided, these details are sufficient for an agent to understand the tool's outcome. It could be slightly more explicit about the response format, but overall it is 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 only parameter, integration_id, is described in the schema as 'Integration ID' which is clear. The tool description does not add further detail, but given the schema coverage is 100% for a simple ID, no additional explanation is necessary. Baseline score for high schema coverage is appropriate.

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

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

The description clearly states it retrieves a single integration's full details (configuration, scopes, last sync result) and explicitly contrasts with list_integrations, which provides an overview. The verb 'Get' and resource 'integration' are specific, and the distinction removes ambiguity.

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 explicit use cases: diagnosing unhealthy integrations from list_integrations and checking granted scopes before relying on a capability. It also clarifies what it does not do (re-run syncs, change settings), guiding appropriate invocation.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, but the description goes further by adding the API key requirement, the caveat that nothing changes until the user acts, and the warning about third-party content not being verified. This adds genuine behavioral context 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 well-structured in three short paragraphs: what it does, when to use it, and a trust caveat. Each sentence earns its place, though the explanation is slightly more expansive than strictly necessary for such a simple tool.

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

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

For a one-parameter, read-only tool with rich annotations and no output schema, the description covers the essential context: purpose, usage step in a workflow, authentication, and risk caveat. It is fully complete for an agent to decide when and how to invoke it.

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 only parameter, item_id, is fully described in the schema as 'Marketplace item ID'. The description does not add additional parameter-level detail, but this is acceptable because schema coverage is 100%, so the baseline score of 3 applies.

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

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

The description clearly states the tool retrieves one marketplace listing in full, including preview, author, and installation instructions. It distinguishes itself from list_marketplace_items by focusing on a single item, so the purpose 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?

It explicitly instructs to use this tool after list_marketplace_items to inspect a template before adoption, and clarifies that it is a read-only step that does not install anything. This provides strong contextual guidance and differentiates it from mutation 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 and idempotentHint, but the description reinforces this in domain terms ('Reads only; no billing state is changed and no subscriber is charged') and adds new behavioral details: API key required, revenue in minor currency units, and the zero-subscriber edge case. This goes beyond the annotation hints.

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

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

Three tightly focused sentences: purpose, usage guidance, and safety/caveats. Every sentence earns its place without repeating schema or annotation fields. The structure front-loads the core function and then layers context efficiently.

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

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

For a simple read-only stats tool with one optional parameter and no output schema, the description covers purpose, usage boundaries, authentication, unit handling, and an edge case (zero subscribers). It also states what it cannot do, making it self-contained for an agent to decide when to invoke it.

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

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

The schema fully documents the only parameter (period with enum values and default), so the description adds no further parameter-level meaning. The 'trailing window' phrase is consistent with but does not expand on the schema's 'Time window' description, 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 retrieves newsletter monetization figures (paid subscribers, monthly recurring revenue, churn, revenue trend) with a specific resource scope. It explicitly differentiates from get_revenue_attribution, which handles per-campaign breakdowns, making it distinct among siblings.

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?

Provides a direct use case ('how is the paid newsletter doing') and an explicit alternative when per-campaign breakdown is needed ('use get_revenue_attribution for that'). Also mentions the API key requirement, giving clear prerequisites for invocation.

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

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

Annotations already declare readOnlyHint and idempotentHint true, and destructiveHint false, so the description doesn't need to reiterate those. It adds context by naming specific outputs (revenue per campaign, per contact, average order value), which helps the agent understand what to expect. However, no mention of any side effects or limitations (e.g., data freshness, permissions) beyond annotations.

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

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

The description is a single sentence that concisely conveys the tool's purpose and key metrics. It is well-structured and front-loaded with the core action. Every word contributes value, making it efficient and easy to parse.

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

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

Given the tool has no output schema, the description partially compensates by listing output fields (revenue per campaign, per contact, average order value). Annotations cover safety and idempotency. For a simple read tool with only two parameters, this is minimally complete, but could include more context on data scope or granularity.

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 period (enum, default 30d) and campaign_id (optional filter) well-documented. The description doesn't add new parameter semantics beyond what the schema provides, so 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 attributes revenue to email and lists specific metrics (revenue per campaign, per contact, average order value). It distinguishes itself from sibling tools like 'get_analytics' and 'get_campaign' by focusing on attribution, but could be more precise about what it doesn't do (e.g., raw analytics).

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

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

The description implies this is for tracking email-driven revenue, providing implicit context for when to use it vs. siblings like 'get_campaign' or 'get_analytics'. However, it lacks explicit guidance on when not to use it or mention of alternatives, which would help an AI agent decide.

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

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

The description adds value beyond the annotations (readOnlyHint, idempotentHint, destructiveHint) by warning about the consequences of exceeding warm-up capacity. It does not contradict the annotations, and the added context helps agents understand the importance of the tool's output.

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

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

The description consists of two concise sentences: the first states the function, and the second adds a crucial warning. No unnecessary words or repetition, 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?

The description explains the tool's purpose and importance but lacks details about the return format (e.g., whether it returns a percentage, number, or structured object). Without an output schema, the agent may not know how to interpret the result for downstream decisions, which is a notable gap.

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

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

The tool has zero parameters, and schema description coverage is 100% (trivially). Per the guidelines, the baseline score is 4. The description does not need to add parameter meaning, as there are none.

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 'Get IP/domain warm-up progress and today's remaining send capacity,' specifying the exact verb and resource. It distinguishes this tool from siblings like get_deliverability_score and send_campaign by focusing on warm-up status, which is unique among the sibling list.

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

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

The phrase 'Exceeding warm-up capacity on a new domain is the fastest way to get throttled or blocklisted' implies the tool should be used before sending to new domains to avoid issues. However, it does not explicitly state when not to use it or compare it to alternative tools for similar purposes.

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 readOnly=false and destructive=false, but the description adds context: it states that existing addresses are updated rather than duplicated and that per-row results are returned, revealing behavior beyond the annotations. This is valuable but does not cover all aspects (e.g., rate limits, transactionality).

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, directly states the key points (bulk limit, update semantics, per-row results) with no filler or redundancy. It is front-loaded and 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 no output schema, the description adds essential context about return format (per-row results, rejection reasons). It does not mention prerequisites (e.g., required field email) but the schema covers that. For a bulk import tool, this is reasonably complete.

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

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

Schema description coverage is 100%, so both parameters are already documented. The description restates the max count and update behavior but does not add further detail beyond the schema. Baseline 3 is appropriate since schema carries the parameter 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's function: bulk-import contacts with a defined limit (5,000) and update behavior. It also explicitly distinguishes from create_contact (single) and update_contact (single) by mentioning bulk import and update semantics.

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 bulk import ('up to 5,000 contacts') but does not explicitly contrast with single-contact tools like create_contact or update_contact. It lacks an explicit 'when to use this instead of alternatives' statement, though the bulk aspect provides implicit 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 indicate read-only and idempotent behavior. The description adds value by mentioning the API key requirement, clarifying that reading has no effect on the test, and warning about interpreting small-sample results. 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 concise but includes multiple useful points (purpose, use case, safety, caution). It is front-loaded with the core function and each sentence adds value, though it could be slightly tighter.

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 operation, the description explains what results are returned (variant results and winner status) and addresses edge cases (no winner selected, early sample caution). Without an output schema, it still conveys the essential information, though it could explicitly mention pagination fields.

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 does not provide additional parameter explanations beyond what the schema already covers (page, type, limit). It adds no extra semantics, so a 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 A/B tests with variant results and winner status, using a specific verb and resource. It distinguishes from sibling tools like create_ab_test and select_ab_test_winner by focusing on the read-only listing aspect.

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

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

The description explicitly states when to use it ('see which tests are still running and which are waiting on a decision') and provides exclusions, noting that declaring a winner is a separate irreversible action. It also advises caution with early results, giving clear usage context.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description adds critical behavioral details: secret values are never returned by any tool, a lost key must be rotated, the operation requires an API key, and the output is security-relevant. This enriches 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 compact and well-structured: a clear first sentence, a practical use case, a note about metadata-only security, and a read-only confirmation. Every sentence 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?

With no parameters and no output schema, the description covers all necessary aspects: purpose, usage scenario, security implications, authentication requirement, and behavior (read-only, no secrets returned). It is fully complete for a list tool of this complexity.

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

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

There are zero parameters, so the baseline is 4. The description adds meaningful context about what the output includes (scopes, last-used times) and what it excludes (secret values), which is more informative than an empty schema alone.

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

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

The description opens with a specific verb+resource: 'List the API keys on the account with their scopes and when each was last used.' This clearly states the action and scope, and distinguishes it from sibling list_* tools by focusing on API keys and their metadata.

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 gives explicit usage context: 'Use it to audit access — to spot keys that are unused, over-scoped, or forgotten.' This tells when to invoke the tool. It doesn't explicitly name alternatives but clarifies that secrets are not recoverable, implying rotation is the alternative for lost keys. This is strong guidance, though not as explicit as naming a sibling tool.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, etc.), the description adds valuable behavioral context: 'Reads only; nothing is activated, paused, or enrolled', requires an API key, and warns that an automation may exist while inactive. This significantly helps the agent set expectations.

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

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

The description is concise and well-structured: purpose and output in the first sentence, usage guidance in the second, and caveats in the third. Every sentence adds meaningful information without redundancy.

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

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

For a simple list tool with optional parameters and no output schema, the description covers the primary use, output contents, related tools, auth requirement, read-only nature, and a critical caveat about inactive automations. It is complete for effective tool selection and invocation.

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

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

The input schema already provides 100% coverage for all three parameters (page, limit, status). The description does not add new parameter-level detail, which is acceptable because the schema is self-sufficient; it merely mentions status and counts in the output context.

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

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

The description clearly states the tool lists automation workflows on the account, gives concrete examples of automation types, and specifies the returned data (status and enrolment counts). It also distinguishes itself from get_automation by noting individual steps are not included.

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

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

It explicitly explains when to use it: to see what is running before adding an overlapping workflow and to find an automation id for get_automation or toggle_automation. It also tells the agent to use get_automation when steps are needed, making alternatives 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=true, idempotentHint=true, and destructiveHint=false, so the agent knows it is a safe read operation. The description adds return field context but does not disclose pagination behavior, rate limits, or ordering. This is consistent with the annotation 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 sentences, front-loaded with the primary action and scope, and no filler. The second sentence adds a useful use case without restating schema details. 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 list tool with complete schema and safety annotations, the description is nearly complete. It lacks explicit mention of pagination defaults or sorting, but these are inferable from the schema parameters. The description adequately covers the tool's purpose and typical usage.

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

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

All three parameters are fully described in the schema (100% coverage), but the description adds meaning by explaining why to use the status filter (find drafts ready to send or campaigns still sending). This goes beyond the enum values and gives practical semantic value.

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

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

The description clearly states the tool lists email marketing campaigns with specific returned fields (status, audience size, headline metrics). This distinguishes it from sibling tools like get_campaign (single item), create_campaign, or send_campaign, leaving no ambiguity about its purpose.

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

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

It provides concrete usage context by suggesting filtering by status to find drafts or in-flight campaigns. It does not explicitly name alternatives (e.g., 'use get_campaign for a single campaign'), but given sibling names and this description, the intended use case is 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=true and destructiveHint=false, so safety is covered. The description adds that it returns subscription status and engagement metrics, which is useful context beyond annotations, but does not disclose pagination behavior or potential rate limits. This is acceptable given 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, front-loaded with the core purpose, and every sentence adds value. 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 schema coverage and idempotent/readOnly annotations, the description covers the key aspects: what it returns, how to filter, and a practical use case. No output schema exists, but the description mentions the fields (subscription status, engagement metrics) which partially covers return info. It is slightly lacking in discussing pagination or total counts but that is addressed by schema parameters.

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

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

All four parameters are fully documented in the schema (100% coverage), so the description adds little beyond the schema. The description does not elaborate on parameter usage, but the schema already includes descriptions for each. The baseline of 3 is appropriate because the description does not contradict or add much value.

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

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

The description clearly states the tool lists contacts and includes specific details about subscription status and engagement metrics, which distinguishes it from generic list tools. It doesn't explicitly compare to siblings, but the context of filtering by status for unsubscribed/bounced addresses is specific enough.

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

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

The description provides a clear when-to-use context: 'Filter by status to find unsubscribed or bounced addresses that should be excluded from sends.' It does not mention alternatives but the sibling list is large and this tool is uniquely about contacts, so the 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, destructiveHint=false. The description adds value by specifying that results include verification status and DNS records, and by framing the typical invocation scenario. No contradictions.

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 purpose and output, the second gives a concrete use case. No redundant words, every sentence serves a purpose.

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

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

The description adequately covers what the tool returns (domains with verification status and DNS records) and when to use it. It lacks explicit mention of the response format (e.g., array), but for a simple list tool this is acceptable, especially given no output schema. Sibling context 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 coverage is 100% (both page and limit are described in the input schema with defaults). The description does not add any additional parameter meaning beyond what the schema already provides. Baseline 3 applies.

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

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

The description clearly states the verb 'List' and the resource 'sending domains', specifying the included fields (verification status, DKIM/SPF/DMARC records). It also provides a specific use case (check when a send fails with unverified-sender error), which distinguishes it from siblings like check_dmarc 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 includes explicit guidance: 'Check here first when a send fails with an unverified-sender error.' This gives a clear context for use. While it doesn't list alternatives or exclusions, the context is strong enough for an agent to decide.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safe read-only nature. The description adds some functional context (mailbox folder, optional search) but does not describe return shape, pagination behavior, or sorting. This is adequate but not enriched beyond annotations.

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

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

Two concise sentences with no filler. The first sentence states the core function, and the second provides a direct pointer to an alternative tool. 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 listing tool with three optional parameters and strong annotations, the description covers the key context: what is listed, where it is listed from, optional search, and when to use a different tool. No output schema exists, but the tool's behavior is straightforward enough that this is acceptable.

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 each parameter already has a meaningful description. The tool description adds minimal semantic value beyond the schema, mentioning full-text search and mailbox folder but not providing new parameter-level detail. 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 'List emails from a mailbox folder with optional full-text search across subject and body', using a specific verb and resource. It distinguishes itself from the sibling tool list_campaigns by explicitly directing marketing sends elsewhere.

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

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

The description gives explicit usage context: 'Use this for reading the unified inbox; use list_campaigns for marketing sends.' This names an alternative and clarifies when not to use this tool, giving clear guidance beyond what the schema alone provides.

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, and non-destructive. The description adds valuable context: 'Reads only; no form is created, published, or unpublished,' 'Requires an API key,' and a caveat about zero conversion counts. This goes beyond the annotations and enriches agent understanding.

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

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

Three well-structured sentences: first states purpose, second gives usage guidance, third adds behavioral notes and caveats. Every sentence earns its place with zero fluff. Front-loaded with the core purpose.

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

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

The description is complete for a list tool: it explains what is returned, when to use it, prerequisites (API key), and a potential misinterpretation of conversion counts. Given the simple schema and no output schema, this is fully 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 description coverage is 100%, so baseline is 3. The description does not reference individual parameters, but the schema already documents page, limit, and status clearly. The description adds no extra parameter-level semantics, but since the schema is complete, no deduction needed.

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

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

The description clearly states 'List signup forms on the account with their embed status and conversion counts.' It names the exact resource and scope, and differentiates from siblings by explicitly mentioning get_form and get_form_submissions, clarifying that it returns forms, not submissions.

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?

Provides explicit guidance: 'Use it to find a form id before get_form or get_form_submissions, and to compare how forms are performing against each other.' Also states what it is not for: 'It returns the forms themselves, not the people who filled them in — that is get_form_submissions.' This is clear when-to-use and when-not-to-use.

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 unified-inbox and detected intent, indicating the tool provides an overview. It does not contradict annotations. However, it does not detail pagination behavior or access scope, but with strong annotation coverage, this is a minor gap.

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

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

The description is two sentences, front-loading the core purpose and then providing usage differentiation. Every sentence adds 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?

With 6 parameters and no output schema, the description sufficiently explains the tool's purpose and filtering options. It mentions return fields (status and intent) but lacks explicit return format or pagination details. Given the complexity, it is mostly complete for an AI agent to use effectively.

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 6 parameters are fully described in the input schema (100% coverage). The tool description does not add new meaning beyond what the schema already provides, so baseline 3 is appropriate. No additional semantic benefit is gained from the 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 clearly states the tool lists unified-inbox conversations (threads) with status and detected intent, and distinguishes from sibling tool 'list_emails' by specifying it is for individual messages in a folder. The verb 'List' plus the resource 'conversations' 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 explicit usage guidance: 'Use this for triage; use list_emails for individual messages in a folder.' This directly tells when to use this tool and when to use an alternative, making the selection clear for an AI agent.

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 context beyond the readOnlyHint annotation: it requires an API key, warns that 'an integration listed as connected can still be failing to sync,' and clarifies that an empty list is 'not an error.' None of these details are present in annotations, and they help set correct expectations.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by concise usage guidance and caveats. Every sentence earns its place without repetition or filler.

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

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

Despite no output schema, the description states what the tool returns (integrations, sync status, last run time) and includes caveats for typical failure modes (stale status, empty list). It also mentions authentication. The coverage is thorough for a 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?

The input schema already fully describes both parameters (page and limit) with their defaults, achieving 100% schema coverage. The description adds no additional parameter-level guidance, so it lands at the baseline 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 specifies the action ('List every third-party integration connected to the account') and the returned data ('with its sync status and when it last ran'). It explicitly distinguishes from siblings by positioning itself as the entry point for external data queries and pointing to get_integration and toggle_integration for 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 gives an explicit when-to-use instruction: 'Start here when a question involves external data.' It names alternatives for specific follow-ups ('For one integration's configuration and scopes, follow up with get_integration; to turn one on or off, use toggle_integration') and adds exclusions via 'Reads only; nothing is connected, disconnected, or re-synced.'

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 the description reinforces this with 'Reads only' and adds an API key requirement and a quality caveat about third-party listings. This adds context 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 concise and well-structured: purpose first, then usage notes, then caveats and alternatives. Every sentence adds value, with no repetition 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 read-only listing tool with zero required parameters, the description covers purpose, usage context, side effects (none), requirements (API key), and quality variation. It is complete for the given complexity, especially with output schema absent.

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

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

Input schema has 100% parameter coverage (page, limit, search, category all have descriptions). The description does not add extra parameter-specific detail, but given high schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose: browsing marketplace templates. It uses a specific verb ('browse') and resource ('MisarMail marketplace'), and explicitly distinguishes itself from sibling tool list_templates by noting they return different things.

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?

Provides explicit when-to-use ('find a starting point instead of authoring from scratch') and when-not-to-use (lists nothing, installs nothing, suggests inspecting with get_marketplace_item). Clearly directs users to list_templates for owned templates, offering an alternative.

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, destructiveHint=false, so the description's role is reduced. It adds context about the sandbox intercept mechanism, but does not disclose new behavioral traits beyond what annotations provide. No contradictions.

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. Every word adds value: 'List emails captured by sandbox mode' and then the explanatory context. No wasted words or redundancy.

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

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

Given no parameters, no output schema, and a simple list operation, the description is fully complete. It explains what the tool returns (emails captured by sandbox) and why it matters (for verifying templates/automations without delivery).

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

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

The input schema has zero parameters, and schema description coverage is 100%. Baseline for 0 params is 4. The description does not need to add param info; it explains the tool's purpose sufficiently without parameter details.

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

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

The description clearly states the verb 'List' and resource 'emails captured by sandbox mode', distinguishing it from sibling tools like 'list_emails' and 'clear_sandbox'. It explains the sandbox mechanism, making the purpose immediately understandable.

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 it to verify templates and automations without emailing anyone.' It implies this is for testing, not for production sends, but does not explicitly name alternative tools. The usage guidance is strong but lacks direct sibling differentiation.

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

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

The description goes beyond annotations by stating it 'Reads only; no template is created, edited, or sent,' and adds practical details like requiring an API key and that an empty list is not an error. This fully discloses behavioral expectations.

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

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

The description is well-structured and every sentence adds value: it covers purpose, usage, distinction from sibling, read-only nature, API key requirement, and empty-list semantics without unnecessary verbosity.

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 thorough for a read-only list operation. It explains the tool's role, expected inputs, output characteristics (placeholders), and edge cases (empty list, missing variable). Given no output schema, it sufficiently covers all necessary context.

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

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

The input schema already provides descriptions for all three parameters (page, type, limit), so the description adds little to parameter understanding. It does not elaborate on parameter usage beyond what the schema offers, but it does not need to.

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

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

The description clearly states the tool's function: listing saved email templates with their variable placeholders. It distinguishes itself from list_marketplace_items, which covers third-party templates, making it 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?

It explicitly explains when to use the tool ('pick a template before composing a send') and what information it provides (which variables must be supplied). It also contrasts with a sibling tool, giving clear guidance on selection.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false. The description adds useful context about returning HTML and subject and previewing personalisation, but does not go beyond that to discuss authentication, rate limits, or edge-case behavior. 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 concise sentences, front-loaded with the action and output, with no redundant filler. Every phrase 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 two-parameter preview tool with strong annotations, the description is nearly complete. It explains the purpose, output, and non-sending nature. The only minor gap is that 'sample variables' could be slightly ambiguous, but the schema clarifies the variable structure.

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 both parameters are already documented. The description mentions 'sample variables' and the output, but adds little semantic meaning 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 uses a specific verb ('Render') and resource ('a template'), and clearly states the output ('resulting HTML and subject'). It also distinguishes itself from sending tools by framing the action as a preview before sending.

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

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

The description explicitly says to use this tool 'to preview personalisation before sending anything,' providing clear usage context. It does not name alternative tools or explicit exclusions, but the guidance is sufficient for typical selection.

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 a non-read-only, non-destructive operation with potential side effects (openWorldHint). The description adds context that sender/threading are auto-derived, but does not detail what happens with body content, authentication, or response behavior. This adds some value beyond annotations but leaves gaps.

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

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

The description is a single, concise sentence that front-loads the purpose and adds meaningful context. Every word earns its place, with no redundancy or filler.

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

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

Given the simple tool (3 params, no output schema, no nested objects) and full schema coverage, the description is adequate. It explains the crucial threading derivation but omits details like whether only one body type is needed, what happens without a body, or any constraints. For the complexity, this is reasonably complete.

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

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

Schema coverage is 100%, so baseline is 3. The description clarifies that threading headers are derived and 'only the body is required,' but this slightly conflicts with the schema requiring email_id. It adds some meaning but introduces ambiguity about required fields, so it does not fully elevate above baseline.

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

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

The description clearly states the action ('Reply to an existing email thread') with a specific verb and resource, distinguishing it from sending new emails (e.g., send_email, send_campaign) and other email operations. The mention of derived sender/threading info further clarifies its scope.

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

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

The description implies when to use this tool (when replying to an existing thread) and provides context about automatic threading, but it does not explicitly name alternatives or specify when not to use it. This is a clear context without exclusions, fitting a score of 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 the tool as readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds only 'Returns prioritized findings,' which modestly informs outcome but does not disclose any additional behavioral traits such as execution time, rate limits, or prerequisite conditions. Given the rich annotations, the description provides acceptable but minimal added 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 extremely concise: two sentences totaling 23 words, with no redundancy. The first sentence immediately conveys the broad scope, and the second sentence succinctly describes the output format. Every word is purposeful.

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 input parameters, the description covers the areas inspected (authentication, reputation, hygiene, content, blocklist) and states it returns prioritized findings. It is nearly complete but lacks mention of any prerequisites (e.g., domain verification) or error conditions, leaving minor gaps. Still highly functional 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?

There are zero parameters, and the schema coverage is 100%. According to the guidelines, with 0 parameters the baseline is 4. The description does not need to add parameter meaning since none exist, and it correctly omits any parameter-related text.

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

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

The description clearly states a specific verb ("run") and resource ("deliverability audit"), and enumerates the components (SPF/DKIM/DMARC authentication, domain reputation, list hygiene, content signals, blocklist) that distinguish it from sibling tools like check_dmarc, validate_email, or get_deliverability_score, which are narrower in 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 does not provide any guidance on when to use this comprehensive audit versus the many sibling tools. For example, it does not say 'use this for a full assessment' or contrast it with simpler checks like get_deliverability_score. The context signals include sibling names, but the description itself offers no comparative 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 mark destructiveHint=true. The description adds context by stating 'triggers a real send' and 'cannot be undone', reinforcing the irreversible nature. It does not contradict annotations and provides meaningful behavioral insight beyond the annotations.

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

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

Two sentences, front-loaded with the core action, no extraneous words. Every sentence earns its place by stating the action and its irreversible consequence.

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

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

The description covers the main action and consequence, but does not mention expected return values, prerequisites (e.g., test state), or error conditions. Given no output schema, slightly more detail on outcome would improve completeness.

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

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

Schema description coverage is 100%, so the schema already documents all parameters (test_id, winner_variant, metric). The description adds no additional meaning or guidance for any parameter, achieving only 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 clearly states the tool selects a winning variant and sends it to the remaining audience, using a specific verb and resource. It distinguishes from siblings like create_ab_test and list_ab_tests by focusing on the selection and execution 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 this is the final action in an A/B test (triggering a real send) and warns it cannot be undone, but it does not explicitly state when not to use it or suggest alternative tools for previewing or cancelling.

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 destructiveHint=true and readOnlyHint=false, but the description adds crucial context: it delivers real email, cannot be undone once sending starts, and recommends pre-confirmation. This goes beyond the annotations, though it could also mention rate limits 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?

Two sentences, each value-dense. The first states the action and the second provides risk warning and a safety tip. No fluff or redundancy; perfectly concise.

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 params, no output schema) and the strong annotations, the description is largely complete. It covers the key behavioral risk and a usage guideline. Slight gaps: no mention of what happens after sending (e.g., confirmation response) or potential errors, but these are minor given the 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 coverage is 100%, so the schema documents both parameters well. The description reinforces the function of 'scheduled_at' (scheduling future time) but does not add details like timezone handling or validation rules. Baseline 3 is appropriate since the schema is sufficient.

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 clear verb ('Send') and resource ('campaign'), explicitly states the action (send now or schedule), and distinguishes itself from siblings like 'send_email' and 'create_campaign' by focusing on the execution of a campaign. It also highlights the irreversible nature of the action.

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 ready to send a campaign) and explicitly advises confirming the audience with 'get_campaign' first. It does not explicitly state when NOT to use it or list alternative tools, but the guidance to confirm audience is clear and practical.

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

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

No annotations, so description must carry the load. It discloses the verification requirement Link and mentions return of message ID/queue status. Missing rate limits and explicit side effects, but the essential behavior (send, verify sender, queue) is covered.

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 essential purpose mud plus the key prerequisite and outcome. 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?

Rich schema covers parameter details; description adds the verified-sender requirement and return value (message ID/queue). Could mention rate limits or failure formats, but given the schema's depth, coverage is 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?

Schema already documents all 12 parameters with meaningful descriptions (format, max sizes, constraints). The description adds only the 'from' verification linkage, which is also in the schema. At 100% coverage, description adds minimal extra value, so baseline 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?

Clear verb+resource: 'Send a transactional email'. The qualifier 'transactional' distinguishes from campaign-send siblings like send_campaign. Mentions the source (verified MisarMail account), tying directly to the 'from' constraint.

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

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

Gives actionable prerequisite guidance: 'use list_domains to check which sender domains are available'. No explicit when-not-to-use, but the verification check addresses the main failure mode. Could mention alternatives (e.g., template-based sends) but not necessary.

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 significant side effects beyond the annotations: activating sends real emails without further confirmation, pausing holds contacts (not drops), and it is safe to repeat. This goes well beyond the idempotentHint and provides critical context about the tool's impact.

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 yet comprehensive. Each sentence conveys essential information about purpose, consequences, usage advice, and safety, without redundancy. The structure logically flows from action to impact to recommendation.

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 consequential nature, the description covers all necessary context: what it does, why it's consequential, how to use it safely (read first), and the precise behavior on pause. It even addresses idempotency and authentication. No gaps are apparent.

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?

While the schema already describes automation_id and active, the description adds semantic depth: active=true activates and starts enrollments, active=false pauses and holds contacts. It also clarifies the behavior for contacts already in progress, which is not evident from the schema alone.

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 action: 'Activate or pause one automation workflow.' It uses a specific verb and resource, and the effect (starting/stopping enrollments) is unambiguous, distinguishing it from read or list 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 strong usage guidance: it advises reading the workflow with get_automation first, explains the consequences of each action, and clarifies that pausing holds contacts rather than cancelling. This helps an agent decide when to use this tool versus alternatives like get_automation or other mutating actions.

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 substantial context beyond annotations: explains that disabling stops syncing but preserves credentials/connection, that re-enabling resumes, and that repeating the same toggle is safe. It also aligns with the idempotentHint annotation. No contradiction.

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

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

The description is three short paragraphs, each serving a purpose: primary action, behavioral impact, and usage guidance. No fluff or redundancy; front-loaded with the core purpose.

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

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

Given no output schema, the description fully covers what the agent needs to know: purpose, side effects, safety, and prerequisite. It is complete for a tool of this complexity.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by clarifying consequences of each enabled state (e.g., 'DISABLING stops all syncing') and reinforces idempotency, which goes slightly beyond the schema definitions.

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: 'Turn one third-party integration on or off.' It uses a specific verb and resource, and distinguishes from sibling tools like toggle_automation by specifying 'third-party integration'.

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 guidance: 'Call list_integrations first so you know the current state rather than toggling blind.' It also notes the prerequisite of an API key and implies when not to use by explaining what it does not do (disconnect or revoke credentials).

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: setting status to unsubscribed immediately excludes the contact from future campaigns. This adds value beyond the annotations, which only indicate idempotentHint and non-destructive. 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, front-loaded with the main purpose, and includes a critical behavioral note. No wasted words.

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

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

Given the tool has 9 parameters, 100% schema coverage, and no output schema, the description is sufficient. It explains the main action and a key side effect. It could mention that it replaces tags (as per schema) but that is already in the schema. Overall, complete 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?

The schema has 100% description coverage for all parameters, so the description does not need to add much. It mentions 'including changing subscription status' which highlights the status parameter, but the schema already describes each 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 the tool updates an existing contact by email address and can change subscription status. It distinguishes from create_contact and list_contacts by specifying 'existing contact' and the update action.

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 updating contact details and subscription status, but does not explicitly mention when not to use it or alternatives. However, the context of updating an existing contact is clear, and the sibling tools like create_contact provide contrast.

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, openWorld, idempotent, and non-destructive. The description adds the key behavior of opening the checkout page in the browser when open=true, and clarifies that this is a general status/upgrade info tool. It does not contradict annotations and adds useful context about the optional side effect.

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

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

The description is three sentences, front-loaded with the main purpose. Every sentence provides distinct value: what it shows, when to call it, and the key parameter behavior. 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 tool with 2 optional parameters, full schema coverage, strong annotations, and no output schema, the description is complete. It explains the primary purpose, usage timing, and the optional browser-opening behavior. Nothing essential is missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add any parameter semantics beyond what the schema already provides. It mentions 'open=true' but that is exactly what the schema says. There is no bonus for repeating schema content.

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

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

The description uses a specific verb 'Show' and clearly states the resource (current MisarMail plan, quota usage, and what upgrading unlocks). It distinguishes the tool from siblings by focusing on plan and upgrade context, which is unique among the listed 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 gives explicit when-to-use guidance: 'Call it any time — not only after hitting a limit.' It does not mention alternatives or exclusions, but for this tool it is clear enough. A 5 would require explicit alternatives or when-not-to-use, so 4 is appropriate.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safe read-only nature is known. The description adds value by detailing what the validation covers (syntax, MX, disposable, role-account), which is not in the annotations. 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 two sentences: the first defines purpose and scope, the second provides usage context. Every sentence is informative with no filler words 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?

Given the tool's simplicity (one param), the schema covers the parameter, annotations cover safety, and the description explains validation logic. The only missing piece is the return format (e.g., boolean vs. structured result), but that is a minor gap given the tool's nature. Overall, it is sufficiently complete 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 schema has 100% coverage for the single parameter 'email' with description 'Email address to validate'. The tool description does not add any extra parameter-specific meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly states the verb 'Validate' and the resource 'email address', and enumerates specific checks (syntax, MX records, disposable-domain, role-account detection). This makes it distinct from sibling tools like check_dmarc or verify_domain, which focus on different aspects.

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

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

It provides clear scenarios: 'before sending' and 'Use this to protect sender reputation on imported lists.' It does not explicitly mention when not to use or alternatives, but the context is clear enough for an agent to decide. The usage guidance is practical and specific.

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 useful behavioral context beyond annotations: it mentions the 'mark it verified' side effect (consistent with readOnlyHint=false) and explains that retries are safe due to DNS propagation. This complements the idempotentHint=true annotation without contradicting 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 two sentences long, front-loaded with the core purpose, and every sentence adds value. It efficiently conveys the action, condition, and retry guidance without any 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?

Given the simple nature of the tool (one parameter, clear annotations, no output schema), the description is nearly complete. It explains what happens on success ('mark it verified') and the retry rationale, though it does not detail the behavior when DNS does not resolve. This is a minor gap for a tool of this complexity.

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

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

The schema fully documents the only parameter (domain_id) with a clear description ('Domain ID returned by add_domain'). The tool description does not add additional meaning beyond the schema, so the baseline 3 applies.

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

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

The description clearly states the action ('Re-check a domain's DNS records'), the resource (domain's DNS records), and the outcome ('mark it verified if they resolve'). It differentiates from siblings like add_domain (domain creation) and check_dmarc (DMARC-specific check) by focusing on domain verification.

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

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

The description provides clear context for when to use the tool: re-checking DNS records after a domain has been added, with a note on DNS propagation time. It implies this is a follow-up to add_domain but does not explicitly name alternatives or exclusions, so it stops 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.