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

With no annotations, the description carries the full behavioral burden. It discloses the 1000-contact bulk limit and the two modes, but omits important mutation behavior such as duplicate handling, validation rules, permissions, error behavior, and what the call returns.

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

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

The description is a single front-loaded sentence with no wasted words. It efficiently conveys the core action and the two usage modes.

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 mutation tool with no annotations, no output schema, and nested objects, the description covers the essential input modes and limit. It still leaves out operational details that would help an agent invoke it safely, such as duplicate behavior, required list state, and response semantics.

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

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

Schema description coverage is 100%, so the schema already explains the email, contacts, list_id, and metadata fields. The description reinforces the single-vs-bulk distinction but does not clarify mutual exclusivity between email and contacts or how top-level metadata relates to bulk contact metadata.

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 and resource: adding contacts to a list. It also distinguishes the two supported modes (single email vs. bulk contacts), which sets it apart from contact-list management siblings like create_contact_list or remove_contact.

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 guidance on mode selection: one contact via email, or up to 1000 via the contacts array. It does not name alternatives or exclusions, but the usage context 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?

No annotations are provided, so the description carries the full burden. It usefully discloses that the call returns DNS records to configure, but says nothing about idempotency, behavior when the domain already exists, error conditions, or the relationship to verify_domain.

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

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

Two short sentences, action first and the return-value note second. Every clause earns its place with no filler.

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

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

No output schema exists, so the description's mention of returned DNS records is a valuable hint, but it stops short of describing what those records are or the follow-up verification step. For an unannotated mutation tool in a domain-management family, more behavioral detail is warranted.

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 documented 'domain' parameter including an example format, so the schema does the heavy lifting. The description adds no semantics about domain constraints (subdomains, verification requirements) beyond what the schema states.

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

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

Specific verb ('Register') plus resource ('sender domain'), which cleanly separates it from list_domains, get_domain, verify_domain and delete_domain by implying creation of a new domain. It does not explicitly name those siblings, but the verb carries enough signal for an agent to choose correctly.

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

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

Usage is only implied: an agent can infer this is the setup step before sending from a domain, and that verify_domain likely follows. There is no explicit when-to-use, when-not-to-use (e.g. domain already registered), or prerequisite statement.

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

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

With no annotations and no output schema, the description carries the full behavioral burden. It discloses the core effect (nothing gets sent), but says nothing about idempotency for an already-suppressed address, whether it applies to all send paths including batch, required permissions, or reversibility. One sentence of effect is thin for a mutation tool.

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

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

A single sentence with zero filler, front-loaded with the verb and resource and ending with the consequence. Nothing to trim.

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 mutation the description covers purpose and outcome, but leaves open what happens when the address is already suppressed and how this interacts with sends in flight. Adequate as a minimum, not 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% and both parameters are documented there, including the reason field's accepted values (manual, bounce, complaint). The description adds no parameter meaning beyond that, 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?

States a specific verb ('Add') and resource ('suppression list') plus the effect ('nothing is sent to it'). It is distinguishable from list_suppressions and remove_suppression by the verb, though it never names them explicitly.

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

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

The intended use (block all delivery to an address) is implied by the effect clause, but there is no explicit when-to-use guidance, no mention of bounce/complaint-driven versus manual suppression workflows, and no pointer to remove_suppression for reversal.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but 'Create ... for organizing recipients' only implies a mutation. It fails to mention permission requirements, whether duplicate names are rejected, whether double_opt_in changes downstream sending behavior, or what the response returns (e.g., a new list ID that add_contacts would need).

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

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

A single front-loaded sentence with zero filler, which is appropriate for a simple create tool. It is efficient but borders on under-specification rather than being genuinely complete.

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 write operation with no annotations and no output schema, the description should at minimum note permissions, uniqueness constraints, and what the created resource looks like. As written, an agent cannot tell whether the call is idempotent, what it returns, or how the result plugs into add_contacts.

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

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

Schema description coverage is 100% – the schema already documents name length limits, the description field, and the double_opt_in default. The description adds no additional meaning beyond the schema, 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 a specific verb ('Create') and resource ('contact list') plus a brief purpose ('organizing recipients'), so an agent knows exactly what it produces. It does not, however, distinguish this from sibling list operations such as create vs. list_contact_lists / update_contact_list, leaving differentiation to the name alone.

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

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

There is no guidance on when to use this versus the other contact-list tools, no preconditions (e.g., whether a list name must be unique across the account), and no mention of follow-up steps like add_contacts. Usage must be inferred entirely from the tool name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Create' and does not explain side effects, whether the route activates immediately, how conflicts with existing patterns or priorities are handled, or what permissions are required.

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

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

The description is a single front-loaded sentence with no wasted words. It is concise, though the brevity contributes to gaps addressed in other dimensions.

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 mutation tool with five parameters, required fields, an enum, and no annotations or output schema, the description is incomplete. It omits required setup, matching semantics, priority behavior, and webhook delivery implications that an agent would need to call 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?

Schema description coverage is 100%, so the input schema already documents all five parameters, including match_type enum values and priority default. The description adds no additional semantics beyond the schema baseline.

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

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

The description states a specific verb and resource: 'Create a routing rule for inbound email.' It is clear enough to distinguish from listing or updating inbound routes, though it does not explicitly name alternatives or contrast with related tools like create_webhook.

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 no guidance on when to use this tool versus alternatives such as create_webhook or update_inbound_route, nor does it mention prerequisites like domain verification or required permissions. Usage is only implied by the tool name.

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

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

With no annotations, the description carries the full burden, but it does disclose one behavioral fact beyond structured data: it returns the created mailbox including its address (valuable since there is no output schema). It says nothing about auth/permission requirements, duplicate-address behavior, or whether creation is idempotent — significant gaps for a mutation tool with zero annotation coverage.

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

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

Two sentences, zero waste, and the core action is front-loaded. The second sentence earns its place because it compensates for the absent output schema.

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 three-parameter, all-optional create tool with no annotations and no output schema, the description covers purpose and return shape but omits failure modes (duplicate address, invalid domain, permissions). Adequate minimum, not 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 all three parameters are already documented in-schema (including the 'random if omitted' default for local_part). The description adds no meaning beyond that, so the baseline of 3 applies.

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

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

Specific verb+resource: 'Create an email address for an AI agent' tells an agent exactly what is produced and for whom, which distinguishes it from domain tools like add_domain or template tools. However, it never references sibling mailbox tools (list_mailboxes, delete_...) to sharpen the boundary.

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 when-to-use, when-not-to-use, or prerequisite guidance is given. The agent must infer from the schema alone that domain_id is only relevant for custom-domain addresses, and nothing explains what happens if a mailbox already exists.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says the tool creates a template but omits key mutation context: whether aliases must be unique, what happens on duplicate aliases, whether the template is immediately usable, permission requirements, and what is returned. That is a significant gap for a create operation.

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

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

A single front-loaded sentence with no wasted words. It is appropriately sized for the tool's surface, though its brevity leaves room for more actionable context without becoming verbose.

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

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

For a mutation tool with no annotations and no output schema, the description is under-specified. The schema fully documents parameters, but the description should still convey behavioral expectations such as alias uniqueness, error conditions, or the effect of creating a template.

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 every parameter is already documented in the schema. The description adds no additional meaning about parameters, which is acceptable at baseline but provides no extra 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 states a specific verb and resource ('Create a ... email template') and identifies the templating engine (MiniJinja), which is useful beyond the tool name. It does not explicitly distinguish itself from siblings like update_template or get_template, but the create verb makes the distinction obvious.

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

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

There is no guidance on when to use this tool versus alternatives such as update_template or list_templates, nor any preconditions (e.g., unique alias, required fields). Usage is only implied by the tool name and description.

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

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

With no annotations, the description carries the full burden but only says what is created. It omits whether the endpoint is auto-verified, whether events must come from a fixed set, whether creation is idempotent, what permissions are needed, and whether the secret/response is returned.

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?

One short, front-loaded sentence with no filler. It is efficient, though its brevity reflects under-specification rather than disciplined selection of detail.

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

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

The schema is simple, fully described, and has only two required params, so the description is narrowly adequate. For a mutation tool with zero annotations, however, it should say more about verification, event vocabulary, and the return value.

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

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

Schema coverage is 100% and the schema already documents both url and events, including example event names. The description adds no syntax or constraint detail 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?

States a specific verb+resource: 'Create a webhook endpoint' for delivery event notifications. It is clearly distinct from list/get/update/delete_webhook siblings by the verb alone, though it does not name them.

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

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

No guidance on when to create a webhook versus using inbound routes or other notification mechanisms, and no prerequisites or caveats. The agent must infer usage entirely.

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

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

No annotations exist, so the description carries the full burden. It usefully discloses the cascade behavior — all contacts in the list are deleted — but says nothing about reversibility, required permissions, or confirmation semantics for a destructive operation.

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

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

One short sentence, front-loaded with the action and resource, plus the key side effect. Nothing wasted.

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 destructive tool with no annotations or output schema, the description is minimal but covers the core effect. It leaves important destructive-operation context (irreversibility, dependent data, permissions) unstated.

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 fully documented in the schema as a contact list UUID, so schema coverage does the heavy lifting. The description adds no syntax or format detail beyond the schema, which is acceptable at this coverage level.

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 a specific verb and resource (delete a contact list) and adds the cascade effect (and all its contacts). This clearly distinguishes it from get_contact_list and update_contact_list, though it does not explicitly name an alternative delete path.

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 when-to-use or when-not-to-use guidance is provided. The description does not mention prerequisites, whether removal is irreversible, or how to handle contacts that should be preserved (e.g., remove_contact first).

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

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

With no annotations, the description carries the full burden; it does disclose the one critical trait, that deletion is permanent/irreversible, which is real value. But it says nothing about required permissions, whether the record is recoverable elsewhere, or how it interacts with dead letter retention/listing.

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?

One short sentence with no filler, but it is under-specified rather than efficiently concise — a single clause for a destructive operation leaves too much unsaid.

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 destructive tool with no output schema, the essentials are present (target + permanence). Missing the practical context an agent needs: how to get a valid stream ID, and that retrying is the non-destructive alternative.

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?

Single parameter with 100% schema description coverage ('Stream ID of the dead letter'), so the schema fully documents it. The description adds no format hints (where to obtain the stream ID, e.g. from list_dead_letters), 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 a specific verb and resource ('delete a dead letter') that maps unambiguously to the tool name. It does not explicitly differentiate from the closest sibling, retry_dead_letter, but the permanent-vs-retry distinction is at least implied by the word 'Permanently'.

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 indication of when to delete versus retry a dead letter, which is the obvious fork an agent faces given retry_dead_letter sits alongside it. No prerequisites, no warnings about confirming with the user before an irreversible action.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only says 'Remove'. It does not disclose whether deletion is irreversible, whether associated mailboxes/emails/analytics are affected, what permissions are required, or what happens on failure for a non-existent ID.

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?

One short sentence, front-loaded with the action and resource, with no wasted words. Brevity here is a virtue, though the sentence is not doing enough work to earn top marks.

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

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

For a destructive operation with no annotations and no output schema, the description is too thin. An agent cannot determine safety profile, side effects, or expected response, which are all the more important because the description is the only source of that information.

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

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

Schema description coverage is 100% and the single parameter 'id' is documented as 'Domain UUID' in the schema. The description adds no further meaning about the identifier or whether it accepts a domain name versus a UUID, 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?

States a specific verb (remove) and resource (sender domain), which distinguishes it cleanly from siblings like add_domain, get_domain, verify_domain, and list_domains. It does not explicitly name those alternatives, but the CRUD framing makes the distinction obvious.

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

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

There is no guidance on when to use this versus alternatives or prerequisites. Nothing tells the agent that the domain should be verified or unused first, nor that removal is the correct action versus disabling or re-verifying.

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

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

No annotations are provided, so the description carries the full burden for a destructive operation. It does not say whether the deletion is permanent or recoverable, whether prior retrieval via get_inbound_email is advisable, what permissions or scope are required, or what happens to associated routes.

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?

One short sentence with no wasted words, but the brevity reflects under-specification rather than density of useful content. It is front-loaded but has nothing to front-load beyond the obvious verb.

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

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

For a destructive tool with no annotations, no output schema, and many similar delete_* siblings, the description leaves the agent without irreversibility warnings, preconditions, or failure behavior. The structured fields alone do not fill that gap.

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

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

Schema coverage is 100% and the single parameter 'id' is documented as an inbound email UUID, so the description adds nothing beyond the schema. Baseline 3 applies when the schema fully documents the only parameter.

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

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

The sentence "Delete an inbound email" restates the tool name (delete_inbound_email) with no added distinction from siblings such as delete_inbound_route, delete_dead_letter, or delete_template. The verb and resource are present, but only because the name already carries them.

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

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

There is no when-to-use guidance, no mention of the related tools (get_inbound_email, list_inbound_emails, delete_inbound_route) that an agent would need to disambiguate or confirm before deleting. An agent must infer everything from the name.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. 'Delete' implies a destructive mutation, but the description does not state whether deletion is permanent, what permissions are needed, whether it affects active routes, or what happens on invalid/missing IDs.

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?

It is a single, front-loaded sentence with no wasted words. It is perhaps too terse, but structurally efficient and free of noise.

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

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

For a destructive operation with no annotations and no output schema, the description is insufficient. It should at least clarify irreversibility, error/confirmation behavior, and any authorization requirements needed to call it safely.

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 single 'id' parameter is fully documented in the schema as an inbound route UUID. The description adds no additional parameter meaning beyond what the schema already provides, so the baseline of 3 applies.

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

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

It states a specific verb and resource: 'Delete an inbound routing rule.' The tool name and description distinguish it from siblings like delete_inbound_email, though the description itself does not explicitly compare against them.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The agent must infer usage entirely from the name and schema.

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

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

No annotations are provided, so the description carries the full burden, yet it says nothing about this being an irreversible destructive mutation, whether deletion of a template in use is allowed, or what errors/permissions apply. A one-word restatement leaves the agent blind on a destructive operation.

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

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

It is short, but its brevity comes from omission rather than efficiency; it is under-specified for a destructive mutation. Nothing is front-loaded because there is nothing to front-load.

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

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

For a destructive, no-annotation, no-output-schema tool surrounded by CRUD siblings, the description omits confirmation semantics, irreversibility, and failure conditions. It is not sufficient for an agent to invoke it safely.

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 the single required param 'id' is documented as 'Template UUID' in the schema. The description adds nothing beyond that, which meets the baseline 3 when the schema already does the work.

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

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

The description 'Delete a template.' merely restates the tool name and title; it adds no verb detail, scope, or resource qualification beyond what the identifier already conveys. It is a tautology rather than a specification of what is deleted or by which identifier.

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 indication of when to use this versus get_template, update_template, or list_templates, and no prerequisites (e.g., confirming template is unreferenced). The agent must infer everything from the name alone.

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

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

With no annotations supplied, the description carries the full burden of disclosure. It does not state that deletion is irreversible, what happens to in-flight deliveries or stored events, whether it 404s on an unknown id, or what permissions are required — all critical for a destructive mutation.

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

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

A single front-loaded sentence with zero waste and no filler. It is appropriately sized, though the brevity reflects under-specification rather than disciplined editing.

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

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

For a destructive operation with no annotations and no output schema, the description should at minimum flag irreversibility and expected failure behavior. The parameter is fully documented by the schema, but the behavioral picture an agent needs before calling a delete tool 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% (the single `id` parameter is documented as "Webhook UUID"), so the schema does the heavy lifting. The description adds no meaning beyond it, which is the baseline case for full schema coverage.

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

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

The description names a clear verb and resource ("Delete a webhook endpoint"), so the intent is unambiguous. However, it is essentially a restatement of the tool name and does nothing to distinguish it from siblings like update_webhook, get_webhook, or delete_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?

There is no guidance on when to use this versus update_webhook or other lifecycle siblings, and no mention of prerequisites or consequences. An agent must infer everything about appropriate invocation from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says the export is CSV, but does not disclose whether it returns file contents, a download URL, or a saved file path; whether period overrides date range; how large exports behave; or whether authentication or account scope matters.

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 single sentence is front-loaded and free of padding, but it is extremely sparse for an export tool with three parameters and no annotations. It is concise but arguably under-specified rather than optimally structured.

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

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

With no annotations, no output schema, and three optional parameters, the description is not complete enough. It omits return behavior, file delivery mechanics, how period interacts with from/to, and any constraints on export size or date ranges.

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 from, to, and period are already documented in the schema. The description adds the word 'daily' as an implicit granularity hint, but does not clarify the precedence between period and the date-range parameters. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description states a specific verb (export) and resource (daily analytics) plus the output format (CSV), so the agent knows what it produces. It does not explicitly distinguish this from sibling analytics tools like get_analytics_timeseries or get_analytics_overview, but the CSV export framing is reasonably distinct.

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

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

There is no guidance on when to use this instead of get_analytics_timeseries or get_analytics_overview, nor on how to choose between the from/to date range and the period shorthand. The agent must infer usage entirely from the name and schema.

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

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

No annotations exist, so the description carries the burden; 'Get' implies a safe read but that is only inferred, and nothing is said about authentication scope or account-scoping (the API key owner). It does disclose the returned subject matter (details, quota, plan), which is more than nothing for a zero-argument tool.

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

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

A single short sentence with no filler, front-loading the resource and enumerating the payload in order of importance. Nothing here wastes an agent's context.

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

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

There is no output schema, so the description is the only source of return-value information, and 'details' remains vague beyond quota and plan. It also omits any mention of credentials/scoping, which is the one thing an agent must understand for a parameterless account call that overlaps with get_subscription.

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 takes zero parameters, so there is nothing to disambiguate; baseline 4 applies. The description correctly implies the account is derived from credentials rather than passed in.

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 a specific verb and resource ('Get account details') and enumerates the payload (quota usage, plan), so the agent knows exactly what comes back. It does not distinguish itself from siblings such as get_subscription or list_billing_plans, which cover overlapping 'plan' territory.

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

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

No guidance on when to call this versus get_subscription or list_billing_plans, which are the obvious near-duplicates in the sibling list. There are no stated prerequisites or exclusions.

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

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

No annotations exist, so the description carries the entire behavioral burden, yet it discloses nothing beyond the bare operation. It doesn't say the call is read-only, whether from/to and period are mutually exclusive or which wins, how results are ordered/paginated, or what an empty result looks like. Only the 'get' verb hints at a read operation.

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

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

One front-loaded sentence with zero waste, but it is under-specified rather than economical – the brevity costs the agent information it needs (metrics, interaction of date params, output shape).

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 annotations, no output schema, and four optional parameters whose precedence is unstated, the description should explain return values and the from/to vs. period behavior. It does none of this, leaving the agent to discover the result shape by trial.

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%, including defaults and max for limit and the period shorthand values, so the schema handles parameter documentation. The description adds no meaning beyond it – it doesn't explain how 'to'/'from' interact with 'period' (all params optional with no stated defaults for dates).

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 verb+resource is present ('Get stats... by recipient domain'), and the 'recipient domain' dimension does differentiate it from get_analytics_overview and get_analytics_timeseries. However, 'stats' is vague – it never says which metrics (sends, opens, bounces, deliveries) are returned, so the agent still has to guess at the payload.

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

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

No guidance on when to choose this over get_analytics_overview, get_analytics_timeseries, or export_analytics_csv. The description only implies usage by its dimension name; no exclusions, prerequisites, or date/period defaults are stated.

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

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

With no annotations, the description carries the behavioral burden. It discloses the returned metric categories and the date-range scoping, and 'Get' implies a read operation, but it does not describe default date behavior, period precedence, authentication needs, rate limits, or response structure.

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

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

The description is a single front-loaded sentence with no redundant or filler language. Every phrase contributes to stating the tool's purpose and metric scope.

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

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

For a simple read-only analytics tool, the description covers the core purpose and metrics. However, because there are no annotations and no output schema, it should do more to explain return shape, optional-parameter defaults, and how period relates to from/to.

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 three parameters are already documented in the schema. The description reinforces date-range scoping but adds no detail on how from/to and period interact, whether period overrides dates, or what defaults apply when no parameters are 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 states a specific verb and resource: get analytics totals and rates for delivered, bounced, opens, and clicks. It is clear enough to distinguish an overview-aggregate tool from adjacent analytics tools, but it does not explicitly contrast itself with get_analytics_timeseries or get_analytics_domains.

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

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

The description gives only the implied use case of retrieving analytics for a date range. It does not say when to choose this tool over get_analytics_timeseries, get_analytics_domains, or export_analytics_csv, nor does it state any exclusions or prerequisites.

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

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

With no annotations, the description carries the full behavioral burden, but it only says 'daily stats for charting.' It does not disclose safety profile, whether results are aggregated, timezone handling, default date range when parameters are omitted, or response shape.

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 single sentence is concise and front-loaded, but it is too terse for a four-parameter analytics tool. It avoids waste but sacrifices useful detail.

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

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

The tool has four optional parameters, no required parameters, no output schema, and no annotations. The description leaves unaddressed what happens with omitted dates or metrics, how the timeseries is grouped, and what the caller can expect, making it incomplete for correct invocation.

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

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

Schema description coverage is 100%, so the schema already explains to, from, period, and metrics. The description adds no parameter-level meaning such as default period, metric selection behavior, or how date ranges interact with period.

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 says to get daily stats for charting, which gives a verb and a resource but remains vague about what stats are returned and how they differ from get_analytics_overview. It implies a timeseries view but does not name or distinguish the sibling analytics 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?

There is no guidance on when to use this tool instead of get_analytics_overview, get_analytics_domains, or export_analytics_csv. No prerequisites, exclusions, or default behavior are stated.

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

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

No annotations are provided, so the description must carry the full burden. It implies a read-only operation and mentions the contact count, but does not disclose error behavior, permissions, or what happens if the id is invalid.

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?

One short sentence, front-loaded with the core action, and 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 get-by-id tool with no output schema, the description is too sparse. It only mentions contact count and omits any details about the returned list fields (e.g., name, created date) or error handling, leaving the agent with insufficient context to interpret the response.

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

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

Schema coverage is 100% and the single 'id' parameter is fully described in the schema. The description adds no additional meaning beyond what the schema provides, so the baseline 3 is appropriate.

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

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

States a specific verb (Get) and resource (contact list) and adds that it returns the contact count. It is clear it retrieves a single contact list, distinct from list_contact_lists, though it doesn't explicitly say 'by id'.

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 no explicit guidance on when to use this tool versus list_contact_lists or other CRUD siblings. The only implied usage is retrieving a single list if you have its id, but alternatives and conditions are not mentioned.

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

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

No annotations, so the description carries the full burden. It does disclose the return payload (DNS records plus verification status), which is real value, but says nothing about behavior beyond that — not-found handling, permission requirements, or whether verification data is fetched live or cached.

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

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

A single front-loaded sentence with no filler. Every clause ('DNS records', 'verification status') conveys useful scope information.

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

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

For a one-parameter read tool with no output schema, the description covers what the tool returns, which is the main gap it needed to fill. Missing only error/failure behavior, which is minor at 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?

Only one parameter, and the schema documents it fully as 'Domain UUID' at 100% coverage. The description adds nothing beyond that, 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?

Uses a specific verb ('Get') and resource ('a domain') and clarifies scope by naming what is bundled in the response — DNS records and verification status. This distinguishes it from list_domains and verify_domain in practice, though it never names those siblings explicitly.

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

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

Usage is only implied: an agent infers it should call this when it has a single domain's UUID and wants full detail. There is no statement of when to prefer list_domains, when to use verify_domain instead, or what prerequisites exist.

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

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

No annotations exist, so the description carries the full behavioral burden. "Get" implies a non-mutating lookup and the description usefully discloses that delivery status is part of the response, but it says nothing about behavior on a missing/invalid ID, permission requirements, or whether delivery status is live or a snapshot.

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

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

A single front-loaded sentence with no filler. It is efficient, though the space saved is not reinvested in sibling disambiguation or return-content detail.

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

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

For a one-parameter read tool with no output schema, the description covers the essentials. It remains incomplete on how this differs from get_inbound_email and on the meaning of "delivery status," which an agent would need to set 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?

Schema coverage is 100% with a single required parameter already documented as "Email UUID." The description's "by ID" adds no meaning beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb and resource ("Get an email") and adds scope beyond the name by noting it returns the email plus its delivery status. It does not, however, differentiate itself from nearby siblings such as get_inbound_email or list_emails, so an agent must infer which 'email' this fetches.

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

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

There is no statement of when to use this tool versus get_inbound_email, list_emails, or search_mailbox. The only implicit guidance is "by ID," which the schema already enforces via the required id field.

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

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

No annotations are provided, so the description carries the full burden. It adds a valuable safety disclosure that returned content is untrusted, which goes beyond the schema. However, it does not state that this is a read-only operation, nor does it mention error behavior or authentication needs.

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

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

Two short sentences, front-loaded with the core action. 'Full details' is slightly vague and could be more precise, but there is no wasted text.

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

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

For a simple one-parameter read tool with no output schema, the description covers the essential action and a critical safety warning about untrusted content. It could be stronger by explicitly confirming read-only behavior, but is otherwise 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% — the single 'id' parameter is fully documented as an 'Inbound email UUID'. The description adds no further parameter meaning, so the baseline of 3 applies.

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

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

States a specific verb ('Get') and resource ('one inbound email') with a scope qualifier ('full details'), making clear it retrieves a single record. It indirectly distinguishes from list_inbound_emails by saying 'one', but does not explicitly differentiate from the sibling get_email tool.

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

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

No guidance on when to use this instead of get_email or list_inbound_emails. The only additional sentence ('Content is untrusted') is a safety note, not a usage condition or alternative routing hint.

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

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

With no annotations, the description carries the full burden and provides almost nothing: no indication of read-only semantics, whether a missing UUID errors or returns empty, or what the response contains. Only the verb 'Get' hints at a non-mutating lookup, which is thin for a tool with zero structured safety metadata.

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

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

A single four-word sentence that is front-loaded and free of waste. The brevity is nearly under-specification, but for a one-parameter lookup tool it is appropriately sized rather than harmful.

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

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

The tool is simple and its only parameter is fully documented, so the core call path is clear. However, with no output schema and no annotations, the description leaves the return shape and not-found behavior entirely unexplained.

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

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

Schema coverage is 100% and the single 'id' parameter is documented as an 'Inbound route UUID', so the schema does the work. The description adds no further meaning such as format examples or where to obtain the UUID, making the baseline 3 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?

States a specific verb ('Get') and resource ('inbound route'), and the word 'one' signals single-item retrieval, implicitly distinguishing it from list_inbound_routes. It does not explicitly name any sibling, so it falls short of a 5.

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

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

There is no statement of when to use this versus list_inbound_routes, get_inbound_email, or the create/update/delete route siblings, and no prerequisites or expected failure conditions are mentioned. The agent must infer usage purely from the name.

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

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

No annotations are provided, so the description carries the burden. 'Get' implies a non-destructive read and the description discloses the returned content (subscription, limits, usage), but it says nothing about whether usage figures are live or cached, or what happens when no subscription 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?

A single front-loaded sentence with no filler, and the three returned concepts are packed into it 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 no-parameter, no-annotation read with no output schema, the description adequately frames what comes back. A note on failure/absent-subscription behavior would close the remaining gap, but 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 tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The schema is an empty object matching the description's premise of a no-argument current-state lookup.

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 a specific verb ('Get') and resource ('the current subscription') and enumerates what it returns: plan limits and usage. It is clearly distinct from siblings like list_billing_plans or get_account by the word 'current', though it never explicitly says so.

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

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

Usage is only implied: a zero-parameter read that an agent would call to inspect the active plan. There is no explicit statement of when to prefer this over get_account or list_billing_plans, nor any prerequisite 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?

No annotations are provided, so the description carries the full behavioral burden; 'Get' weakly implies a read-only, side-effect-free operation and 'body content' discloses something about the return payload. It says nothing about permission requirements, behavior for a missing or deleted template ID, or the response structure, which matters since there is no output schema.

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

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

One short, front-loaded sentence with zero filler. Every word contributes: the action, the resource, and the notable inclusion of body content.

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

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

For a one-parameter getter with a fully described schema this is close to adequate, but with no annotations and no output schema the description should say what a template contains (subject, HTML/text body, variables) and what happens when the ID is unknown.

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 is fully documented in the schema ('id' as a Template UUID) at 100% coverage, so the baseline of 3 applies. The description adds no format, sourcing, or lookup guidance for the ID beyond what the schema already states.

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

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

States a specific verb and resource ('Get a template') and adds scope detail ('including its body content') that separates it from list_templates, which would not return bodies. It never names a sibling explicitly, so the differentiation is implicit rather than stated.

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 single-template retrieval is implied by the name and by 'including its body content', hinting at use when the full body is needed rather than a summary listing. There is no explicit when-to-use, no exclusion of list_templates, and no mention of prerequisites such as a valid template ID.

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

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

No annotations exist, so the description must carry the behavioral burden. It does disclose the returned fields (URL, events, active status), which is helpful since there is no output schema, but it says nothing about read-only nature, behavior when the ID is unknown (404 vs empty), or authorization 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?

One short sentence, front-loaded with the verb and resource, with zero filler. Nothing could be removed without losing information.

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

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

For a single-ID getter with one fully documented parameter and no output schema, naming the returned fields covers the main gap. Only error/not-found behavior and permission expectations are missing, which are modest omissions here.

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

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

Schema coverage is 100% and the single parameter is documented as a 'Webhook UUID' in the schema. The description adds no format hints or sourcing guidance beyond that, so the schema does all the work — 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?

States a specific verb (get) and resource (webhook) and enumerates what comes back (URL, events, active status), which separates it from list_webhooks and create/update_webhook at a glance. It doesn't explicitly name the sibling it contrasts with, so it stays just short of a 5.

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

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

Usage is only implied by the singular resource and the required id parameter; there is no explicit statement that this is the single-record lookup versus list_webhooks, nor any precondition such as needing an existing webhook ID. An agent can infer it, but nothing is spelled out.

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

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

With no annotations, the description carries the full disclosure burden, and it delivers little. "List" implies a read-only operation, but nothing is said about who may call it (admin-only?), entry retention, ordering, or whether pagination totals are returned — all material for an audit endpoint.

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

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

A single front-loaded sentence with no filler, which is appropriately sized for a two-parameter list tool. It is efficient rather than padded, though the brevity comes at the cost of the missing usage and behavior detail noted elsewhere.

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

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

For a simple, optional-parameter list tool with a fully documented schema and no output schema, the description is minimally sufficient. It still leaves the agent guessing about the shape of an audit entry and whether special access is required.

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 page and per_page are fully documented in the schema itself. The description adds no extra semantics such as default ordering, max per_page, or filtering by actor/date, so the baseline of 3 applies.

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

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

The description gives a specific verb and resource ("List audit log entries") plus a scope qualifier ("for administrative actions"). No sibling tool covers audit logs, so it is distinguishable by resource alone, though it could say more about what an entry contains.

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

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

There is no guidance on when to use this versus the analytics tools (get_analytics_overview, get_analytics_timeseries) that also expose activity data, nor any mention of prerequisites such as admin permissions. The agent is left to infer everything about appropriate 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?

No annotations are provided, so the description carries the full disclosure burden. It implies a read-only enumeration but never says so, and it omits whether results are paginated, how many plans are typically returned, whether the list is account-scoped or public, and whether auth is required.

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

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

A single short sentence with the key information front-loaded and zero filler. Nothing to trim and nothing buried.

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 simple zero-parameter shape means the description does not need much, and naming prices and limits covers the return content at a high level. However, with no output schema and no annotations, the description is the only source of information about the response shape and access requirements, and it says nothing about either.

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 takes zero parameters, so there is nothing the schema could document that the description must compensate for. Per the baseline for parameterless tools, a 4 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?

States a specific verb (List) and resource (available plans) plus the payload the caller can expect (prices and limits). No sibling tool in this server covers billing plans, so no disambiguation is required; the definition is clear on its own but not maximally specific (e.g., what a 'plan' contains structurally).

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

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

There is no guidance on when to call it, whether it requires authentication, or how it relates to get_subscription, which is the obvious neighboring tool for account-level billing state. The agent must infer that this is a catalog lookup versus a subscription lookup.

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

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

No annotations are provided, so the description carries the full burden. It does disclose a useful behavioral detail — results include contact counts — but says nothing about pagination, ordering, or account scoping for what could be a long collection.

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

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

A single seven-word sentence, front-loaded with the verb and resource, with the payload detail appended. Nothing is wasted and nothing important is buried.

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

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

For a zero-parameter list tool with no output schema, the description covers the core behavior and return shape but omits pagination and ordering behavior. An agent could call it correctly but cannot predict result size or handling of large lists.

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 takes zero parameters and the schema is empty, so there is nothing for the description to document. The baseline of 4 applies; the brief mention of contact counts covers what the caller can expect.

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 a specific verb and resource ("List contact lists") and adds that contact counts are included, which distinguishes it from get_contact_list. It does not explicitly name how it differs from list_contacts, but the resource noun 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?

There is no statement of when to use this versus alternatives such as get_contact_list or list_contacts, and no prerequisites. Only the verb "list" implies a usage pattern; the agent must infer the rest.

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

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

With no annotations, the description carries the full behavioral burden and discloses almost nothing: no mention of pagination behavior, default ordering, permissions, or what the response contains. A single sentence is insufficient for a list tool with four parameters and no safety 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?

One short sentence, zero waste, and the core purpose is front-loaded. It is terse but not padded or structurally confusing.

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 paginated list tool with no annotations and no output schema, the description leaves pagination semantics, filter behavior, empty-list behavior, and return shape entirely unaddressed. The schema covers parameters but not the tool's behavior.

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

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

Schema description coverage is 100%, so all four parameters (list_id, page, per_page, status) are already documented in the schema. The description adds no meaning beyond what the schema provides, which is acceptable at 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?

States a specific verb (List) and resource (contacts in a contact list), so an agent knows this returns contacts rather than lists. It does not explicitly distinguish itself from siblings like list_contact_lists or get_contact_list, but the resource scope is clear enough.

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

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

No guidance on when to use this versus list_contact_lists, get_contact_list, or add_contacts. The pagination and status-filter parameters imply it is the retrieval tool for members of a list, but that is left to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says items 'sit in the dead letter queue' but does not disclose ordering, pagination behavior, whether results are read-only or reflect a snapshot, or what to expect when the queue is large — only the word 'List' implies a safe read.

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

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

One sentence, zero filler, with the distinguishing qualifier ('failed permanently') placed before the queue name. Appropriately sized for a simple list tool, though it could front-load the scope even more sharply.

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

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

For a single-parameter list tool with no output schema and no annotations, the description covers the 'what' but leaves out result shape, ordering, and the relationship to the retry/delete dead letter siblings. Adequate but clearly incomplete for an agent that must decide how to act on the results.

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

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

Schema coverage is 100% and the single 'count' parameter already documents its default (50) and max (200), so the description adds nothing on parameters. Baseline 3 applies when the schema does all the lifting.

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

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

States a specific verb and resource ('List emails') plus a clear qualifier ('failed permanently', 'dead letter queue') that separates it from the general list_emails sibling. It does not name the alternative tools explicitly, so sibling differentiation is implied rather than explicit.

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

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

The 'failed permanently' wording hints at when this is relevant (diagnosing delivery failures), but the description never states when to use this versus list_emails, retry_dead_letter, or delete_dead_letter. Usage is inferable from the queue name rather than explained.

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

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

With no annotations, the description carries the full burden, yet it discloses nothing about pagination semantics, result ordering, whether unverified/pending domains are included, or permission requirements. Only the read nature is implied by the verb 'List'.

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

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

A single short sentence with no wasted words, but it is under-specified rather than efficiently concise — there is room for one clause on scope or pagination that would clearly earn 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 paginated list tool with no output schema and fully documented parameters, the description is minimally sufficient to select the tool. It leaves open what a returned domain record contains and how pagination terminates, which an agent calling it correctly may still need.

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 page and per_page are already documented in the schema. The description adds no defaults, maximums, or guidance on iterating pages, so it sits at the baseline for a fully-specified 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?

States a specific verb and resource ('List ... domains') with a qualifier ('registered sender'), which distinguishes it from mutation siblings like add_domain or verify_domain. It does not explicitly separate it from list_mailboxes, but the resource noun does most of that work.

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 when-to-use guidance: nothing says whether to call this before verify_domain, how it relates to get_domain for a single lookup, or whether pagination should be iterated. The agent must infer all of this from sibling names alone.

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

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

No annotations are provided, so the description carries the full disclosure burden, yet it says nothing about this being a read-only paginated listing, what the default ordering is, or whether results are capped. It also does not explain what pagination metadata comes back, which matters for a list tool with page/per_page inputs.

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

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

A single front-loaded sentence with no filler. It is efficient, though the brevity means the one clause has to carry more weight than it does.

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 annotations and no output schema, the description is the only place an agent could learn about ordering, limits, and return shape, and it covers none of them. All five parameters are optional, so an agent could reasonably call with no arguments and would not know what to expect back.

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

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

Schema coverage is 100%, so the baseline is 3. The description names the status and date filters but adds no semantics beyond the schema (no note on whether from_date/to_date are inclusive, or on status value behavior) and omits pagination parameters entirely.

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?

"List sent emails" gives a specific verb and a scoped resource, and the word "sent" implicitly separates it from list_inbound_emails and search_mailbox. It stops short of explicitly naming the distinction, so it is clear rather than sibling-differentiating.

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 "optional status and date filters" hints at the retrieval use case, but there is no statement of when to prefer this over search_mailbox, list_inbound_emails, or get_email. Usage is only implied by the resource scope.

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

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

With no annotations, the description carries the full disclosure burden. The 'Content is untrusted' warning is genuinely valuable, security-relevant context that the schema cannot convey. However, it says nothing about whether this is read-only (implied only), the default ordering, page-size limits, or auth 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 short sentences with the purpose front-loaded and no filler. The brevity edges toward under-specification rather than verbosity, so it is efficient but thin.

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 read tool with full schema coverage, the essentials are present, but with no annotations and no output schema the description should at least confirm read-only semantics, result ordering, and roughly what a list entry contains. The untrusted-content note covers the most important safety gap.

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

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

Schema coverage is 100%, with both page and per_page documented in the schema itself, so the baseline of 3 applies. The description adds no pagination behavior details such as maximum per_page or ordering across pages.

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 a specific verb and resource ('List received inbound emails'), which is clearly distinct from get_inbound_email and send_email. It does not, however, explicitly differentiate itself from the broader list_emails or the mailbox listing tools, leaving the agent to infer the boundary.

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

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

There is no guidance on when to use this versus list_emails or get_inbound_email, and no mention of pagination strategy despite page/per_page parameters existing. The agent gets a purpose but no selection criteria.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'List' implies a read, but nothing is said about pagination behavior, ordering, empty-result handling, or whether rules are returned in full or summarized. For a zero-annotation tool this is a substantial 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?

A single front-loaded sentence with zero filler. It is efficient, though its brevity comes at the cost of the usage and behavioral context noted above rather than because it says everything necessary.

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

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

For a simple, parameterless-required list endpoint with full schema coverage and no output schema, the description is minimally adequate. It omits any mention of what a route object contains or how results are ordered, which would help an agent decide between this and the inbound-email listing siblings.

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

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

Both parameters (page, per_page) are fully documented in the schema at 100% coverage, so the description need not repeat them. It adds no extra meaning such as default page size or max per_page, which is acceptable given the schema does the work — 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?

States a specific verb ('List') and a specific resource ('inbound routing rules'), so an agent knows this is a read operation over the inbound-route collection. It does not, however, distinguish itself from adjacent siblings such as list_inbound_emails or get_inbound_route, leaving the agent to infer the boundary from the name alone.

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

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

There is no statement of when to use this tool versus alternatives, no prerequisite or permission notes, and no exclusion of similar-sounding siblings (list_inbound_emails, get_inbound_route). The agent must infer usage entirely from the name.

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

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

No annotations are provided, so the description carries the full disclosure burden, yet it says nothing about read-only safety, pagination behavior, defaults for limit/offset, or result ordering. A one-line read listing is low risk, but the description adds no behavioral context at all.

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

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

A single front-loaded sentence with zero waste. It is efficient, though the brevity edges into under-specification rather than crisp completeness.

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 annotations and no output schema, the description should at least explain pagination expectations and what a mailbox record includes. For a list tool in a crowded mailbox toolset, one sentence leaves the agent guessing about defaults and result shape.

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% ('Items to return', 'Items to skip'), so the two pagination parameters are already documented. The description adds no extra meaning such as default page size or max limit, 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 a specific verb (list) and resource (agent mailboxes) scoped to the account, which is enough to distinguish it from create_mailbox and read_mailbox_messages by verb alone. It does not explicitly name those siblings or explain what an 'agent mailbox' contains, so it stops short of full differentiation.

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

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

There is no guidance on when to use this versus create_mailbox, read_mailbox_messages, search_mailbox, or list_mailbox_threads. The agent must infer the correct entry point from the name alone.

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

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

With no annotations, the description carries the full burden. It usefully discloses that each row is a thread with its latest message, but says nothing about ordering, whether reading marks messages as read, permissions required, or how pagination behaves beyond the schema's limit/offset fields.

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

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

A single front-loaded sentence with no filler; the resource and the returned shape (threads with latest message) are stated immediately.

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 fully documented parameters, this is adequate but thin: no ordering guarantee, no note about thread-level pagination, and no mention of what happens with an invalid or empty mailbox_id.

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 mailbox_id, limit, and offset. The description adds no extra semantics such as default/max limit, offset ordering, or thread-count behavior, so the baseline of 3 applies.

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

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

The description states a specific verb and resource ('list conversation threads') and scopes it to an agent mailbox, plus discloses a key characteristic (latest message per thread). It is distinguishable from list_emails and list_mailboxes by name and by the 'thread' concept, though it never explicitly contrasts with the thread-reading 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?

There is no guidance on when to choose this over list_emails, read_mailbox_messages, or search_mailbox, all of which return mailbox content. The agent must infer from the tool name whether thread-level or message-level listing is wanted.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses what qualifies as a suppressed address (bounces, complaints, manual entries), but says nothing about pagination behavior, ordering, or that results are read-only and non-mutating.

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

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

A single efficient sentence with the core resource front-loaded and the parenthetical detail earning its place. It is terse rather than padded, though it leaves little room for the missing usage and pagination context.

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

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

For a simple, parameter-light list tool with no output schema and no annotations, the description covers the essentials of what is listed. It falls short on return shape, pagination, and when to prefer it over related suppression tools.

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

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

Schema description coverage is 100% for both optional parameters (page, per_page), so the schema already documents them. The description adds no pagination details beyond the schema, which is the baseline expectation.

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 gives a specific verb ('List') and resource ('suppressed addresses') and enumerates the suppression categories (bounces, complaints, manual entries), so an agent understands exactly what is returned. It does not explicitly contrast itself with add_suppression or remove_suppression, but the read-only listing 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?

There is no explicit when-to-use guidance, no mention of prerequisites, and no routing to alternatives such as add_suppression for adding entries. Usage is only inferable from the verb 'List'.

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

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

No annotations exist, so the description carries the full behavioral burden, yet it discloses nothing: not that the operation is read-only, not the default sort order, not whether results are paginated or truncated, and not the default page size (the schema gives a default for 'page' but not 'per_page'). For a list endpoint with zero annotation coverage this is a real 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?

A single four-word sentence with zero padding and the resource front-loaded. It is efficiently sized, though the same brevity is what leaves the other dimensions thin.

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 two-optional-parameter list tool with fully documented schema fields and no output schema, the definition is minimally viable. The missing pieces, pagination limits and safety profile, are what keep it from being 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%, and both parameters ('page', 'per_page') are documented in the schema, so the description need not repeat them. It adds no meaning beyond the schema, which is the baseline-3 outcome rather than a failure.

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

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

The description states a clear verb ('List') and resource ('email templates'), which is enough to distinguish it from get_template, create_template, and delete_template among the siblings. It stops short of explicitly contrasting itself with the read sibling get_template, which keeps it out of the 5 band.

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

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

There is no guidance on when to call this versus get_template or create_template, and no mention of prerequisites such as authentication or account scope. The agent must infer that this is the browse-all path purely from the verb 'List'.

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

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

With no annotations, the description carries the full behavioral burden. It only implies a read operation by the verb 'List' but does not disclose pagination behavior, ordering, filters, or what happens with no webhooks.

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

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

A single, front-loaded sentence with no wasted words. However, its extreme brevity means it omits useful context rather than being optimally 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?

For a simple list tool with fully documented schema parameters, the description is minimally sufficient. It does not explain return format, pagination defaults, or result bounds, which would help an agent 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?

Schema coverage is 100%, so both page and per_page are fully documented in the schema. The description adds no parameter semantics beyond the schema 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?

States a specific verb (List) and resource (webhook endpoints), making the operation clear. It does not explicitly differentiate itself from siblings like get_webhook, but the verb/resource combination is unambiguous.

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

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

No guidance on when to use this tool versus alternatives, nor any prerequisites or exclusions. The agent must infer that this is the appropriate read operation for webhooks.

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

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

No annotations exist, so the description carries the full burden; it does add one genuinely useful disclosure — that message content is untrusted external input, a prompt-injection warning. It says nothing about pagination defaults, ordering, or whether full bodies are returned, which an agent needs to call and interpret this correctly.

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 waste, and the security caveat is compact and immediately actionable rather than buried.

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?

A simple read tool with fully documented params and a valuable trust warning, but with no output schema and no annotations, the description could have covered return shape or ordering. As written it is adequate but leaves gaps for a tool returning untrusted message content.

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% (limit, offset, unread, mailbox_id all documented), so the schema already does the work. The description adds no meaning beyond it, which is the baseline case.

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 a specific verb and resource ('List messages in an agent mailbox'), making the operation unambiguous. However, it never distinguishes itself from close siblings like search_mailbox, list_mailbox_threads, or list_inbound_emails, so an agent still has to infer which mailbox-reading tool fits.

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 indication of when to use this versus search_mailbox or list_mailbox_threads, and no stated preconditions (e.g. that a mailbox must exist or be created via create_mailbox). Usage is only implied by the verb.

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 the description carries the full burden, and it discloses almost nothing: it does not say whether removal is idempotent, what happens if the email is not in the list (error vs silent success), whether the contact is deleted globally or only unlinked from this list, or what permissions are required. For a mutation with zero annotation coverage this is a meaningful 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?

A single front-loaded sentence with no filler, but its brevity reflects under-specification rather than disciplined economy; nothing about outcome or failure mode is stated.

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?

A two-required-parameter mutation tool with no annotations and no output schema relies entirely on the description, which omits error behavior, idempotency, and scope of the removal (per-list vs account-wide). Not complete enough for correct invocation in edge cases.

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%, documenting both email and list_id (UUID), so the schema does the heavy lifting. The description adds no meaning beyond it — no format detail, no note about whether email must match an existing contact.

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 a specific verb and resource (remove a contact from a contact list), which is unambiguous. It does not name a sibling or clarify how it relates to add_contacts/remove_suppression, so differentiation is implicit only.

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

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

No guidance on when to use this versus alternatives such as remove_suppression or update_contact_list, and no stated prerequisites (does the contact/list need to exist?). The agent must infer everything from the single sentence.

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

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

No annotations exist, so the description must carry the full behavioral burden, yet it only says the entry is removed. It does not say the address becomes mailable again, whether the call errors when the address is not suppressed, whether it is idempotent, or what permissions are required for this account-level mutation.

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?

One short, front-loaded sentence with zero filler. It is efficient, though the terseness leaves little room for the operational detail an agent would want.

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

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

For a single-parameter tool with no output schema this is roughly adequate, but with no annotations the description should mention the side effect (the address will receive mail again) and the not-found behavior to be fully complete.

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

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

There is a single required parameter with 100% schema description coverage ('Email address to unsuppress'), so the schema already fully documents it. The description's word 'address' adds only marginal clarity, matching the baseline for high schema coverage.

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

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

States a specific verb (remove) and resource (suppression list entry) with the object named, so an agent can tell it apart from add_suppression and list_suppressions by verb alone. It stops short of explicitly naming those siblings or the scope of the removal.

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 statement of when this should be invoked versus add_suppression or list_suppressions, and no prerequisites or exclusions. Usage is only implied by the verb.

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

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

No annotations exist, so the description carries the full burden. It usefully discloses that replies stay in-thread and that the recipient is an external party (a real safety constraint: never include secrets), but says nothing about delivery behavior, failures on invalid message_id, or rate limits.

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

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

Two short sentences, front-loaded with the action and scope, then a safety caveat. Nothing wasteful or repetitive.

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 four-parameter send-style tool with a fully described schema and no output schema, the description is adequate but thin: it omits any statement about what a reply produces (new message id, thread linkage) or failure modes, which matter for a mutation tool with no 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?

Schema description coverage is 100%, so all four parameters are already documented in the schema. The description adds only contextual meaning ('recipient is an external party') rather than any syntax or format guidance 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?

States a specific verb+resource: reply to a message in an agent mailbox, with the qualifier 'keeping the thread' that separates it from the sibling send_email. It doesn't name the alternative, so differentiation is implied rather than explicit.

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

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

The phrase 'keeping the thread' implies when to choose this over send_email, but there is no explicit when/when-not guidance or stated prerequisite (e.g., message_id must exist in the mailbox). Usage is inferable but not spelled out.

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

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

No annotations exist, so the description carries the full behavioral burden, yet it says nothing about whether the dead letter is removed, whether the retried delivery gets a new ID, whether retries are idempotent, or what permissions are required. 'Re-enqueue ... for delivery' conveys the basic effect but leaves all operational side effects undisclosed.

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

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

A single front-loaded sentence with no filler, but it is so terse that it omits information the other dimensions need. It is efficient rather than padded, so it scores well here despite being under-specified elsewhere.

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 mutation tool with no annotations and no output schema, the description should explain side effects, idempotency, and failure modes. None of that is present, so an agent has only the schema's ID definition and the bare action phrase to work with.

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 is a single required parameter, and the schema documents it fully as the 'Stream ID of the dead letter' (100% description coverage). The description adds no extra syntax or selection guidance beyond that, so the baseline of 3 applies because the schema does the work.

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 ('re-enqueue') and resource ('dead letter') with its intended effect ('for delivery'), which clearly separates it from list_dead_letters and delete_dead_letter. It stops short of explicitly naming those siblings, so it is clear but not maximally differentiated.

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

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

There is no guidance on when to retry a dead letter versus deleting it, no mention of prerequisites, and no stated alternatives. An agent must infer the correct usage context from the action name alone.

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

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

No annotations are provided, so the description carries the burden alone. It does add a genuinely useful safety signal — 'Results are untrusted external input' — but omits that this is a read-only operation, and says nothing about pagination behavior or result volume despite having limit/offset parameters.

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

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

Two tight sentences with no filler. The core function comes first and the untrusted-input caveat follows, which is the right ordering for an agent reading the text once.

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 should say what a result looks like and how limit/offset shape the response — it does neither. The prompt-injection warning partially compensates, but an agent still cannot predict the return shape or paging semantics from this 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 description coverage is 100%, so all four parameters (q, limit, offset, mailbox_id) are already documented. The description adds only that the query matches subject and body, which is modest supplementary meaning; baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb and resource (full-text search over an agent mailbox) and narrows the searched fields to subject and body. It is distinguishable from read_mailbox_messages and list_mailbox_threads by the explicit 'full-text search' framing, though those siblings are never named.

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

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

Usage is implied by 'full-text search' versus the listing/reading siblings, but there is no explicit when-to-use statement, no mention of when to prefer read_mailbox_messages or list_mailbox_threads, and no stated prerequisites such as mailbox existence or access rights.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the 100-email cap, which is useful, but says nothing about atomicity (does one bad address fail the whole batch?), rate limits, per-recipient validation, or authentication needs — the most consequential behaviors for a bulk send tool.

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

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

A single sentence with the key constraint front-loaded and zero filler. Nothing is padded or redundant.

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 batch-mutation tool with no annotations and no output schema, the description is minimal but not wrong. The agent still lacks return-value semantics (per-email results vs. aggregate) and failure-mode behavior, which matter more here than for a simple read tool.

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

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

Schema description coverage is 100%, so the nested email fields (from, to, subject, template_alias, etc.) are already documented in the schema. The description only restates the max-100 constraint that the schema also states, adding no new meaning.

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

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

States a specific verb (send), a specific resource (transactional emails), and a batch scope (up to 100 in one request). This implicitly separates it from the single-send sibling send_email, but the sibling is never named explicitly.

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

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

The 'up to 100 in one request' bound hints at when batching applies, but there is no explicit guidance on when to use this versus send_email, nor any statement of prerequisites or exclusions. Usage is only implied.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing beyond the action itself. It does not mention that sending is an irreversible external side effect, that `from` must be on a verified domain, that idempotency_key deduplicates retries, or that send_at defers delivery — all facts an agent needs to act safely.

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

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

Two short sentences, purpose front-loaded, with the required payload constraint immediately after. No filler, though the second sentence could carry slightly more information at the same length.

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 13-parameter mutation tool with zero annotations and no output schema, the description is thin: it is silent on verified-domain prerequisites, rate limits, scheduling, idempotency behavior on retry, and the single-vs-batch choice. An agent could call it correctly only by reading the schema closely, which leaves real risk around side effects.

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 the property descriptions are well written (verified domain, ISO 8601, template alias semantics). The description restates the body/template alternative already implied by those property descriptions, so it adds only marginal value; 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 a specific verb and resource ("Send a transactional email"), which is immediately actionable. It does not distinguish itself from the sibling send_batch_emails, so an agent choosing between single and batch sending gets no help here.

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 second sentence gives conditional guidance on payload shape ("Provide html_body and/or text_body, or template_alias with template_data"), which is genuinely useful for constructing a call. However, there is no guidance on when to use this versus send_batch_emails, when scheduling via send_at is appropriate, or any preconditions such as a verified sending domain.

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

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

No annotations are provided, so the description carries the full burden. 'Replace' is the single useful behavioral signal, but the description never says what happens to omitted fields (are description/double_opt_in cleared or preserved?), whether the change is reversible, or what permissions are needed — critical for a mutation tool.

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

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

One sentence, front-loaded with the verb and resource, zero filler. It is arguably too terse rather than too long, but nothing is redundant.

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 mutation tool with no annotations and no output schema, the description should clarify partial-vs-full update semantics and side effects. The word 'Replace' gestures at this but does not resolve it, leaving an agent unable to predict the result of omitting optional 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 each of the four parameters is already documented. The description enumerates the three mutable fields, which confirms which parameters this tool writes, but adds no format, constraint, or default information 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?

Specific verb ('Replace') plus resource ('a contact list') plus the exact fields affected, which distinguishes it from create/get/delete_contact_list siblings. The only wrinkle is that 'Replace' implies full PUT semantics while the required-only 'name' schema hints at partial update, leaving a small ambiguity about 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?

No statement of when to use this versus create_contact_list or get_contact_list, and no prerequisites (e.g., list must exist, must not be in use). Usage is only implied by the verb.

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

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

With no annotations, the description carries the full disclosure burden, yet it says nothing about permissions, whether the replacement is reversible, or what happens to fields such as webhook_url when omitted. The word 'replace' hints that unset optional fields may be cleared, but this is never confirmed.

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?

One sentence with zero waste and the verb front-loaded, but at four words it is under-specified rather than efficient. The brevity leaves the operative semantics of 'replace' unexplained.

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

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

This is a mutating tool with five required parameters and no annotations or output schema, yet the description never addresses the destructive implications of a full replacement or how the caller should supply the id. For a six-parameter write operation, far more context is needed.

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

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

Schema description coverage is 100% and every parameter including the match_type enum is documented in the schema, so the description only needs to match that baseline. It adds no behavioral meaning beyond the schema – notably it does not explain why priority and is_active are required for a replace operation.

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 names a specific verb and resource ('Replace an inbound routing rule'), and the verb 'replace' usefully signals full-overwrite semantics rather than partial patching. It does not explicitly distinguish itself from siblings like create_inbound_route or delete_inbound_route, but the name and verb pair make the operation identifiable.

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

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

There is no guidance on when to use this tool versus create_inbound_route or delete_inbound_route, and no stated prerequisites such as needing the rule's id first or requiring list_inbound_routes to discover it. The agent must infer all of this from the tool name alone.

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

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

No annotations are provided, so the description carries the full burden. It says 'Replace' but the schema shows html_body, text_body and preheader as optional, leaving unclear whether omitted fields are cleared, preserved, or rejected — a critical behavioral detail for a destructive-feeling mutation. No mention of permissions, reversibility, or 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?

A single tight sentence with no filler, front-loaded with the action. It is arguably too terse rather than verbose, so length is not the problem — missing content is.

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 6-parameter mutation tool with no annotations and no output schema, the definition is underspecified: replacement semantics, required-field behavior, and error/validation expectations are all absent. The agent cannot tell what a successful call changes or guarantees.

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

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

Schema description coverage is 100%, so each of the 6 parameters is documented in the schema itself, justifying the baseline 3. The description adds no format, constraint, or requiredness detail beyond restating field names, and it silently drops 'preheader' and the required 'id'.

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 verb 'Replace' plus the resource 'template' is specific, and the named fields (name, subject, bodies) map to the schema. It is clearly distinguishable from create_template/get_template/delete_template by name and description, but it omits 'preheader' and leaves ambiguity about whether 'Replace' means a full overwrite or a partial update.

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

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

There is no statement of when to use this instead of create_template or get_template, no prerequisites (must the template exist? what permissions?), and no note that id is required. The agent must infer everything from the sibling names.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not say whether the update overwrites the entire events list (removing subscriptions not re-sent), whether auth/permissions are required, whether the change is reversible, or what happens if the webhook is inactive. For a full-replace mutation with zero annotation coverage this is a significant gap.

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

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

A single front-loaded sentence with no filler. It is efficient, though the terseness is arguably under-specification rather than tight writing given the mutation risk.

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 4-required-param full-replace mutation with no annotations and no output schema, the definition should describe side effects, overwrite semantics, and error/return behavior. None of that is present, leaving the agent to guess about the consequences of the call.

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

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

Schema description coverage is 100%, so all four parameters are already documented in the schema. The description enumerates the same fields but adds no semantics such as event-name format, URL validation rules, or that all four are mandatory for the replace.

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 a specific verb (Replace) and resource (webhook) plus the fields affected, which lets an agent distinguish it from create_webhook, get_webhook, and delete_webhook. The only ambiguity is that 'Replace' connotes full overwrite while the name says 'update', but the intent is still clear.

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

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

No guidance on when to use this versus create_webhook or delete_webhook, and no preconditions (webhook must already exist, id must be valid). The agent must infer that this is for modifying existing webhooks from the name alone.

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

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

With no annotations, the description carries the full burden, and it does disclose the three validation layers, which is useful behavior. However, it says nothing about whether network/DNS lookups make it slow or costly, whether results are cached, or whether it has side effects, and there is no output schema describing the result shape.

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

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

A single sentence, front-loaded with the action and resource, with zero padding. Every clause (syntax, DNS, deliverability) 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?

There is no output schema, so the description ought to explain what a validation result looks like (boolean, score, reason codes), and it does not. For a one-parameter read-style check it is otherwise adequate, but the return semantics are a real gap.

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

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

Schema coverage is 100% for the single 'email' parameter, so the schema already documents it. The description adds no format or syntax guidance beyond that, so the baseline of 3 applies.

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

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

The description names a specific verb ('Check') and resource ('an address') and enumerates the three checks performed (syntax, DNS, deliverability), so an agent knows exactly what it does. It does not explicitly distinguish itself from nearby siblings like verify_domain, though the resource difference is self-evident.

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

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

Usage is only implied: the deliverability check suggests running it before send_email, but there is no explicit 'use this when...' guidance, no exclusions, and no mention of alternatives 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?

No annotations are provided, so the description carries the full behavioral burden and discloses little beyond the precondition. It does not say whether verification is asynchronous, whether repeated calls are idempotent or rate-limited, or what happens when verification fails.

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?

One sentence with the action and the precondition front-loaded and zero filler. It is efficient, though its brevity contributes to the missing behavioral detail noted elsewhere.

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 single-parameter tool this is close to adequate, but with no annotations and no output schema the description leaves open what the call returns (a verification status? a job id?) and whether the agent must poll afterward.

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

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

Schema coverage is 100% and the single 'id' parameter is documented as a 'Domain UUID'. The description adds only that the domain must have records configured, which is contextual rather than parameter-level detail, 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?

States a specific verb ('Trigger DNS verification') and resource ('a domain'), which clearly separates it from read-only siblings like get_domain and list_domains. It does not explicitly name an alternative, but the action itself 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?

The clause 'whose records are configured' supplies an implied precondition for invocation, which is real guidance. However, it never states what to do instead if records are not yet configured (e.g., check with get_domain first) or how this differs from add_domain at setup time.

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