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

No annotations are provided, so the description carries full burden. It mentions ordering by 'total bounces', which hints at sorting behavior, but doesn't disclose critical traits like whether it's read-only, requires authentication, has rate limits, pagination, or what the output format is. For a stats-listing tool with zero annotation coverage, this is a significant gap in behavioral disclosure.

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

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

The description is a single, efficient sentence with zero waste. It's front-loaded and appropriately sized for its content, though it could benefit from more detail. Every word earns its place by stating the core action and ordering.

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

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

Given the complexity (3 parameters, no annotations, no output schema), the description is incomplete. It doesn't explain parameters, output format, or behavioral context. For a tool that likely returns structured data about bounce classifications, this leaves too many gaps for effective agent use.

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

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

Schema description coverage is 0%, so the description must compensate for three undocumented parameters (group, limit, include_subaccounts). The description adds no information about these parameters—it doesn't explain what 'group' refers to, how 'limit' affects results, or what 'include_subaccounts' does. This leaves parameters largely unexplained.

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

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

The description 'List statistics, ordered by total bounces' specifies a verb ('List') and resource ('statistics'), but it's vague about what kind of statistics (bounce classification stats implied by the name) and lacks differentiation from sibling tools like 'get--v3-domain_name-bounces' or 'post--v2-bounce-classification-metrics'. It states a purpose but not with high specificity.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools related to bounces, domains, and stats, there's no mention of context, prerequisites, or exclusions. Usage is implied only by the tool's name and description, but no explicit guidelines are given.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool aggregates counts, implying a read-only operation, but doesn't specify whether it's safe, requires authentication, has rate limits, or what the output format looks like. For a tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is extremely concise with just three words, making it front-loaded and efficient. There's no wasted verbiage, and it directly states the core function. However, this conciseness comes at the cost of completeness, as noted 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?

Given the tool has one undocumented parameter, no annotations, and no output schema, the description is incomplete. It doesn't explain what 'counts' are being aggregated (e.g., emails, bounces), the time range, or the return format. For a tool in a complex domain with many siblings, this minimal description leaves critical gaps in understanding.

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

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

The input schema has one parameter 'domain' with 0% description coverage, meaning the schema provides no semantic context. The description 'Aggregate counts by country' doesn't mention the 'domain' parameter at all, failing to compensate for the schema's lack of documentation. This leaves the parameter's purpose and format completely unexplained.

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 'Aggregate counts by country' clearly indicates the tool performs aggregation and groups by country, which is a specific verb+resource combination. However, it doesn't distinguish this tool from sibling tools like 'get--v3-domain-aggregates-devices' or 'get--v3-domain-aggregates-providers' that likely aggregate by different dimensions, leaving the purpose somewhat vague regarding its unique role.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools available (e.g., other aggregation tools, stats tools), there's no indication of context, prerequisites, or exclusions. This lack of guidance makes it difficult for an agent to select this tool appropriately among similar options.

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

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

No annotations are provided, so the description carries full burden. It implies a read operation ('aggregate counts') but doesn't disclose behavioral traits like whether it's safe, what permissions are needed, rate limits, or response format. The description adds minimal context beyond the basic operation.

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

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

The description is a single, efficient sentence with no wasted words. It's appropriately sized and front-loaded, making it easy to parse quickly.

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

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

Given 1 parameter with 0% schema coverage, no annotations, no output schema, and many sibling tools, the description is incomplete. It doesn't explain the tool's scope, parameter usage, or behavioral context, leaving significant gaps for a tool that aggregates data.

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

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

Schema description coverage is 0% with 1 parameter ('domain'), and the description provides no information about this parameter. It doesn't explain what 'domain' means, its format, or how it affects aggregation. The description fails to compensate for the lack of schema documentation.

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 'Aggregate counts by devices triggering events' states the purpose (aggregating counts) and resource (devices/events), but is vague about what 'events' refers to and doesn't distinguish from sibling tools like 'get--v3-domains-domain-tag-devices' which appears similar. It provides basic verb+resource but lacks specificity.

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 is provided. The description doesn't mention prerequisites, context, or exclusions. With many sibling tools in the same domain, this omission leaves the agent without direction on tool selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure but offers nothing about what this tool actually does beyond the vague 'aggregate counts'. There's no information about whether this is a read or write operation, what permissions might be required, what format the results take, whether there are rate limits, or any other behavioral characteristics.

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

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

The description is extremely concise - just three words - but this brevity comes at the cost of being severely under-specified. While there's no wasted text, the description fails to provide the necessary information for effective tool use. It's front-loaded only in the sense that there's nothing to load beyond the initial phrase.

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

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

For a tool with one required parameter, no annotations, no output schema, and 0% schema description coverage, the description is completely inadequate. It doesn't explain what the tool does, how to use it, what the parameter means, what results to expect, or how it differs from similar tools. The agent would need to guess or experiment to understand this tool's purpose and usage.

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

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

The schema has 0% description coverage for its single required 'domain' parameter, and the tool description provides absolutely no information about what this parameter means, what format it expects, or what values are valid. The description doesn't mention parameters at all, leaving the agent completely in the dark about how to use this tool.

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

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

The description 'Aggregate counts by ESP' is vague and tautological - it essentially restates the tool name 'get--v3-domain-aggregates-providers' without specifying what is being aggregated or what 'ESP' means. While it hints at counting/aggregation, it doesn't clearly state what resource or data is being processed, making it difficult to distinguish from sibling tools like 'get--v3-domain-aggregates-countries' or 'get--v3-domain-aggregates-devices'.

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

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

The description provides absolutely no guidance on when to use this tool versus alternatives. There's no mention of prerequisites, context, or comparison to sibling tools like 'get--v3-domain-aggregates-countries' or 'get--v3-domain-tag-stats-aggregates'. The agent must guess based solely on the tool name pattern.

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. 'List all bounces' implies a read-only operation but doesn't specify permissions, rate limits, pagination behavior, or what 'all' entails (e.g., time range, filtering). It lacks critical context for safe and effective use.

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

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

The description is concise with a single sentence, but it's under-specified rather than efficiently informative. While it avoids unnecessary words, it lacks essential details, making it more of a placeholder than a helpful summary. It's front-loaded but incomplete.

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

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

Given the tool's complexity (4 required parameters, no annotations, no output schema), the description is completely inadequate. It doesn't explain the resource context, parameter roles, behavioral traits, or output format, leaving the agent unable to use the tool effectively. It fails to compensate for the lack of structured data.

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

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

The schema has 4 required parameters (domain_name, limit, page, term) with 0% description coverage, meaning none are documented in the schema. The description adds no parameter information, failing to explain what these parameters mean or how they affect the listing. This leaves all parameters semantically undefined.

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

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

The description 'List all bounces' states the verb ('List') and resource ('bounces'), but it's vague about scope and lacks sibling differentiation. It doesn't specify what 'bounces' are (e.g., email bounce events) or distinguish it from similar tools like 'get--v3-domain_name-bounces-address' or 'get--v1-bounce-classification-stats', making it minimally informative.

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

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

There is no guidance on when to use this tool versus alternatives. The description provides no context, prerequisites, or exclusions, leaving the agent with no usage direction. This is particularly problematic given multiple sibling tools related to bounces and domain data.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Lookup' implies a read-only operation, but it doesn't specify whether this requires authentication, has rate limits, returns structured data, or handles errors. The description provides no behavioral context beyond the basic action implied by the name.

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

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

The description is extremely concise with just three words, which could be appropriate if it were more informative. However, this brevity results in under-specification rather than efficient communication. The single phrase doesn't provide enough context to be truly helpful.

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

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

For a tool with 2 required parameters, 0% schema description coverage, no annotations, and no output schema, the description is completely inadequate. It doesn't explain what the tool returns, what the parameters mean, when to use it, or any behavioral characteristics. This leaves the agent with insufficient information to use the tool effectively.

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

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

The schema has 0% description coverage, meaning neither parameter (domain_name, address) has any documentation in the schema. The description 'Lookup bounce record' adds no information about what these parameters represent, their expected formats, or how they combine to identify a specific bounce record. This leaves both parameters completely undocumented.

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 'Lookup bounce record' is a tautology that essentially restates the tool name 'get--v3-domain_name-bounces-address'. While it indicates a read operation ('lookup'), it lacks specificity about what resource is being accessed (bounce records for a specific address within a domain) and doesn't distinguish it from sibling tools like 'get--v3-domain_name-bounces' (which likely retrieves all bounces for a domain).

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'get--v3-domain_name-bounces' (for all bounces in a domain) or 'get--v3-domain_name-complaints-address' (for complaints at address level), nor does it specify prerequisites or appropriate contexts for this lookup operation.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states 'List all complaints', which implies a read-only operation but doesn't cover critical aspects like pagination behavior (suggested by 'limit' and 'page' parameters), authentication needs, rate limits, or what 'all' entails (e.g., date ranges, filtering). This is inadequate for a tool with 5 parameters.

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

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

The description is a single phrase 'List all complaints', which is overly concise to the point of under-specification. While it avoids verbosity, it lacks necessary detail and structure to be helpful, making it inefficient rather than appropriately sized.

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

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

Given the tool's complexity (5 parameters, 3 required), lack of annotations, 0% schema description coverage, and no output schema, the description is severely incomplete. It doesn't explain parameter usage, behavioral traits, or return values, leaving the agent with insufficient information to use the tool effectively.

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

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

Schema description coverage is 0%, meaning none of the 5 parameters (domain_name, limit, page, address, term) are documented in the schema. The description 'List all complaints' adds no semantic information about these parameters, failing to compensate for the lack of schema documentation.

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

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

The description 'List all complaints' states a basic verb+resource but lacks specificity about what kind of complaints (e.g., email complaints, domain complaints) and doesn't differentiate from sibling tools like 'get--v3-domain_name-complaints-address'. It's better than a tautology but remains vague about scope and context.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'get--v3-domain_name-complaints-address' or other complaint-related tools. The description offers no context, prerequisites, or exclusions, leaving the agent without direction.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure but offers none. It doesn't indicate whether this is a read-only operation, what permissions might be required, whether it returns structured data, or any error conditions. 'Lookup' implies a query but provides no behavioral context about what the tool actually does beyond the minimal verb.

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

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

The description is extremely concise (two words) and front-loaded, but this conciseness comes at the cost of severe under-specification. While there's no wasted text, the description fails to provide necessary information that would require more content. It's technically efficient but substantively inadequate.

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

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

Given a tool with 2 required parameters (0% schema coverage), no annotations, no output schema, and multiple similar sibling tools, the description is completely inadequate. It doesn't explain what the tool returns, how to interpret results, what the parameters represent, or when to choose this tool over alternatives. For a lookup operation with specific parameters, this leaves the agent with insufficient guidance.

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

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

The schema has 0% description coverage for both required parameters (domain_name and address), and the description provides absolutely no information about what these parameters mean, their format, or their relationship. The description doesn't even mention that parameters exist, let alone explain their semantics. This leaves both parameters completely undocumented.

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 'Lookup complaint record' restates the tool name (which contains 'complaints') without adding specificity. It doesn't clarify what type of complaint record, what domain it relates to, or what distinguishes it from sibling tools like 'get--v3-domain_name-complaints' (without address parameter). The verb 'lookup' is generic and doesn't provide meaningful 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?

The description provides zero guidance on when to use this tool versus alternatives. There's no mention of prerequisites, appropriate contexts, or comparison to sibling tools like 'get--v3-domain_name-complaints' (which appears similar but lacks the address parameter). The agent receives no usage direction.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. 'Get templates' implies a read operation but fails to describe key behaviors: it doesn't specify if this is a list operation, pagination handling, authentication needs, rate limits, or what the return format looks like. The description lacks any behavioral context beyond the basic action, making it inadequate for a tool with 4 parameters and 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?

The description is extremely concise with just two words, 'Get templates', which is front-loaded and wastes no space. While this brevity leads to under-specification in other dimensions, it scores high for conciseness as every word directly contributes to the core purpose without redundancy or fluff.

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

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

Given the tool's complexity (4 parameters, 0% schema coverage, no annotations, no output schema), the description is completely inadequate. It fails to explain the tool's behavior, parameter meanings, usage context, or return values. For a tool that likely involves retrieving templates with pagination and domain-specific filtering, the description lacks essential details needed for effective use.

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

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

Schema description coverage is 0%, meaning none of the 4 parameters (domain_name, page, limit, p) are documented in the schema. The description 'Get templates' adds no parameter semantics—it doesn't explain what domain_name refers to, how pagination works with page and p, what limit controls, or the purpose of the enum values for page. This leaves all parameters undocumented and unclear.

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

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

The description 'Get templates' is a tautology that restates the tool name without adding meaningful context. It specifies the verb 'Get' and resource 'templates', but lacks specificity about what templates are being retrieved (e.g., email templates for a domain) and doesn't differentiate from sibling tools like 'get--v3-domain_name-templates-template_name' or 'get--v3-domain_name-templates-template_name-versions'. This minimal description provides only basic purpose without clarity on scope or distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context, or exclusions, such as requiring a domain_name parameter or how it differs from related template tools. With multiple sibling tools involving templates, the lack of usage guidelines leaves the agent without direction on appropriate selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure but offers none. It doesn't indicate whether this is a read-only operation, what permissions are required, how errors are handled, or any rate limits. The single phrase 'Get template' fails to describe any behavioral traits, leaving critical operational context missing.

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

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

While concise with only two words, the description is under-specified rather than efficiently structured. It lacks front-loaded critical information and fails to earn its place by providing necessary context. The brevity here is a detriment, as it omits essential details without adding clarity.

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

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

Given the complexity of a tool with 3 parameters (2 required), 0% schema coverage, no annotations, and no output schema, the description is completely inadequate. It doesn't compensate for the lack of structured data, leaving the agent without enough information to understand what the tool does, how to use it, or what to expect in return.

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

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

The schema description coverage is 0%, meaning none of the three parameters (domain_name, template_name, active) are documented in the schema. The description adds no information about these parameters—it doesn't explain what they represent, their expected formats, or the optional 'active' parameter's purpose. This leaves all parameters semantically undefined.

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

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

The description 'Get template' is a tautology that merely restates the tool name without adding meaningful context. It doesn't specify what kind of template (email, web, configuration) or what resource domain it operates on, nor does it distinguish this from sibling tools like 'get--v3-domain_name-templates' or 'get--v3-domain_name-templates-template_name-versions'. The purpose remains vague beyond the basic verb-noun pairing.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites like authentication, differentiate it from related sibling tools (e.g., to list templates vs. get a specific one), or specify any context for usage. This leaves the agent with no actionable information for tool selection.

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

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

With no annotations provided, the description carries full burden but only states the basic action. It doesn't disclose behavioral traits such as pagination behavior (implied by 'page' and 'limit' parameters), rate limits, authentication needs, or what 'get all' entails (e.g., list vs. details). The description is minimal and lacks critical operational context.

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

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

The description is extremely concise with just three words, front-loaded and zero waste. It efficiently states the core purpose without unnecessary elaboration, though this brevity contributes to gaps 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?

Given 5 parameters with 0% schema coverage, no annotations, no output schema, and sibling tools indicating a complex domain (email/template management), the description is incomplete. It doesn't address pagination, return format, error conditions, or how it fits into the broader toolset, making it inadequate for effective use.

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

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

Schema description coverage is 0%, so the description must compensate but adds no parameter information. It doesn't explain the meaning of domain_name, template_name, page, limit, or p, leaving all 5 parameters undocumented. The description fails to provide any semantic context beyond the tool name.

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

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

The description 'Get all template versions' clearly states the action (get) and resource (template versions), but it's vague about scope and doesn't differentiate from sibling tools like 'get--v3-domain_name-templates-template_name' or 'get--v3-domain_name-templates-template_name-versions-version_nam'. It lacks specificity about what 'all' means in context.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites like requiring domain_name and template_name, nor does it contrast with sibling tools that might handle single versions or templates. Usage context is implied but not explicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure but offers none. It doesn't indicate if this is a read-only operation, what permissions are required, whether it returns data or metadata, or any error conditions. 'Get a version' implies retrieval but lacks details on response format, rate limits, or side effects, making it inadequate for a tool with 3 required parameters.

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

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

The description is extremely concise with just three words, but this brevity results in under-specification rather than effective communication. While front-loaded, it lacks necessary detail, making it inefficient for the agent's understanding. It avoids redundancy but at the cost of clarity.

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

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

Given the tool's complexity (3 required parameters, no annotations, 0% schema coverage, no output schema), the description is completely inadequate. It doesn't explain what a 'version' is in this context, how parameters interact, what data is returned, or any behavioral aspects. This leaves critical gaps for the agent to invoke the tool correctly.

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

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

The schema has 0% description coverage, meaning none of the 3 parameters (domain_name, template_name, version_name) are documented in the schema. The description 'Get a version' adds no semantic meaning about these parameters—it doesn't explain what they represent, their format, or how they relate to retrieving a version. This fails to compensate for the schema's lack of documentation.

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

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

The description 'Get a version' is a tautology that restates the tool name's 'get' action without specifying what resource 'version' refers to. It doesn't distinguish this tool from its sibling 'get--v3-domain_name-templates-template_name-versions' which likely lists versions, nor does it clarify what kind of version (e.g., template version) is being retrieved. The purpose remains vague beyond the basic verb.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites like needing a domain, template, and version name, nor does it differentiate it from sibling tools like 'get--v3-domain_name-templates-template_name' or 'get--v3-domain_name-templates'. This leaves the agent with no context for tool selection.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'List all unsubscribes' implies a read-only operation but does not specify pagination, rate limits, authentication needs, or what 'all' entails (e.g., time range, filtering). This leaves significant gaps in understanding the tool's behavior.

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

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

The description is extremely concise with a single sentence, 'List all unsubscribes', which is front-loaded and wastes no words. It efficiently conveys the core action, though it may be overly brief for the tool's complexity.

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

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

Given the complexity (5 parameters, 3 required, no output schema, and no annotations), the description is incomplete. It does not address parameter usage, behavioral traits, or output expectations, making it inadequate for effective tool selection and invocation by an AI agent.

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

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

The input schema has 5 parameters with 0% description coverage, and the description does not mention any parameters. It fails to add meaning beyond the schema, such as explaining what 'domain_name', 'address', or 'term' represent in the context of listing unsubscribes, which is critical given the low 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 'List all unsubscribes' clearly states the verb ('List') and resource ('unsubscribes'), making the purpose understandable. However, it lacks specificity about scope (e.g., for a domain) and does not distinguish from sibling tools like 'get--v3-domain_name-unsubscribes-address', which appears related but is not differentiated 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?

No guidance is provided on when to use this tool versus alternatives, such as the sibling 'get--v3-domain_name-unsubscribes-address'. The description does not mention context, prerequisites, or exclusions, leaving usage unclear beyond the basic purpose.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. 'Lookup' implies a read-only operation, but it doesn't specify whether this requires authentication, returns a single record or list, includes error handling, or has rate limits. For a tool with two required parameters and no annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence with no wasted words. However, it's under-specified rather than concise—it lacks necessary details but doesn't include extraneous information. It's front-loaded but too minimal to be fully helpful.

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

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

Given the tool has 2 required parameters, 0% schema description coverage, no annotations, and no output schema, the description is incomplete. It doesn't cover parameter meanings, behavioral traits, or output expectations, making it insufficient for an agent to use the tool effectively without additional context.

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

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

Schema description coverage is 0%, so the schema provides no parameter descriptions. The description doesn't mention parameters at all, failing to explain what 'domain_name' and 'address' represent (e.g., email domain and recipient address) or their expected formats. This leaves both parameters undocumented, which is inadequate for a tool with two required inputs.

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 'Lookup unsubscribe record' states a verb ('Lookup') and resource ('unsubscribe record'), providing a basic purpose. However, it's vague about what exactly is being looked up and doesn't distinguish this tool from sibling tools like 'get--v3-domain_name-unsubscribes' (which likely lists multiple unsubscribes) or 'get--v3-domain_name-bounces-address' (which has similar structure for bounces).

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a domain and address), contrast it with sibling tools (like the broader 'get--v3-domain_name-unsubscribes'), or specify use cases. This leaves the agent without context for tool selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a list operation, implying it's likely read-only, but doesn't confirm safety, permissions, rate limits, pagination behavior, or what the output looks like. For a tool with 5 parameters and no annotation coverage, this leaves significant behavioral gaps.

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

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

The description is a single, efficient sentence with zero wasted words. It's appropriately sized and front-loaded, making it easy to parse quickly.

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

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

Given the complexity (5 parameters, 3 required, no output schema, no annotations), the description is inadequate. It doesn't explain parameter usage, output format, behavioral constraints, or how this tool fits among siblings. For a list operation with multiple filtering parameters, more context is needed for effective use.

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

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

Schema description coverage is 0%, so the schema provides no parameter documentation. The description mentions 'domain' which loosely relates to the 'domain_name' parameter, but doesn't explain the purpose of the other 4 parameters (limit, page, address, term) or why 3 are required. It adds minimal semantic value beyond the schema.

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

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

The description 'List allowlist records for domain' states the basic action (list) and target (allowlist records for domain), but it's vague about what 'allowlist records' specifically are and doesn't distinguish from siblings like 'get--v3-domain_name-whitelists-value'. It provides a minimal purpose without sibling differentiation.

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

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

No guidance on when to use this tool versus alternatives is provided. The description doesn't mention any prerequisites, exclusions, or context for usage, leaving the agent with no direction on when this tool is appropriate compared to other listing or filtering tools in the sibling set.

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

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

No annotations are provided, so the description carries full burden. It only states 'Lookup', implying a read-only operation, but fails to disclose any behavioral traits such as authentication needs, rate limits, error conditions, or what happens if the record isn't found. This is inadequate for a tool with two required parameters.

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

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

The description is extremely concise with just three words, front-loading the core action. There's no wasted verbiage, though this brevity contributes to underspecification rather than clarity.

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

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

Given no annotations, 0% schema coverage, no output schema, and two required parameters, the description is completely inadequate. It fails to explain what the tool does beyond a vague phrase, leaving critical gaps in understanding purpose, parameters, and 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 0%, meaning parameters 'domain_name' and 'value' are undocumented in the schema. The description adds no semantic information about these parameters, such as what they represent, their format, or examples. It doesn't compensate for the lack of schema documentation.

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 'Lookup allowlist record' restates the tool name with minimal elaboration. It specifies a verb ('Lookup') and resource ('allowlist record'), but lacks specificity about what domain or value is being looked up, and doesn't distinguish it from sibling tools like 'get--v3-domain_name-whitelists' which likely lists all whitelists rather than looking up a specific record.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites, context, or comparisons to sibling tools, leaving the agent with no usage direction.

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. 'Get tag limits' implies a read-only operation, but it doesn't specify what 'limits' refers to (e.g., usage quotas, rate limits, configuration limits), whether authentication is required, potential side effects, error conditions, or response format. The description provides no behavioral context beyond the basic action.

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

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

The description is extremely concise at just three words ('Get tag limits'), with no wasted words or unnecessary elaboration. It's front-loaded with the core action, though this brevity comes at the cost of clarity and completeness. Every word serves a purpose, even if that purpose is minimal.

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

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

Given the complexity implied by the tool name (involving domains, limits, and tags), the lack of annotations, 0% schema description coverage, and no output schema, the description is completely inadequate. It doesn't explain what 'tag limits' are, how they're retrieved, what the 'domain' parameter means, or what the tool returns. For a tool with one required parameter and no structured documentation, this description provides almost no useful context.

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

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

The input schema has 1 parameter ('domain') with 0% description coverage, meaning the schema provides no documentation for this parameter. The description 'Get tag limits' doesn't mention the 'domain' parameter at all, nor does it explain what 'tag limits' are or how they relate to the domain. With low schema coverage, the description fails to compensate by adding meaningful parameter context.

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

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

The description 'Get tag limits' is a tautology that essentially restates the tool name 'get--v3-domains-domain-limits-tag'. It provides a verb ('Get') and resource ('tag limits'), but lacks specificity about what 'tag limits' actually means in this context. It doesn't distinguish this tool from sibling tools like 'get--v3-domain-tag' or 'get--v3-domain-tag-stats', which also involve tags.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools involving domains, tags, and statistics (e.g., 'get--v3-domain-tag', 'get--v3-domain-tag-stats', 'get--v3-domain-tag-stats-aggregates'), there's no indication of what makes this tool unique or when it's appropriate. No prerequisites, exclusions, or contextual cues are mentioned.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'Retrieve', implying a read-only operation, but doesn't specify whether this requires authentication, rate limits, error conditions, or the format of the returned email. For a tool with zero annotation coverage, this leaves significant behavioral gaps.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action, making it easy to scan and understand quickly.

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

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

Given the complexity of retrieving stored emails, the lack of annotations, no output schema, and 0% schema coverage for parameters, the description is incomplete. It doesn't cover behavioral aspects, parameter meanings, or return values, making it insufficient for effective tool use.

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

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

Schema description coverage is 0%, so the schema provides no parameter details. The description adds no information about what 'domain_name' or 'storage_key' represent, their formats, or examples. With two required parameters and no compensation in the description, this is inadequate for understanding inputs.

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 'Retrieve' and the resource 'a stored email', making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'get--v3-domain_name-messages' or 'post--v3-domains-domain_name-messages-storage_key', which might handle similar email-related operations.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, such as needing a specific domain or storage key, or contrast it with other email retrieval tools in the sibling list, leaving usage context unclear.

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 states the action ('Get') without details on permissions required, rate limits, error handling, or response format. For a tool with two required parameters and no output schema, this is a significant gap in transparency about how the tool behaves beyond its basic function.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action, though it could be more structured by explicitly mentioning parameters. However, its brevity is appropriate given the lack of additional context needed for clarity.

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

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

Given the tool's complexity (2 required parameters, no annotations, no output schema), the description is incomplete. It doesn't explain what 'webhook_name' means, how results are returned, or any behavioral traits like error conditions. Without annotations or output schema, the description should provide more context to guide effective use, but it falls short.

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 0%, meaning parameters 'domain_name' and 'webhook_name' are undocumented in the schema. The description adds minimal value by implying these parameters are used to filter 'by type', but it doesn't explain what 'webhook_name' represents (e.g., a specific webhook identifier, a type name) or provide examples. It fails to compensate for the low 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 'Get domain webhooks by type' states a clear verb ('Get') and resource ('domain webhooks'), but it's vague about what 'by type' means. It doesn't specify whether it retrieves a single webhook, multiple webhooks filtered by type, or metadata about webhook types. Compared to siblings like 'get--v3-domains-domain-webhooks' (likely lists all webhooks) and 'put--v3-domains-domain_name-webhooks-webhook_name' (updates a specific webhook), it lacks clear 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid domain_name and webhook_name), contrast with sibling tools (e.g., 'get--v3-domains-domain-webhooks' for listing all webhooks), or specify use cases. This leaves the agent guessing about appropriate contexts.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure but fails to do so. It does not indicate whether this is a read-only operation, if it requires authentication, or any rate limits. The phrase 'List of' implies a read operation, but without explicit confirmation, it remains insufficient for safe tool invocation.

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

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

The description is a single, efficient phrase with no wasted words. It is front-loaded and to the point, though its brevity contributes to under-specification rather than clarity. The structure is appropriate for its length, but it lacks the necessary detail to be fully helpful.

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

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

Given the tool's complexity (one parameter with no schema coverage), no annotations, and no output schema, the description is incomplete. It fails to explain the parameter, the tool's behavior, or the output format. For a tool that likely interacts with domain-specific data, this minimal description is inadequate for effective use.

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

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

The input schema has one required parameter ('domain') with 0% description coverage, meaning the schema provides no details about this parameter. The description does not mention the parameter at all, offering no compensation for the lack of schema documentation. This leaves the agent guessing about the parameter's purpose and format.

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

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

The description 'List of supported country codes' is vague—it states what the output is rather than what the tool does. It lacks a clear verb (e.g., 'retrieve' or 'fetch') and does not specify the resource or context (e.g., for a domain or tag). This makes it tautological, as it restates the tool's name without clarifying its function.

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

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

No guidance is provided on when to use this tool versus alternatives. Sibling tools like 'get--v3-domain-aggregates-countries' suggest similar functionality, but the description offers no differentiation or context for selection. This absence of usage instructions leaves the agent without direction.

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. The phrase 'List of supported devices' suggests a read-only operation, but it doesn't clarify whether this is a safe query, what permissions might be required, whether results are paginated, what format the output takes, or any error conditions. For a tool with no annotation coverage, this description provides essentially zero behavioral context beyond the minimal implication of 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?

The description is extremely concise at just three words, which could be appropriate if it were more informative. However, this brevity comes at the cost of being under-specified rather than efficiently informative. While it's not verbose or poorly structured, it fails to provide the necessary context that would justify such extreme conciseness.

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

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

Given the tool's apparent complexity (involving domains, tags, and devices), the complete lack of annotations, 0% schema description coverage, no output schema, and the presence of many similar sibling tools, this description is completely inadequate. It provides almost no useful information about what the tool does, how to use it, what to expect, or when to choose it over alternatives. The agent would be operating almost entirely in the dark.

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

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

The input schema has one required parameter 'domain' with 0% description coverage in the schema itself. The tool description provides no information about this parameter - what it represents, what format it expects, what values are valid, or how it affects the results. The description doesn't even mention that a domain parameter is required. With low schema coverage and no parameter information in the description, this creates significant ambiguity about how to use the tool correctly.

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

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

The description 'List of supported devices' is a tautology that essentially restates the tool name 'get--v3-domains-domain-tag-devices'. It doesn't specify what action is performed (list? retrieve? filter?), what resource is being accessed (devices for a domain? devices with a tag?), or how it differs from sibling tools like 'get--v3-domain-aggregates-devices'. The description provides minimal value beyond the name itself.

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

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

The description provides absolutely no guidance about when to use this tool versus alternatives. There are multiple sibling tools that appear related to domains, tags, and devices (e.g., 'get--v3-domain-aggregates-devices', 'get--v3-domains-domain-tag-countries'), but the description offers no context about how this tool differs from them or what specific use case it addresses. The agent would have no basis for choosing this tool over similar-looking alternatives.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. It fails to do so—it does not indicate whether this is a read-only operation, if it requires authentication, what the output format might be, or any rate limits. The description is too minimal to provide any behavioral context beyond the implied 'List' action.

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

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

The description is extremely concise with a single phrase 'List of supported providers', which is front-loaded and wastes no words. However, this conciseness comes at the cost of clarity and completeness, but based solely on brevity and structure, it scores highly.

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

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

Given the tool has one parameter with no schema description, no annotations, no output schema, and a vague purpose, the description is completely inadequate. It fails to provide necessary context for the agent to understand what the tool does, how to use it, or what to expect, making it insufficient for effective tool invocation.

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

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

The input schema has one required parameter 'domain' with 0% description coverage, and the tool description adds no information about this parameter. It does not explain what 'domain' represents (e.g., a domain name, identifier) or its role in listing providers, leaving the parameter's meaning and usage completely undocumented.

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

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

The description 'List of supported providers' is vague and tautological—it essentially restates the tool name 'get--v3-domains-domain-tag-providers' without specifying what 'providers' are (e.g., email service providers, tag providers) or what action 'List' entails (e.g., retrieve, display). It lacks a clear verb-resource distinction, making it unclear what the tool actually does beyond the name.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention any context, prerequisites, or sibling tools (e.g., other domain-tag-related tools like 'get--v3-domains-domain-tag-countries'), leaving the agent with no information on appropriate usage scenarios.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Get' implies a read-only operation, but the description doesn't specify whether this requires authentication, returns paginated results, has rate limits, or what the output format might be. It lacks details on error conditions, side effects, or performance characteristics, leaving significant gaps for a tool with unknown behavioral traits.

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

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

The description is extremely concise at three words, with no wasted language. It's front-loaded with the core action and resource, though this brevity comes at the cost of completeness. Every word earns its place by stating the basic operation, but it lacks necessary elaboration.

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

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

Given the tool's complexity (a read operation with one parameter), no annotations, no output schema, and 0% schema description coverage, the description is incomplete. It doesn't explain what 'domain webhooks' are, how results are structured, or any behavioral aspects. For a tool in a domain with many siblings, more context is needed to guide effective use.

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

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

The input schema has one parameter ('domain') with 0% description coverage, meaning the schema provides no semantic context. The description adds no information about this parameter—it doesn't explain what 'domain' represents, its format, or examples. For a single undocumented parameter, the description fails to compensate, leaving the agent to guess its meaning.

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

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

The description 'Get domain webhooks' is a tautology that essentially restates the tool name. While it indicates a read operation ('Get') on a resource ('domain webhooks'), it lacks specificity about what 'domain webhooks' entails (e.g., listing webhooks, retrieving configurations). It doesn't differentiate from sibling tools like 'get--v3-domains-domain_name-webhooks-webhook_name', which appears to target a specific 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context, or exclusions, nor does it reference sibling tools for comparison. Without any usage context, an agent must infer everything from the name and schema alone.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. 'Get messages queue status' implies a read-only operation, but it does not specify authentication requirements, rate limits, error conditions, or what the output looks like (e.g., queue metrics, status codes). For a tool with no annotation coverage, this is a significant gap in behavioral context.

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

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

The description 'Get messages queue status' is extremely concise—a single phrase with no wasted words. It is front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place by conveying the essential purpose without redundancy.

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

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

Given the complexity (a tool with one parameter but no schema descriptions or annotations) and lack of output schema, the description is incomplete. It does not explain what 'messages queue status' returns, how to interpret results, or any behavioral nuances. For a tool in a domain with many similar siblings, this minimal description is inadequate for effective use.

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

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

The input schema has one required parameter 'name' with 0% description coverage, and the tool description does not mention any parameters. The description fails to add meaning beyond the schema, such as explaining what 'name' refers to (e.g., a domain name, queue identifier) or its format. With low schema coverage, the description does not compensate, leaving parameters undocumented.

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

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

The description 'Get messages queue status' clearly indicates a retrieval operation (verb 'Get') on a specific resource ('messages queue status'), which is better than a tautology. However, it lacks specificity about what 'messages queue status' entails or how it differs from sibling tools like 'get--v3-domain_name-bounces' or 'get--v3-domain_name-complaints', which also retrieve domain-related data. The purpose is vague but not misleading.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools (e.g., 'get--v3-domain_name-bounces', 'get--v3-domain_name-complaints') that also retrieve domain-specific data, there is no indication of context, prerequisites, or exclusions. This leaves the agent without direction for tool selection.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Get tracking settings' implies a read-only operation, but it doesn't specify whether it requires authentication, rate limits, error conditions, or what the return format looks like. For a tool with no annotation coverage, this minimal description fails to provide necessary behavioral context.

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

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

The description is extremely concise with just three words, front-loading the core action and resource. There is no wasted verbiage or unnecessary structure, making it efficient in terms of brevity, though this comes at the cost of 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?

Given the tool's complexity (1 parameter with 0% schema coverage, no annotations, no output schema), the description is completely inadequate. It doesn't explain what tracking settings are, how to use the parameter, what the tool returns, or any behavioral traits. For a tool that likely interacts with domain tracking data, this minimal description fails to provide the necessary context for effective use.

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

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

The input schema has 1 parameter ('name') with 0% description coverage, meaning the schema provides no semantic information. The description 'Get tracking settings' adds no meaning about what the 'name' parameter represents (e.g., a domain name, tracking type, or identifier). This leaves the parameter completely undocumented, failing to compensate for the schema gap.

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

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

The description 'Get tracking settings' restates the tool name ('get--v3-domains-name-tracking') in a tautological manner. It specifies the verb 'Get' and resource 'tracking settings', but lacks specificity about what tracking settings are (e.g., for a domain) and doesn't differentiate from sibling tools like 'put--v3-domains-name-tracking-click' which modify tracking settings.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites, context, or exclusions, and doesn't reference sibling tools that might be related (e.g., put tools for updating tracking settings). This leaves the agent without direction on appropriate usage scenarios.

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

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

No annotations are provided, and the description offers zero behavioral information. It doesn't indicate whether this is a read-only operation, what authentication might be required, whether it has rate limits, what format the totals are returned in, or any other behavioral characteristics. For a tool with 6 parameters and no annotation coverage, this is completely inadequate.

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

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

The description is extremely concise (4 words), but this is more under-specification than effective brevity. While it's front-loaded with the core concept ('Totals'), the extreme brevity comes at the cost of providing any useful information. It's not verbose, but it's also not helpful.

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 completely inadequate for a tool with 6 parameters, no annotations, no output schema, and numerous sibling alternatives. The description fails to explain what the tool does, when to use it, what the parameters mean, what behavior to expect, or what results will be returned. Given the complexity implied by the parameter count and sibling tool ecosystem, this description provides almost no useful context.

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

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

With 0% schema description coverage for all 6 parameters (domain, start, end, resolution, duration, event), the description provides absolutely no information about what these parameters mean, their expected formats, or how they affect the 'totals' calculation. The description doesn't mention any parameters at all, leaving the agent completely in the dark about how to use this tool.

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

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

The description 'Totals for entire domain' is vague and tautological - it essentially restates the tool name 'get--v3-domain-stats-total' without specifying what kind of totals or what statistics are being aggregated. It doesn't clearly distinguish this from sibling tools like 'get--v3-domain-tag-stats' or 'get--v3-stats-total' which also appear to provide statistical data.

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

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

The description provides absolutely no guidance about when to use this tool versus alternatives. With numerous sibling tools providing various statistics and aggregates (domain-aggregates, tag-stats, bounce stats, etc.), there's no indication of what makes this 'total stats' tool unique or when it should be selected over other statistical tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Get a tag' implies a read-only operation but doesn't specify permissions, rate limits, error conditions, or response format. It lacks details on what 'tag' refers to in this context (e.g., a label for a domain), making it insufficient for safe and effective use.

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

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

The description is extremely concise with just three words, making it front-loaded and free of unnecessary details. However, this conciseness comes at the cost of clarity and completeness, but as a standalone assessment of brevity, it earns full marks for efficiency.

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

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

Given the tool's complexity (2 required parameters), lack of annotations, 0% schema description coverage, and no output schema, the description is completely inadequate. It doesn't explain the tool's purpose, parameters, behavior, or output, leaving the agent with insufficient information to invoke it correctly in context with sibling 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?

The input schema has 2 parameters (domain and tag) with 0% description coverage, meaning they are entirely undocumented. The description 'Get a tag' adds no semantic information about these parameters—it doesn't explain what 'domain' and 'tag' represent, their expected formats, or how they relate to the operation, failing to compensate for the schema's lack of documentation.

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

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

The description 'Get a tag' is a tautology that merely restates the tool name without adding meaningful context. While it indicates a retrieval action, it doesn't specify what kind of tag (e.g., email domain tag, metadata tag) or what resource it operates on, making it vague compared to sibling tools like 'get--v3-domain-tags' or 'get--v3-domain-tag-stats'.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention any prerequisites, context, or distinctions from sibling tools such as 'get--v3-domain-tags' (which might list tags) or 'get--v3-domain-tag-stats' (which might provide statistics), leaving the agent with no usage direction.

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

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

No annotations are provided, so the description carries full burden. 'List all tags' implies a read-only operation, but it doesn't disclose behavioral traits like pagination (suggested by 'page' and 'limit' parameters), rate limits, authentication needs, or what 'all' entails (e.g., across a domain). This leaves significant gaps for safe invocation.

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

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

The description is extremely concise with 'List all tags'—a single, front-loaded phrase that efficiently states the core action. There's no wasted verbiage, making it easy to parse, though this brevity contributes to gaps 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?

Given the complexity (5 parameters, 1 required, no output schema, no annotations), the description is incomplete. It doesn't explain the tool's behavior, parameter usage, or output format, leaving the agent under-informed for a tool with multiple inputs and potential filtering/pagination logic.

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 description adds no parameter semantics beyond the schema, which has 0% description coverage for 5 parameters (domain, page, limit, tag, prefix). Without explanation of what these parameters do (e.g., 'domain' is required, 'tag' might filter), the agent lacks context to use them effectively, failing to compensate for the low 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 'List all tags' states a clear verb ('List') and resource ('tags'), but it's vague about scope and context. It doesn't specify what kind of tags (e.g., email tags, domain tags) or differentiate from sibling tools like 'get--v3-domain-tag' or 'get--v3-domains-domain-limits-tag', which might handle similar resources differently.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools (e.g., 'get--v3-domain-tag', 'get--v3-domain-tag-stats'), there's no indication of context, prerequisites, or exclusions, leaving the agent to infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Get stats by tag' implies a read-only operation but doesn't specify authentication requirements, rate limits, pagination behavior, error conditions, or what the output looks like (no output schema exists). For a tool with 10 parameters and no annotation coverage, this is a significant gap in behavioral transparency.

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

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

The description is extremely concise at just three words. While this represents under-specification rather than ideal conciseness, it contains no wasted words and is front-loaded with the core purpose. Every word earns its place, though more content would be needed for a complete description.

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

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

Given the complexity (10 parameters, 3 required), zero schema description coverage, no annotations, and no output schema, the description is completely inadequate. It doesn't explain what type of stats are retrieved, what the parameters mean, how to interpret results, or how this differs from similar tools. For a statistical retrieval tool with significant parameter complexity, this description provides insufficient context.

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

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

The schema description coverage is 0%, meaning none of the 10 parameters have descriptions in the schema. The tool description 'Get stats by tag' only mentions one parameter ('tag') and doesn't explain the purpose of the other 9 parameters (domain, start, end, resolution, duration, provider, device, country, event) or their relationships. This fails to compensate for the complete lack of schema documentation.

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

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

The description 'Get stats by tag' restates the tool name 'get--v3-domain-tag-stats' in a tautological manner. It specifies the verb 'Get' and resource 'stats by tag', but doesn't clarify what type of stats (e.g., email analytics, performance metrics) or what domain context is involved. It fails to distinguish this tool from sibling tools like 'get--v3-domain-tag-stats-aggregates' or 'get--v3-domain-stats-total'.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools available (e.g., 'get--v3-domain-aggregates-countries', 'get--v3-domain-tag-stats-aggregates'), there's no indication of what makes this tool unique or when it should be selected over similar tools. No prerequisites, exclusions, or alternative recommendations are mentioned.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. It only states the action without detailing whether it's read-only, has side effects, requires authentication, involves rate limits, or describes output format. This leaves critical behavioral aspects unspecified.

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

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

The description is a single, efficient sentence with no wasted words, making it front-loaded and easy to parse. However, this conciseness comes at the cost of under-specification.

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

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

Given the tool's complexity (3 required parameters), lack of annotations, 0% schema coverage, and no output schema, the description is severely incomplete. It does not provide enough information for an agent to understand the tool's purpose, usage, behavior, or parameters adequately.

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

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

The schema has 0% description coverage, with three required parameters (domain, tag, type) undocumented. The description mentions 'tag' but does not explain any parameters' meanings, formats, or constraints, failing to compensate for the schema's lack of documentation.

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

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

The description 'Get aggregate stat types by tag' restates the tool name with minimal elaboration, making it tautological. It specifies the action ('Get') and resource ('aggregate stat types by tag'), but lacks detail on what 'aggregate stat types' or 'tag' refer to, and does not differentiate from sibling tools like 'get--v3-domain-tag-stats' or 'get--v3-domain-stats-total'.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention prerequisites, context, or exclusions, leaving the agent without direction on appropriate usage scenarios compared to sibling tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is a list operation, implying it's likely read-only and non-destructive, but it doesn't confirm this or add any other behavioral traits (e.g., authentication needs, rate limits, pagination, or response format). For a tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without any wasted words. It's front-loaded with the key action ('List'), making it easy to parse and understand quickly.

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

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

Given the tool's low complexity (0 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks behavioral details and usage context. Without annotations or output schema, the description should ideally provide more guidance on response format or limitations, but it meets the basic requirement for a simple list tool.

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

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

The input schema has 0 parameters with 100% description coverage, meaning no parameters need documentation. The description doesn't add parameter details, which is appropriate here. A baseline of 4 is applied since the schema fully handles the parameter semantics, and the description doesn't need to compensate.

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

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

The description clearly states the verb ('List') and resource ('dedicated IP pools of the account'), making the purpose specific and understandable. However, it doesn't explicitly distinguish this tool from sibling tools like 'get--v3-ips' or 'get--v5-accounts-subaccounts-ip_pools-all', which might also list IP-related resources, so it doesn't achieve 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?

The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'get--v3-ips' (which lists individual IPs) and 'get--v5-accounts-subaccounts-ip_pools-all' (which lists IP pools across subaccounts), there's clear potential for confusion, but the description offers no context or exclusions to help an agent choose appropriately.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. 'Get DIPP details' implies a read-only operation but doesn't confirm safety, permissions required, rate limits, or what the response contains (e.g., format, error handling). It fails to add meaningful context beyond the basic implication of retrieval, leaving critical behavioral aspects undocumented.

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

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

The description is extremely concise ('Get DIPP details'), but this brevity results in under-specification rather than effective conciseness. It lacks necessary details about purpose, parameters, or usage, making it inefficient for an agent's understanding. While front-loaded, it doesn't earn its place with informative 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?

Given the complexity of a tool with 1 undocumented parameter, no annotations, and no output schema, the description is completely inadequate. It doesn't explain what 'DIPP' is, what details are returned, how to use the pool_id, or any behavioral aspects. For a retrieval tool in a context with many sibling tools, this leaves the agent without sufficient information to invoke it correctly.

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

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

The input schema has 1 parameter (pool_id) with 0% description coverage, meaning the schema provides no semantic information. The description 'Get DIPP details' adds no clarification about what pool_id represents (e.g., an identifier for an IP pool), its format, or where to obtain it. This leaves the parameter entirely undocumented, failing to compensate for the schema's lack of 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 'Get DIPP details' is a tautology that essentially restates the tool name 'get--v3-ip_pools-pool_id' (get operation on IP pools). It doesn't specify what 'DIPP' means or what kind of details are retrieved, making the purpose vague. While it indicates a retrieval action, it lacks the specificity needed to distinguish it from sibling tools like 'get--v3-ip_pools' (which likely lists pools) or 'get--v3-ip_pools-pool_id-domains' (which might get domains for a pool).

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid pool_id), exclusions, or comparisons to sibling tools like 'get--v3-ip_pools' (for listing pools) or 'get--v3-ips' (for IP details). Without any usage context, an agent cannot make informed decisions about tool selection.

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

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

No annotations are provided, so the description carries full burden. It only states a read operation ('Get') but doesn't disclose behavioral traits such as pagination (implied by 'limit' and 'page' parameters), rate limits, authentication needs, or what 'linked' entails. This is inadequate for a tool with parameters.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded and appropriately sized for its minimal content, though this conciseness comes at the cost 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?

Given no annotations, 0% schema coverage, no output schema, and three parameters, the description is incomplete. It lacks essential details like parameter explanations, behavioral context, and usage guidelines, making it insufficient for effective tool 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 0%, so the schema provides no parameter descriptions. The description adds no meaning beyond the schema—it doesn't explain 'pool_id', 'limit', or 'page', leaving all three parameters undocumented. This fails to compensate for the coverage gap.

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

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

The description 'Get domains linked to DIPP' states a basic action but is vague. 'DIPP' is unexplained (likely 'Dynamic IP Pool'), and it doesn't specify what 'linked' means (e.g., associated, assigned). It distinguishes from siblings by mentioning 'DIPP' but lacks clarity on the exact resource and operation.

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

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

No guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context, or compare with sibling tools like 'get--v3-ips-ip-domains' or 'get--v3-domains', leaving the agent without usage direction.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. 'List account IPs' implies a read-only operation but doesn't specify permissions needed, rate limits, pagination behavior, or what 'account IPs' encompasses (e.g., dedicated vs. shared). The description lacks crucial context for safe and effective use.

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

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

The description is extremely concise at just three words, front-loading the core purpose with zero wasted language. It's appropriately sized for what it communicates, though it could benefit from additional 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 tool with 2 undocumented parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what the parameters do, what the output looks like, or behavioral constraints. Given the complexity implied by filtering parameters and the lack of structured documentation, this description leaves too many gaps.

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

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

The input schema has 2 parameters (dedicated, enabled) with 0% description coverage, meaning the schema provides no semantic information. The description 'List account IPs' doesn't mention these parameters at all, failing to compensate for the schema's lack of documentation. Users have no clue what these boolean filters do.

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

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

The description 'List account IPs' clearly states the action (list) and resource (account IPs), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling tools like 'get--v3-ip_pools' or 'get--v3-ips-ip', which appear related to IP management but serve different purposes.

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

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

The description provides no guidance on when to use this tool versus alternatives. With multiple sibling tools related to IPs and domains, there's no indication of whether this is for listing all account IPs, filtered IPs, or how it differs from other IP-related tools like 'get--v3-ip_pools'.

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

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

No annotations are provided, so the description carries full burden. It implies a read operation ('Get details'), but doesn't disclose behavioral traits such as authentication requirements, rate limits, error handling, or what the output looks like (e.g., JSON structure). For a tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded and appropriately sized for a simple tool, though this conciseness comes at the cost of detail 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?

Given the tool's complexity (1 parameter, no output schema, no annotations), the description is incomplete. It lacks details on parameter meaning, output format, behavioral context, and differentiation from siblings, making it inadequate for an agent to use the tool effectively without additional inference.

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

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

The input schema has 1 parameter with 0% description coverage, and the description doesn't add any semantic meaning beyond the schema. It doesn't explain what 'ip' represents (e.g., IPv4 address, account-specific IP), valid formats, or examples, failing to compensate for the low 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 'Get details about account IP' states a clear verb ('Get details') and resource ('account IP'), but it's vague about what specific details are retrieved. It doesn't distinguish from sibling tools like 'get--v3-ips' (which might list IPs) or 'get--v3-ip_pools-pool_id' (which might get pool details), leaving 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 guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., needing a specific IP), exclusions, or comparisons to siblings like 'get--v3-ips' for listing IPs or 'get--v3-ips-ip-domains' for related data, leaving the agent to infer usage.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions retrieving domains for a specific IP, but doesn't cover aspects like whether this is a read-only operation, potential rate limits, authentication needs, or what the return format looks like. This leaves significant gaps for a tool with 4 required parameters.

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

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

The description is a single, efficient sentence that directly states the tool's function without unnecessary words. It's appropriately sized and front-loaded, making it easy to grasp quickly.

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

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

Given the complexity of 4 required parameters, 0% schema coverage, no annotations, and no output schema, the description is incomplete. It should provide more details on parameters, behavioral traits, and expected outputs to adequately guide an AI agent.

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

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

Schema description coverage is 0%, so the schema provides no parameter details. The description only implies the 'ip' parameter's purpose ('specific IP is assigned') but doesn't explain 'limit', 'search', or 'skip', leaving three parameters undocumented. It adds minimal value beyond the schema.

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

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

The description clearly states the action ('Get all domains') and resource ('of an account where a specific IP is assigned'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'get--v3-ips-ip' or 'get--v3-ip_pools-pool_id-domains', which appear related to IPs and domains, so it lacks sibling distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as the sibling tools that handle IPs or domains. It states what the tool does but offers no context, exclusions, or prerequisites for usage.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. It only states 'Get mailing lists', offering no information on permissions, rate limits, pagination, response format, or whether it's read-only or has side effects. For a tool with three parameters and no output schema, this is a significant gap in transparency.

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

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

The description is concise with two words, but this brevity leads to under-specification rather than efficiency. It's front-loaded but lacks necessary detail, making it too sparse for a tool with multiple parameters and no annotations. While not verbose, it doesn't earn its place by providing useful 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?

Given the complexity (3 parameters, 0% schema coverage, no annotations, no output schema), the description is incomplete. It doesn't explain what the tool returns, how parameters affect results, or behavioral aspects like safety or performance. For a retrieval tool in a context with many siblings, this minimal description is inadequate.

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

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

The input schema has three parameters (limit, skip, address) with 0% description coverage, meaning their purposes are undocumented. The description 'Get mailing lists' adds no meaning about these parameters, such as that 'limit' controls pagination, 'skip' offsets results, or 'address' filters by email address. It fails to compensate for the schema's lack of documentation.

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

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

The description 'Get mailing lists' restates the tool name 'get--v3-lists' with minimal elaboration, making it tautological. It specifies the verb 'Get' and resource 'mailing lists', but lacks detail on scope (e.g., all lists, filtered lists) and doesn't distinguish from sibling tools like 'get--v3-lists-list_address', which likely retrieves a specific list. This is vague and offers little beyond the name.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools such as 'get--v3-lists-list_address' for retrieving a specific list or 'post--v3-lists' for creating lists, nor does it specify any context, prerequisites, or exclusions for usage. This leaves the agent without direction on tool selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a read operation ('Get'), but doesn't mention authentication requirements, rate limits, error conditions (e.g., what happens if the list address doesn't exist), or response format. This leaves significant gaps for a tool that likely interacts with a mailing list system.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly. Every word serves a purpose in conveying the basic functionality.

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

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

Given the lack of annotations, 0% schema description coverage, and no output schema, the description is incomplete. It doesn't address key contextual aspects like authentication, error handling, or what data is returned (e.g., list metadata, member count). For a tool with one required parameter in a domain with many sibling tools, this leaves the agent under-informed.

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

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

The schema has 0% description coverage, so the description must compensate. It mentions 'by address' which hints at the 'list_address' parameter, but doesn't explain what constitutes a valid address (e.g., format, domain constraints) or provide examples. This adds minimal value beyond the bare schema.

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

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

The description clearly states the verb ('Get') and resource ('a mailing list'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'get--v3-lists' (which likely lists all mailing lists) or 'get--v3-lists-list_address-members' (which gets members of a specific list), leaving room for ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid list address), exclusions, or comparisons to sibling tools like 'get--v3-lists' for broader queries, leaving the agent to infer usage context.

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

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

With no annotations provided, the description carries full burden but only states the action without behavioral details. It doesn't disclose if this is a read-only operation, how results are returned (e.g., paginated with limit/skip), error conditions, or rate limits, which are critical for a tool with multiple parameters.

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

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

The description is a single, efficient sentence with no wasted words, making it easy to parse. It's front-loaded with the core action, though this brevity contributes to gaps 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?

Given the tool's complexity (5 parameters, 1 required, no output schema, and no annotations), the description is incomplete. It fails to address key aspects like return format, pagination behavior, or error handling, making it inadequate for safe and effective use by an agent.

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

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

Schema description coverage is 0%, so the description must compensate but adds no parameter information. It doesn't explain the meaning of 'list_address', 'address', 'subscribed', 'limit', or 'skip', leaving all 5 parameters undocumented beyond their types in the schema.

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

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

The description 'Get mailing lists members' states the action ('Get') and resource ('mailing lists members'), making the basic purpose clear. However, it's vague about scope (e.g., all members vs. filtered) and doesn't differentiate from sibling tools like 'get--v3-lists-list_address' or 'get--v3-lists-list_address-members-member_address', which appear related to lists and members.

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

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

No guidance is provided on when to use this tool versus alternatives. The description lacks context about prerequisites, such as needing a valid list address, or comparisons to other list-related tools in the sibling set, leaving the agent to infer usage from parameters alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure but fails completely. It doesn't indicate whether this is a read-only operation, what permissions might be required, whether it's idempotent, what error conditions exist, or what the response format looks like. The single phrase 'Get a member' reveals nothing about the tool's behavior beyond the basic action implied by the verb.

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 maximally concise at just two words. While this represents severe under-specification rather than ideal conciseness, it technically contains no wasted words and is front-loaded with the core action. Every word earns its place, even though that place is inadequate.

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

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

Given the tool has 2 required parameters with 0% schema coverage, no annotations, and no output schema, the description is completely inadequate. It fails to explain what the tool does beyond the most basic level, provides no parameter guidance, no behavioral context, and no relationship to sibling tools. This leaves the agent with insufficient information to use the tool effectively.

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

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

The schema has 0% description coverage for both parameters (list_address and member_address), and the description provides zero information about what these parameters mean, their expected format, or their relationship. For a tool with two required parameters and no schema documentation, this represents a critical gap in understanding how to use the tool correctly.

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

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

The description 'Get a member' is a tautology that essentially restates the tool name without adding meaningful context. It doesn't specify what type of member (email list member, team member, etc.) or what resource is being retrieved. While it includes a verb ('Get'), it lacks specificity about the domain or context of the operation.

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

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

The description provides absolutely no guidance about when to use this tool versus alternatives. It doesn't mention prerequisites, context, or relationships to sibling tools (like other list-related tools such as 'get--v3-lists-list_address-members' which likely retrieves multiple members).

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

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

With no annotations, the description carries full burden but only states the action without behavioral details. It does not disclose if this is a read-only operation, how results are returned (e.g., pagination), rate limits, authentication needs, or error handling, which are critical for a list operation with parameters.

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

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

The description is extremely concise with a single three-word phrase, front-loaded and free of unnecessary words. However, this brevity leads to under-specification rather than effective communication.

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

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

Given the tool's complexity (2 parameters, no schema descriptions, no annotations, no output schema), the description is severely incomplete. It fails to explain the resource context, parameter usage, return values, or behavioral traits, making it inadequate for effective tool 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 0%, so the description must compensate but adds no parameter information. It does not explain the purpose of 'skip' and 'limit' parameters, their expected formats (e.g., numeric strings for pagination), or default behaviors, leaving them undocumented.

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

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

The description 'Get all routes' restates the tool name 'get--v3-routes' with minimal elaboration, making it tautological. It specifies the verb 'Get' and resource 'routes' but lacks detail on what 'routes' are in this context or what 'all' entails, failing to distinguish from siblings like 'get--v3-routes-id' which likely fetches a specific route.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention siblings such as 'get--v3-routes-id' for retrieving a single route or other list tools like 'get--v3-lists', leaving the agent without context for selection.

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

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

With no annotations provided, the description carries full burden but fails to disclose any behavioral traits. It doesn't indicate whether this is a read-only operation, what permissions are required, how errors are handled, or what the response format might be. This leaves critical behavioral aspects completely unspecified.

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

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

The description is maximally concise with just three words, though this brevity comes at the cost of completeness. There's no wasted language or unnecessary elaboration, making it efficiently front-loaded despite being under-specified.

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

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

For a tool with no annotations, no output schema, and 0% parameter documentation, the description is completely inadequate. It doesn't compensate for the missing structured information, leaving the agent with insufficient context to understand what the tool does, how to use it properly, or what to expect in return.

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

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

The schema has 0% description coverage for the single parameter 'id', and the tool description provides no additional parameter information. While only one parameter exists, the description fails to explain what 'id' represents (e.g., route identifier format, where to find it) or any constraints, leaving parameter meaning entirely undocumented.

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

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

The description 'Get a route' is a tautology that merely restates the tool name without adding meaningful context. It doesn't specify what a 'route' represents in this domain or what information is retrieved, making it minimally informative beyond the obvious verb-noun pairing.

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

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

No guidance is provided on when to use this tool versus alternatives like 'get--v3-routes' (which appears to list routes) or other domain-specific tools. The description offers no context about prerequisites, typical use cases, or distinctions from sibling tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description mentions 'filtered/grouped totals' which implies a read-only aggregation operation, but it doesn't specify whether this requires authentication, what the output format looks like, whether there are rate limits, or if the data is real-time vs historical. For a tool with 7 parameters and no annotation coverage, this is a significant gap in behavioral context.

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

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

The description is extremely concise at just 5 words, which is appropriate for its length. However, it's arguably too brief given the tool's complexity (7 parameters, no annotations, many siblings). While front-loaded with the core concept, it lacks the detail needed for effective tool selection and usage.

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

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

Given the tool's complexity (7 parameters, 1 required, no annotations, no output schema, and many similar sibling tools), the description is inadequate. It doesn't explain what kind of statistics are returned, how parameters affect the output, or how this differs from other statistical tools in the server. The agent would struggle to use this tool correctly without additional documentation or trial-and-error.

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

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

The schema has 0% description coverage for all 7 parameters, and the description provides no information about what any parameter means or how they interact. While the description mentions 'filtered/grouped totals,' it doesn't explain which parameters control filtering versus grouping, what values are acceptable, or how 'event' (the only required parameter) relates to the statistics being retrieved. The description fails to compensate for the complete lack of schema documentation.

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 'Filtered/grouped totals for entire account' states the general purpose (retrieving aggregated statistics) but lacks specificity about what kind of statistics or resources are involved. It doesn't clearly distinguish this tool from its many siblings (like 'get--v3-domain-stats-total' or 'get--v3-domain-tag-stats'), which appear to handle similar statistical data but for different scopes or entities.

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. With 50+ sibling tools including many other 'get--v3-stats-*' and 'get--v3-domain-*' variants, the description provides no context about appropriate use cases, prerequisites, or exclusions. The agent must infer usage from the tool name and schema alone.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. However, it only states 'Totals for entire account,' which doesn't indicate whether this is a read-only operation, what data it returns, any rate limits, authentication requirements, or potential side effects. For a tool with 5 parameters and no output schema, this lack of behavioral context is severely inadequate.

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

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

The description is extremely concise at just three words, which is front-loaded and wastes no space. However, this brevity comes at the cost of under-specification—it's too terse to be helpful. While structurally simple, it lacks the necessary detail for effective tool use.

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

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

Given the complexity (5 parameters, 1 required, no schema descriptions, no annotations, no output schema), the description is completely inadequate. It doesn't explain what the tool does beyond a vague notion of 'totals,' leaving the agent guessing about behavior, parameters, and output. For a stats-related tool with multiple inputs, this fails to provide any meaningful context.

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

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

The schema description coverage is 0%, meaning none of the 5 parameters (start, end, resolution, duration, event) are documented in the schema. The description 'Totals for entire account' adds no meaning about these parameters—it doesn't explain what 'event' refers to (the only required parameter), how date ranges work, or what 'resolution' and 'duration' control. This fails to compensate for the schema gap.

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 'Totals for entire account' restates the tool name 'get--v3-stats-total' in a tautological way. It doesn't specify what kind of totals (e.g., statistics, metrics, counts) or for what resource (e.g., emails, events, domains). While it implies account-level scope, it lacks a clear verb and specific resource, making it vague compared to siblings like 'get--v3-domain-stats-total' which clearly targets domain statistics.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention any prerequisites, context, or sibling tools like 'get--v3-stats-filter' or 'get--v3-domain-stats-total' that might be relevant for filtering or domain-specific stats. Without such information, an agent cannot determine appropriate usage scenarios.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies a read-only operation (likely safe), but doesn't specify if it's a query, what data format it returns, any rate limits, authentication needs, or potential side effects. For a stats tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence that's front-loaded with the core purpose. There's no wasted verbiage, but it could be more informative without losing conciseness. It's appropriately sized for a simple tool, though under-specified.

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

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

Given the complexity (4 parameters, no annotations, no output schema), the description is incomplete. It doesn't cover parameter meanings, return values, or behavioral traits, making it inadequate for the agent to use the tool effectively. The lack of output schema exacerbates this, as the description doesn't hint at what 'totals' includes.

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

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

The input schema has 4 parameters with 0% description coverage, and the description adds no information about them. It doesn't explain what 'event', 'limit', 'resolution', or 'timestamp' mean, their expected formats, or how they affect the totals. With low schema coverage, the description fails to compensate, leaving parameters undocumented.

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 'Totals for account domains for a single time resolution' states the tool aggregates domain data over time, but it's vague about what 'totals' means (e.g., metrics like count, volume) and doesn't specify the resource clearly (e.g., 'account domains' vs. 'domain stats'). It distinguishes from some siblings like 'get--v3-domain-aggregates-countries' by focusing on totals, but the purpose lacks specificity.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention siblings like 'get--v3-stats-total' or 'get--v3-stats-filter', leaving the agent to infer usage based on naming alone. There's no explicit context or exclusions stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Get domains' implies a read operation but reveals nothing about permissions, rate limits, pagination, side effects, or response format. For a tool with 7 parameters and no output schema, this lack of behavioral context is inadequate.

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

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

The description is extremely concise with just two words, front-loading the core action and resource. There is no wasted verbiage, though this brevity comes at the cost of clarity and 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?

Given the tool's complexity (7 parameters, no annotations, no output schema, many siblings), the description is severely incomplete. It fails to explain the tool's purpose, usage, behavior, or parameters, making it inadequate for an agent to select and invoke it correctly.

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

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

The schema has 0% description coverage for its 7 parameters, and the description adds no semantic information about them. Parameters like 'state', 'authority', and 'include_subaccounts' are entirely unexplained, leaving their purpose and usage ambiguous.

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

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

The description 'Get domains' is a tautology that restates the tool name without adding meaningful context. It specifies the verb 'Get' and resource 'domains', but doesn't distinguish this from sibling tools like 'get--v3-domain-stats-total' or 'get--v4-domains-name', nor does it clarify what kind of domains (email, web, etc.) or what 'getting' entails (listing, retrieving details, etc.).

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

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

No guidance is provided on when to use this tool versus alternatives. With many sibling tools related to domains (e.g., 'get--v3-domain-stats-total', 'get--v4-domains-name'), the description offers no context, prerequisites, or exclusions, leaving the agent to guess based on parameter 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 must fully disclose behavioral traits. 'Get domain details' implies a read-only operation but does not specify authentication needs, rate limits, error handling, or response format. It lacks essential context for safe and effective use.

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

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

The description is extremely concise with a single phrase 'Get domain details', which is front-loaded and wastes no words. However, this brevity comes at the cost of completeness, as it under-specifies the tool's functionality.

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

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

Given the tool's complexity (1 parameter with no schema descriptions, no annotations, no output schema, and many siblings), the description is incomplete. It does not address parameter meaning, behavioral traits, or differentiation from alternatives, making it inadequate for effective tool selection and invocation.

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

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

The input schema has 1 parameter with 0% description coverage, and the description does not explain the 'name' parameter's purpose, format, or constraints. It fails to compensate for the schema's lack of documentation, leaving the parameter's semantics unclear.

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

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

The description 'Get domain details' restates the tool name 'get--v4-domains-name' with minimal elaboration, making it tautological. It specifies the verb 'Get' and resource 'domain details' but lacks specificity about what details are retrieved or how it differs from sibling tools like 'get--v4-domains' or 'get--v3-domain-tag'.

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

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

No guidance is provided on when to use this tool versus alternatives. With many sibling tools (e.g., 'get--v4-domains', 'get--v3-domain-tag'), the description offers no context, prerequisites, or distinctions, leaving the agent without usage direction.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states it's a 'Get' operation, implying read-only behavior, but doesn't mention authentication requirements, rate limits, error conditions, or what 'current' means (e.g., real-time vs cached data). This leaves significant gaps for an AI agent to understand how to invoke it 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?

The description is a single, efficient sentence that directly states the tool's purpose without any wasted words. It's appropriately sized for a simple read operation with no parameters, making it easy for an AI agent to parse quickly.

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

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

For a tool with no parameters and no output schema, the description is minimally adequate but lacks depth. It doesn't explain what 'custom sending limit' refers to (e.g., for accounts, domains, or other entities), what format the response might have, or any behavioral nuances. Given the simplicity, it's passable but could be more informative.

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

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

The tool has 0 parameters with 100% schema description coverage, so the schema fully documents the absence of inputs. The description doesn't need to add parameter information, and it correctly implies no inputs are required by not mentioning any. This meets the baseline for tools with no parameters.

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

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

The description 'Get current custom sending limit' clearly states the action (Get) and resource (current custom sending limit), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools, which appear to be various domain, stats, and account management tools, so it doesn't reach the highest score.

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

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

The description provides no guidance on when to use this tool versus alternatives. Given the sibling tools include various get operations for domains, stats, and accounts, there's no indication of context or prerequisites for selecting this specific limit-checking tool.

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

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

No annotations are provided, so the description carries full burden. It implies a read-only list operation ('List'), but doesn't disclose behavioral traits such as pagination, rate limits, authentication needs, or what 'DIPPs' stands for (likely Dedicated IP Pools). This leaves significant gaps in understanding how the tool behaves.

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

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

The description is a single, efficient sentence with no wasted words, making it front-loaded and easy to parse. It directly conveys the core purpose without unnecessary elaboration.

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

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

Given the tool has 0 parameters, no annotations, and no output schema, the description is minimally adequate but incomplete. It explains what the tool does but lacks context on behavior, output format, or differentiation from siblings, which is needed for a list operation in a complex server environment.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate, but it could have clarified terms like 'DIPPs' to enhance semantics. Baseline is 4 for zero parameters.

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

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

The description 'List DIPPs delegated to subaccounts' clearly states the action (list) and resource (DIPPs delegated to subaccounts), making the purpose understandable. However, it doesn't differentiate from sibling tools that also list resources (e.g., 'get--v3-ip_pools', 'get--v3-domains'), so it's not fully specific about what makes this listing unique.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context, or compare to sibling tools like 'get--v3-ip_pools' or other list operations, leaving the agent with no usage direction.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. 'List logs' implies a read-only operation, but it doesn't specify whether this requires authentication, has rate limits, returns paginated results, or what format the logs are in. The description mentions nothing about behavioral traits beyond the basic action, leaving critical operational context unspecified.

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

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

While 'List logs' is extremely concise, it's under-specified rather than appropriately sized. Two words cannot adequately describe an 8-parameter tool with complex filtering and pagination capabilities. This isn't effective conciseness—it's omission of necessary information that would help the agent understand and use the tool correctly.

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

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

Given the tool's complexity (8 parameters, nested objects, no output schema, no annotations), the description is severely incomplete. It doesn't explain what 'logs' means in this context, what the output looks like, how pagination works, or any behavioral constraints. For a tool with rich input schema but no other structured guidance, 'List logs' provides insufficient context for effective use.

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

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

Schema description coverage is 75%, which is relatively high, so the baseline is 3 even though the description adds no parameter information. The description 'List logs' doesn't explain any parameters beyond what the schema already documents (e.g., date ranges, events, pagination). It neither compensates for the 25% coverage gap nor enhances understanding of parameter purposes.

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

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

The description 'List logs' is a tautology that essentially restates the tool name 'post--v1-analytics-logs'. It provides the basic verb 'list' but doesn't specify what type of logs (analytics logs), what resource they belong to, or how this differs from sibling tools like 'post--v1-analytics-metrics' or 'post--v1-analytics-usage-metrics'. The purpose is minimally stated but lacks 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?

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools available (e.g., 'post--v1-analytics-metrics', 'get--v3-domain-stats-total'), there's no indication of what makes this tool unique for listing logs, what context it applies to, or any prerequisites. This leaves the agent guessing about appropriate usage scenarios.

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

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

No annotations are provided, so the description carries full burden. It only mentions 'query' without disclosing behavioral traits like whether this is a read-only operation, potential rate limits, authentication requirements, or what the output looks like (e.g., time-series data). For a complex analytics tool with 9 parameters, this is a significant gap in transparency.

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

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

The description is extremely concise with just three words, front-loading the core purpose without any waste. It's appropriately sized for a tool where the schema provides extensive documentation, though it may be too brief for full clarity.

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

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

Given the tool's complexity (9 parameters, no output schema, no annotations), the description is incomplete. It doesn't explain the tool's role in the broader analytics context, what 'account metrics' entail, or how results are structured. For a POST request with rich filtering options, more context is needed to guide effective use.

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

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

Schema description coverage is high (89%), so the baseline is 3. The description adds no parameter semantics beyond the schema, which already details each parameter thoroughly with descriptions, defaults, formats, and enums. No additional context or examples are provided in the description to enhance understanding.

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

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

The description 'Query account metrics' states the basic action (query) and resource (account metrics), but it's vague about what specific metrics are available and how this differs from sibling tools like 'post--v1-analytics-logs' or 'post--v1-analytics-usage-metrics'. It doesn't specify that this is for email analytics or mention the comprehensive metrics list available in the schema.

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

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

No guidance is provided on when to use this tool versus alternatives. With many sibling tools for analytics and stats (e.g., 'post--v1-analytics-logs', 'get--v3-domain-stats-total'), the description fails to indicate this tool's specific use case, such as for detailed, customizable metric queries over time with dimensions.

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

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

With no annotations provided, the description carries full burden but only states 'Query' without disclosing behavioral traits like whether it's read-only (implied by 'query'), rate limits, authentication needs, or what happens with invalid parameters. It lacks details on response format, pagination, or error handling.

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

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

The description is a single, efficient sentence with zero waste. It's appropriately sized and front-loaded, though it could benefit from more detail given the tool's complexity.

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

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

For a complex tool with 9 parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain what the tool returns, how to interpret results, or provide context about the metrics system, leaving significant gaps for an agent to use it correctly.

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

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

Schema description coverage is 89%, so the schema already documents most parameters well. The description adds no additional meaning beyond the schema's details about date formats, defaults, or metric/dimension options. Baseline 3 is appropriate as the schema does 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 'Query account usage metrics' states a general purpose (querying metrics) but lacks specificity about what kind of metrics (email validation, processing, etc.) and doesn't distinguish from sibling tools like 'post--v1-analytics-metrics' or 'post--v1-analytics-logs'. It's vague about the exact resource 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 guidance on when to use this tool versus alternatives like 'post--v1-analytics-metrics' or other analytics tools in the sibling list. The description provides no context about prerequisites, typical use cases, 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 are provided, so the description carries full burden for behavioral disclosure. 'List statistic v2' gives no information about whether this is a read-only operation, whether it requires authentication, what rate limits apply, what the response format looks like, or whether it's paginated. For a POST endpoint with 9 parameters and no output schema, this is critically insufficient.

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?

While technically concise (three words), this is under-specification rather than effective brevity. The description fails to communicate essential information and wastes its limited space. A proper description would be longer but more helpful - this is too short to be useful.

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

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

Given the complexity (9 parameters, nested objects, no output schema, 44% schema coverage, no annotations), the description is completely inadequate. It doesn't explain what bounce classification metrics are, what time ranges apply, how dimensions/metrics work, what the POST method implies, or what results to expect. The agent cannot use this tool effectively with such minimal 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 only 44%, meaning most parameters lack documentation in the schema. The description 'List statistic v2' adds zero information about what the 9 parameters mean, how they interact, or what values are expected. It doesn't compensate for the poor schema coverage, leaving the agent guessing about parameter usage.

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

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

The description 'List statistic v2' is a tautology that essentially restates the tool name 'post--v2-bounce-classification-metrics'. It doesn't specify what resource is being listed (bounce classification metrics), what 'v2' refers to, or how this differs from sibling tools like 'get--v1-bounce-classification-stats'. The purpose is vague and lacks 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?

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools available (e.g., 'get--v1-bounce-classification-stats', 'post--v1-analytics-metrics', various domain-specific tools), there's no indication of context, prerequisites, or exclusions. The agent receives no help in selecting this tool appropriately.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. 'Send an email' implies a write/mutation operation but reveals nothing about authentication needs, rate limits, side effects (e.g., billing implications noted in schema for 'o:archive-to'), error handling, or response format. This is critically inadequate for a complex mutation tool with no 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?

The description is extremely concise ('Send an email') with zero wasted words, making it front-loaded and easy to parse. However, this conciseness comes at the cost of completeness, but purely on brevity and structure, it's optimal.

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

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

For a complex mutation tool with 37 parameters, no annotations, and no output schema, the description is completely inadequate. It fails to address behavioral aspects, usage context, or any details beyond the minimal purpose, leaving the agent with insufficient information to understand the tool's full scope and implications.

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 73%, providing good baseline documentation for most parameters. The description adds no parameter-specific information beyond the generic 'Send an email', so it doesn't compensate for the 27% gap or enhance understanding of parameter interactions. With high schema coverage, the baseline score of 3 is appropriate as the description doesn't add value but doesn't detract either.

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 'Send an email' states the basic action but is overly simplistic for a complex tool with 37 parameters. While it identifies the verb ('Send') and resource ('email'), it doesn't distinguish this from other email-related tools in the sibling list (like template management or analytics tools) and lacks specificity about the comprehensive capabilities implied by the extensive parameter schema.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools (e.g., template management, analytics, list management), there's no indication of when this primary email-sending tool is appropriate versus other post/put tools for related functions, leaving the agent without contextual usage direction.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. 'Create a template' implies a write operation but doesn't specify permissions needed, whether it's idempotent, rate limits, or what happens on success/failure (e.g., returns a template ID). It mentions creation but lacks details like whether it overwrites existing templates or requires unique names. For a mutation tool with zero annotation coverage, this is insufficient.

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?

While concise with two words, this is under-specification rather than effective brevity. The description fails to front-load critical information (e.g., 'Create an email template for a domain') and doesn't earn its place by adding value. It's too sparse to be helpful, scoring low for structure despite being short.

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

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

Given the tool's complexity (8 parameters, mutation operation, no output schema, and no annotations), the description is incomplete. It doesn't explain the purpose, usage, or behavioral aspects needed for an agent to invoke it correctly. The high schema coverage helps with parameters, but overall context is lacking for a creation tool in a domain with multiple sibling 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 high (88%), with most parameters well-documented in the schema (e.g., 'name' supports utf-8 and downcasing, 'headers' specifies supported keys). The description adds no parameter information beyond the schema. According to rules, with high coverage (>80%), the baseline is 3 even with no param info in the description, as the schema carries the burden.

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

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

The description 'Create a template' is a tautology that merely restates the tool name 'post--v3-domain_name-templates'. It lacks specificity about what kind of template is being created (e.g., email template for a domain) and doesn't distinguish it from sibling tools like 'post--v3-domain_name-templates-template_name-versions', which also creates template versions. A more helpful description would specify the resource and context.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., requiring a domain_name), compare it to sibling tools like 'put--v3-domain_name-templates-template_name' (which updates templates) or 'get--v3-domain_name-templates' (which lists templates), or indicate any constraints. This leaves the agent with no context for tool selection.

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

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

No annotations are provided, so the description carries full burden. 'Create' implies a mutation, but it doesn't disclose behavioral traits like permissions needed, whether the operation is idempotent, rate limits, or what happens on success/failure. The description is minimal and fails to add meaningful context beyond the basic action, leaving critical behavioral aspects undocumented.

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

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

The description is extremely concise with a single sentence, 'Create a template version', which is front-loaded and wastes no words. While it may be under-specified, it earns full marks for brevity and clarity in structure without unnecessary elaboration.

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

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

Given the complexity (7 parameters, mutation operation, no annotations, no output schema), the description is incomplete. It doesn't explain the resource hierarchy (domain_name → template_name → versions), expected outcomes, error conditions, or how it fits with sibling tools. For a creation tool with significant parameters and no structured support, this is inadequate.

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 71% (5 of 7 parameters have descriptions), so the baseline is 3. The description adds no parameter semantics beyond what the schema provides—it doesn't explain relationships between parameters (e.g., how 'tag' uniqueness works) or clarify usage. This meets the minimum viable level given the schema's decent 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 'Create a template version' states a clear verb ('Create') and resource ('template version'), but it's vague about what a 'template version' entails in this context. It doesn't distinguish from sibling tools like 'post--v3-domain_name-templates' (create template) or 'put--v3-domain_name-templates-template_name' (update template), leaving ambiguity about the specific scope of this creation operation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., existing template), exclusions, or compare it to sibling tools like creating a template or updating a version. This lack of context makes it hard for an agent to choose correctly among related operations.

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral insight. 'Resend' implies a mutation/write operation, but it doesn't disclose authentication requirements, rate limits, whether the original message is preserved, what happens on failure, or the expected response format. This leaves critical behavioral aspects undocumented.

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

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

The description is extremely concise with just two words, front-loading the core action. There's no wasted language or redundancy, making it efficient for quick scanning.

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 3 parameters, no annotations, no output schema, and low schema description coverage, the description is inadequate. It doesn't explain what 'resend' entails operationally, how parameters interact, what 'storage_key' refers to, or what the tool returns. More context is needed for safe and effective use.

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

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

Schema description coverage is 33% (only 'to' parameter has a description). The tool description adds no parameter information beyond the schema. Since schema coverage is low (<50%), the description fails to compensate for undocumented parameters like 'domain_name' and 'storage_key', leaving their purpose unclear. Baseline 3 applies as schema does some work but gaps remain.

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 'Resend an email' clearly states the action (resend) and resource (email), but it's vague about scope and context. It doesn't specify whether this resends from storage or recreates a message, and doesn't distinguish from sibling tools like 'post--v3-domain_name-messages' which appears to create new messages.

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

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

No guidance is provided about when to use this tool versus alternatives. The description doesn't mention prerequisites (like needing a stored message), exclusions, or compare it to similar tools such as 'post--v3-domain_name-messages' for sending new emails.

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

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

No annotations are provided, so the description carries full burden. It states 'Create' implying a write operation, but doesn't disclose behavioral traits like authentication requirements, rate limits, side effects (e.g., if it overwrites existing webhooks), or response format. This is inadequate 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?

The description is a single, efficient sentence with zero waste. It's appropriately sized and front-loaded, making it easy to parse quickly.

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