SendPost MCP by usefulapi

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

Annotations already declare readOnly, idempotent, and non-destructive, so the safety profile is covered. The description adds genuinely new context: an 'account key' auth requirement and a 366-day maximum window, neither of which appears in the annotations or schema. Response shape is left unstated, keeping it below a 5.

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

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

A single dense sentence with the access mode and scope front-loaded, followed by the resource and the key limit. No redundant or filler text.

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

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

For a read-only stats tool with a fully documented schema, the description conveys what data comes back (delivery and engagement aggregates), the aggregation axis (group/tag across sub-accounts), and the time limit. Missing only return-format/pagination detail, which is minor given no output schema exists.

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

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

Schema description coverage is 100% and already documents from/to UTC dates and the group example ('transactional'). The description adds only the 366-day range constraint, which is a real semantic addition but modest; baseline 3 is appropriate.

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

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

States a concrete verb+resource: aggregate delivery and engagement counts for an existing group/tag across sub-accounts. The 'group/tag' scope plus 'across sub-accounts' distinguishes it reasonably from sendpost_get_account_stats and sendpost_list_subaccount_stats, though no sibling is named explicitly.

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

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

The implied use case (aggregated group-level stats over a date window) is inferable, but there is no explicit 'use this instead of X when...' routing against the many similar stats siblings. The 'up to 366 days' note hints at a boundary but doesn't state what to do beyond it.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the description adds real value with 'READ (account key)' — an auth-scope requirement not in the annotations — and the 366-day range ceiling. It doesn't mention pagination or response shape, but the added auth and range context clears the bar.

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

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

A single front-loaded sentence that leads with the READ classification and then the resource and scope. Every clause carries information; nothing is padded.

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

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

For a two-parameter read-only stats tool with full schema coverage and rich annotations, the description covers access mode, scope, and range limit. Without an output schema, 'delivery and engagement counts' gives only a rough sense of return content, which is the one modest gap.

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

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

Schema coverage is 100%, with both `from` and `to` documented as YYYY-MM-DD UTC, so the schema carries the burden. The description's 'over a date range, up to 366 days' reinforces the constraint but adds no format or syntax detail beyond what the schema states.

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

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

States a specific verb (aggregate) and resource (delivery and engagement counts across sub-accounts) with a scoping qualifier (date range). It implicitly distinguishes itself from sendpost_get_subaccount_stats by saying 'across sub-accounts', but never names the sibling directly.

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

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

The 'up to 366 days' line implies the valid window, and 'across sub-accounts' implies aggregate use versus per-subaccount tools. However, it never explicitly says when to pick this over sendpost_list_account_stats or sendpost_get_subaccount_stats, leaving selection to inference from names.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is fully covered. The description adds genuine value with the sub-account key requirement and the nature of the payload (DNS records, verification status), but says nothing about error behavior for invalid domain_id or about rate limits.

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

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

A single sentence with the operation type and auth scope front-loaded, followed immediately by the resource and returned content. Nothing is wasted and nothing is buried.

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

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

For a one-parameter read tool with full annotation coverage, the description covers what the tool inspects and the key type required. The remaining gap is the provenance/format of domain_id, which is the one thing an agent could get wrong when invoking it.

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

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

Schema description coverage is 0% for the single required parameter domain_id, so the description must compensate and it does not mention the parameter at all. It never explains that domain_id is a positive integer or where an agent should obtain it (presumably from sendpost_list_domains).

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

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

States a specific verb ('Inspect') and resource ('a sending domain's DNS records and verification status'), which clearly separates it from the enumeration sibling sendpost_list_domains. It does not explicitly name that sibling, so differentiation is implicit rather than stated.

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

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

The 'READ (sub-account key)' prefix signals the auth context and the singular 'a sending domain' implies single-domain lookup, so an agent can infer when to use it. However, there is no explicit 'use X when you need to enumerate domains' routing guidance and no stated prerequisites or failure conditions.

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

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

Annotations already declare readOnly, idempotent, non-destructive and open-world, so the description's added value is the account-key authorization requirement and the disclosure of what is actually returned (address, reverse DNS, warmup state). It does not address error behavior for an unknown or deleted ip_id.

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

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

One front-loaded sentence carrying the operation type, auth mode, resource and return fields. Nothing is padded or repeated from the title.

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

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

Listing the returned fields compensates well for the absent output schema, and the auth marker is useful. However, with no schema descriptions and no output schema, the missing explanation of ip_id leaves an agent guessing how to supply the one required input.

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

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

The single parameter ip_id has 0% schema description coverage, so the description is the only place meaning could be added — and it never mentions the parameter, its integer type, or that it must be a positive SendPost IP identifier. With one undocumented required parameter, the description fails 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?

States a specific verb ("Inspect") and resource ("an existing sending IP") plus the exact attributes returned: public address, reverse DNS, warmup state. This clearly separates it from sendpost_list_ips and sendpost_get_ip_pool, though it never names those siblings explicitly.

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

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

"READ (account key)" hints at the auth prerequisite and "existing" implies a previously created IP, so usage is implied rather than stated. There is no explicit guidance on when to pick this over sendpost_list_ips or how to obtain the required identifier.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true. The description adds useful context: account-key authentication and explicit exclusions ('Provider credentials and routing internals are excluded'), though it does not describe error behavior or response shape.

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

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

The description is a single, front-loaded sentence with no wasted words. It immediately states access mode and scope, then lists what is returned and excluded.

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

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

For a simple one-parameter read tool with no output schema, the description plus annotations cover the key safety and scope concerns. The main remaining gap is where to obtain a valid ippool_id, but this is minor for an otherwise well-scoped read operation.

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

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

Schema description coverage is 0% for the single required ippool_id parameter. The description says 'one IP pool' but provides no ID format, source, or validation guidance beyond the schema's integer constraint, so it does not compensate for the missing 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 uses a specific verb (Inspect) and resource (one IP pool), and names the fields exposed: routing strategy, overflow settings, public IP metadata. The phrase 'one IP pool' also distinguishes it from the sibling list_ip_pools tool.

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

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

Usage is implied by 'READ (account key)' and 'Inspect one IP pool', but the description does not explicitly say when to use this tool versus list_ip_pools or other sibling tools, nor does it state prerequisites or exclusions beyond authentication.

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

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

Annotations already cover read-only, idempotent and non-destructive behavior; the description adds useful context beyond that with auth scope ('account key'), content exclusions and a concrete size failure mode ('may exceed the 1 MiB read limit'). It does not spell out error handling or rate limits, so it is not a 5.

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

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

Three compact sentences with the read/auth label and field scope front-loaded. The exclusions and size caveat each earn their place; nothing repeats the title or schema mechanically.

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

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

For a single-parameter read tool with annotations and no output schema, the description covers returned fields, excluded content and the read-limit caveat. It does not describe response structure or not-found behavior, but the essentials for selecting and invoking the tool are present.

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

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

There is one required message_id parameter with 0% schema description coverage. The description implies it is the submitted message's ID, but does not explicitly document the input or explain its format/constraints, so it only partially compensates 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?

States a specific read operation and enumerates the returned fields: ID, sender, recipient, subject, groups and routing metadata. The 'submitted message' scope and exclusions distinguish it clearly from the account/domain/IP list tools in the sibling set.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 '(account key)' marker signals the auth scope, and exclusions for bodies, attachments, custom headers and recipient custom fields imply when this metadata-only tool is appropriate. It does not name an alternative tool, but no sibling appears to compete for message-level metadata retrieval.

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

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

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint), so the description's job is picking up what they can't express. It does that by disclosing the content contract — safe metadata, labels, blocked state — and explicitly flagging that credentials are excluded, which tells the agent this call is safe to surface without leaking secrets.

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

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

One tight sentence with the access mode front-loaded in parentheses and the exclusion note last. Every clause carries information — resource, returned fields, and the credential caveat.

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

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

For a single-parameter read with no output schema, the description supplies the closest thing to a return contract by enumerating metadata, labels and blocked state, plus the credential exclusion. The only missing piece is the provenance of subaccount_id, which is the one thing an agent must resolve before calling.

Complex tools with many parameters or behaviors need more documentation. 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 single parameter subaccount_id carries no documentation anywhere in the definition. The description never explains where this ID comes from (presumably sendpost_list_subaccounts) or its expected form beyond the schema's integer bounds, leaving the agent to infer the linkage.

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

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

States a specific verb (get) and resource (a single sub-account), and the singular framing implicitly distinguishes it from the sendpost_list_subaccounts sibling that returns many. It does not explicitly name the difference from sendpost_get_subaccount_stats, so it stops short of full differentiation.

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

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

The 'READ (account key)' prefix implies this is a non-mutating retrieval and hints at an auth requirement, and 'safe metadata, labels and blocked state' suggests the kind of lookup it serves. But it never says when to prefer this over sendpost_list_subaccounts or sendpost_get_subaccount_stats, nor does it state prerequisites explicitly.

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

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

Annotations already declare readOnly, idempotent, non-destructive, so safety is covered. The description adds genuinely new context: it requires an account key and caps the range at 366 days, which an agent needs to know before calling. It stops short of describing response shape or whether empty ranges error.

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

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

A single front-loaded sentence with the access mode first, then the operation, scope, and constraint. Nothing extraneous and nothing buried.

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

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

There is no output schema, so the description should say more about what 'delivery and engagement counts' include (e.g. sent, opened, clicked) and whether results are zero-filled. The auth note and 366-day limit help, but the return contract remains vague.

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

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

Schema coverage is 67%; the two date parameters are documented in the schema, but subaccount_id has no description. The description only hints that a single sub-account id is needed and that the range must be within 366 days, which is modest added meaning rather than full compensation for the undocumented id parameter.

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

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

States a specific operation (aggregate delivery and engagement counts) on a specific resource (one sub-account) over a date range. The word 'aggregate' implicitly distinguishes it from the sibling sendpost_list_subaccount_stats, though that contrast is never made explicit.

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

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

Usage is implied by 'one sub-account over a date range' and 'aggregate', which suggests totals rather than per-row listings, but the description never says when to prefer it over sendpost_get_account_stats or sendpost_list_subaccount_stats. No exclusions or prerequisites beyond the date-range cap.

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

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

Annotations already declare readOnly, idempotent, non-destructive and openWorld. The description contributes beyond that by flagging 'account key' auth and the 366-day per-call window, but says nothing about pagination, result ordering, or what happens when the range exceeds 366 days.

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

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

Two sentences, zero filler: the read/auth marker and resource come first, the metric list second, and the range limit last. Every clause carries 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?

With no output schema, the description usefully enumerates the returned metric categories and the time granularity (daily), which is the key return-shape information. Minor gaps remain around aggregation semantics (per sub-account rows vs totals) but an agent can call it confidently.

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

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

Schema coverage is 100% (from/to with date format and UTC note), so the baseline is 3. The description adds a genuine constraint not present in the schema — the maximum 366-day span per call — which meaningfully informs how to build the range.

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

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

Names a specific verb+resource (daily delivery/bounce/open/click/unsubscribe/spam counts) and scopes it to 'across sub-accounts', which separates it from sendpost_get_account_stats (single account). It does not explicitly contrast with the similarly named sendpost_list_subaccount_stats, so sibling differentiation is partial.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 'across sub-accounts' scope implies when this tool is the right choice versus the per-account/per-subaccount stat tools, but no alternative is named and no when-not guidance is given. 'Use up to 366 days per call' is a constraint, not usage routing.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds useful context beyond annotations by noting the sub-account key requirement and clarifying that the tool does not create or verify domains, though it does not discuss pagination or response shape.

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

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

The description is two compact sentences with no waste. The access mode and purpose are front-loaded, and the exclusion follows immediately.

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

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

For a simple list/audit operation with rich annotations and no output schema, the description is largely complete: it covers the domain-audit scope, DNS/verification visibility, auth context, and mutation exclusions. Minor gaps remain around the search parameter and exact returned fields.

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

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

Schema coverage is 67%, with limit and offset documented in the schema but search left undocumented. The description adds no parameter-level meaning, so it neither helps interpret search nor supplements the pagination 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 states a specific audit/list purpose for sending domains and adds scope around DNS record configuration and verification failures. It clearly distinguishes from create/verify operations, though it does not explicitly contrast with the sibling get_domain tool for single-domain retrieval.

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

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

It gives clear context by labeling the operation as READ and specifying sub-account key authentication, and it explicitly excludes create/verify use cases. However, it does not name an alternative tool or explain when to use get_domain instead of this list 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds the account-key auth requirement and hints that IP metadata is 'safe public' data, but does not disclose pagination behavior, rate limits, or response shape.

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

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

A single compact sentence front-loads read/auth context and then lists the useful returned fields. There is no filler or repetition.

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

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

For a simple list endpoint with annotations covering safety and a schema covering most pagination, it supplies useful returned-field context despite having no output schema. It still omits search/filter semantics and pagination expectations.

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

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

The schema documents limit and offset, but the search parameter has no schema description and the tool description provides no parameter guidance at all. With 67% coverage, the description fails to compensate for the undocumented search filter.

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

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

States a specific verb, resource, and returned fields: 'List IP pool names, routing strategy, overflow settings and safe public IP metadata.' The plural listing scope distinguishes it from singular sendpost_get_ip_pool, though it does not name that sibling explicitly.

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

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

'READ (account key)' signals the auth and read-only context, but there is no explicit guidance on when to choose this over sendpost_get_ip_pool or sendpost_list_ips, and no exclusions are stated. Usage is only implied by the listing 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?

Annotations already cover readOnly, idempotent, and non-destructive, so the bar is lower; the description still adds real value by disclosing the account-key auth requirement and explicitly denying allocation/state-change side effects. It stops short of describing result shape or pagination 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?

Two terse sentences with the access mode and scope front-loaded and the negative constraint last; no filler or repetition of the title.

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

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

A read-only list tool with full annotation coverage and no output schema needs little more than scope, auth, and safety, all of which are present. The only real gap is the undocumented 'search' parameter and any hint about result ordering or pagination defaults.

Complex tools with many parameters or behaviors need more documentation. 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 67%: limit and offset are documented in the schema, while the 'search' parameter has no description anywhere. The prose adds nothing about filtering syntax or what search matches against, so it neither helps nor hurts beyond the schema baseline.

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

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

States a specific verb and resource ('List sending IPs') plus the payload contents ('warmup and state metadata'), which is more than the title alone. It does not distinguish itself from close siblings like sendpost_get_ip or sendpost_list_ip_pools, leaving the list-vs-single-vs-pool boundary to inference.

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

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

'READ (account key)' signals the auth context and the closing sentence rules out one misuse (allocating or changing IPs), implying usage. But there is no explicit statement of when to pick this over sendpost_get_ip, sendpost_get_ip_pool, or sendpost_list_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?

Annotations already declare readOnly, idempotent, non-destructive and open-world, so the safety profile is covered. The description adds genuinely new behavioral information not present in annotations: that API keys and SMTP credentials are never returned, telling the agent what field-level data is redacted. It lacks any note on result size or pagination behavior, keeping it below a 5.

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

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

A single compact sentence with no filler, front-loading the read mode and the returned resource. The parenthetical auth note is slightly cryptic but costs little space.

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

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

For a read-only, zero-required-parameter list tool with rich annotations and no output schema, this covers purpose, auth mode, and the key data-safety caveat. The remaining gap is search semantics and paging behavior, which an agent could infer from field names.

Complex tools with many parameters or behaviors need more documentation. 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 67% schema coverage, limit and offset are documented in-schema and the description adds nothing about them. The `search` parameter has no description in either place, so the description does not compensate for the one real gap; baseline 3 is appropriate.

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

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

States a specific verb and resource ("List sub-accounts") plus the scope of returned data ("safe account metadata"), which is clear enough to distinguish it from the singular sendpost_get_subaccount sibling. It stops short of naming that sibling or the stats-listing siblings explicitly.

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

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

The "READ (account key)" prefix hints at the auth mode and read nature, but there is no statement of when to use this tool versus sendpost_get_subaccount or sendpost_list_subaccount_stats. No pagination or filtering guidance beyond what the schema already implies.

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

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

Annotations already cover readOnly, idempotent, non-destructive and openWorld, so the safety profile is settled. The description adds real context beyond that: it flags an account-key auth requirement and a hard 366-day range limit that would otherwise cause a failed call. Return shape and pagination remain undisclosed.

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

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

A single tight sentence, front-loaded with the READ/account-key qualifier and then the core action. Nothing superfluous, though the parenthetical '(account key)' reads awkwardly and could be integrated more cleanly.

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

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

No output schema exists, so the description should at least indicate what comes back (stat record shape, ordering, pagination). It names 'delivery and engagement statistics' but leaves the agent guessing about the response structure for a list endpoint.

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

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

Schema coverage is 67% – from/to carry format and UTC guidance in the schema, but subaccount_id has no description anywhere. The description's 366-day note usefully constrains the date pair but says nothing about what subaccount_id expects or where to obtain it (e.g. via sendpost_list_subaccounts).

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

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

The description states a specific verb (Read) and resource (a sub-account's delivery and engagement statistic records) plus a scoping constraint (date range, up to 366 days). An agent can distinguish it from generic sibling reads. It does not, however, explicitly contrast with sendpost_get_subaccount_stats, so sibling differentiation is only partial.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 date-range framing and 366-day cap imply when this tool applies, but there is no explicit 'use this instead of X' guidance despite a near-identical sibling (sendpost_get_subaccount_stats) existing. The user must infer the list-vs-get distinction from the verb alone.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds a genuinely new constraint the annotations do not carry: the requirement for a sub-account API key, plus the explicit negative scope (no add/remove). It does not describe result shape or pagination limits, but the schema handles those.

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

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

Two short sentences, with the access class and read-only nature front-loaded before the scope clause. No filler or restatement of the title.

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

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

For a 6-parameter read tool with no output schema and solid annotation coverage, this covers access, scope, and non-mutation adequately. The remaining gap is the meaning of the `type` filter and what `search` matches, which an agent would need to filter confidently.

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

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

Schema coverage is 67%, with from/to/limit/offset documented in-schema; the description only adds that the range governs the query and that pagination applies. The `type` enum values and the target of `search` (which has no schema description at all) are left unexplained in both places, so the description does not compensate for the 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?

States a specific verb ('Inspect') and resource ('suppressions and documented reasons') plus scope (date range, pagination), which is unambiguous. None of the siblings read suppressions, so the tool is trivially distinguishable from every listed alternative.

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

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

'READ (sub-account key)' signals the credential and operation class needed, and 'Does not add or remove suppressions' tells the agent this is not the route for mutation. No sibling alternative is named, but no sibling overlaps the resource, so there is nothing to route away from.

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