emailwarmup

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

Goes beyond the annotations by disclosing the 1,000-contact ceiling and, more importantly, that duplicates and unsubscribed addresses are silently skipped — partial-success semantics the agent needs to reason about outcomes. What's missing is whether skipped items are reported back and whether re-running the same batch is safe (annotations say non-idempotent).

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 short sentences, zero filler, with the cap and the operation stated first and the skip behavior last. Every clause carries information the agent cannot get from the structured fields.

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?

Adequate for a two-parameter mutation with no output schema: input expectations, volume limit, and dedupe behavior are all covered. The remaining gap is the result shape — how many were added versus skipped — which matters for non-idempotent adds.

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?

campaign_id is covered by the schema, so the description's real contribution is on contacts: it says email is the only required field and that optional keys like first_name and company map to campaign placeholders, which the schema does not convey at all (the item schema declares only email).

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

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

States a specific verb and resource ('Add ... contacts to a campaign') plus a hard cap of 1,000, which an agent can act on immediately. It is clearly distinguishable from list_campaign_contacts, though the description never names 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?

Usage is implied by the operation itself and the batching limit, but there is no explicit when-to-use/when-not guidance, no pointer to list_campaign_contacts for verification, and no note about needing the campaign to exist or be in a particular state.

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

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

Annotations already declare the mutation profile (readOnly=false, destructive=false, idempotent=false, openWorld=false), so the description doesn't need to restate safety. It adds real value with the valid record-type set and the 'name = subdomain, empty for apex' convention, but omits propagation delay, whether duplicates get created on repeat calls, and validation/failure 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?

Three terse sentences, front-loaded with the action and the key naming convention, with the type list at the end. No filler, though the type list could have been tied to the `type` parameter rather than left as a loose tail.

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

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

This is a six-parameter mutation with only 17% schema coverage and no output schema, yet the description says nothing about what the call returns, whether the record takes effect immediately, or how `ttl`/`prio` should be set. For a write tool with this much undocumented surface, more is required.

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

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

Schema coverage is only 17%, so the description must compensate; it does explain `name` (subdomain, '' for the apex) and enumerates valid `type` values, which the schema does not. However, `content`, `ttl`, and especially `prio` (which only makes sense for MX/SRV but is never tied to those types) remain undocumented in both places.

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 ('Add a DNS record') and confines it to domains purchased through the service, which distinguishes it from generic DNS tooling. It never names the obvious siblings (list_dns_records, delete_dns_record), so the boundary is inferable but not 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?

'a domain you bought here' implies a prerequisite (the domain must already be in this account), and the record-type list frames what can be added. There is no explicit when-to-use/when-not, no pointer to list_dns_records to check existing records, and no guidance on duplicate/non-idempotent behavior.

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 this is a non-read-only, non-idempotent, non-destructive write. The description adds genuinely new behavior: each mailbox costs $3/month and the call returns a Stripe checkout link rather than provisioning immediately, which tells the agent payment is a required follow-up step. It doesn't say what happens to the mailbox before payment completes.

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 compact sentences, front-loaded with the action and prerequisite, followed by price and return value. Nothing redundant.

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

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

For a 2-parameter mutation with no output schema, the description covers cost and the checkout-link return. It omits what happens on payment abandonment, whether mailboxes are created inactive, and any limits on batch size, which an agent would want 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 coverage is only 50%, and the description clarifies one key constraint — the 'domain' value must be one purchased through this service. It adds nothing about the 'mailboxes' array (local part vs display name, batch limits, duplicates), leaving that entirely to the schema.

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

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

States a concrete verb+resource (add mailboxes to a domain) and scopes it to domains bought through this service, which separates it from add_contacts or connect_imap_mailbox. No sibling is named explicitly, so differentiation is inferred 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 phrase 'a domain you bought here' implies the prerequisite that the domain must already exist in the account, and the pricing note signals a billable action. But it never says when to prefer this over connect_zoho_mailbox / connect_imap_mailbox or what to do if the domain isn't owned.

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

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

Annotations already declare non-read-only, non-destructive, non-idempotent, closed-world, so safety is covered. The description adds genuinely new behavioral context: the call returns a checkout link, the domain is not provisioned until payment, and no operation is idempotent (buying twice means two purchases). It does not mention pricing, failure/partial-purchase behavior, or whether domains must be available first.

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 short sentences, front-loaded with the action, then the return value and asynchronous completion, then the required consent flag. Nothing is filler.

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

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

With no output schema, the description usefully explains that the return value is a Stripe checkout link and that setup is deferred until payment, which is the key thing an agent needs to report back. Missing are cost/eligibility details and what happens on failure, but the critical call-time context is 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?

Schema description coverage is 0% at the top level, so the description must compensate; it does so partially by stating the "up to 3 mailboxes each" limit on the nested mailboxes array and by flagging that accept_sending_rules must be true. It never explains what accepting sending rules entails or elaborates on the domains structure beyond the schema itself.

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

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

States a specific verb and resource ("Buy domains") plus the scope (up to 3 mailboxes each), which cleanly separates it from search_domains and list_bought_domains. It stops short of naming those siblings explicitly, but the action is unambiguous.

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

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

The asynchronous payment flow ("Returns a Stripe checkout link for the person to pay; setup starts once paid") implies when this tool applies, but there is no explicit when-to-use vs when-to-use-search_domains guidance and no stated prerequisites beyond the accept_sending_rules flag.

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 safety (readOnly, idempotent, non-destructive), so the description's added value is the disclosed search strategy: caller-supplied selector first, then selectors observed in real mail, then 45 common ones. That tells the agent the call is a multi-step external probe that may take longer than a single lookup, which is genuinely useful context beyond the annotations.

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

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

A single sentence, front-loaded with the outcome, that packs the fallback order without filler. Nothing to cut.

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 carries return-value burden, yet it never says what a hit or a miss looks like (key present? null? error for unregistered domain?). For a two-parameter read tool with annotations, the call mechanics are covered but the result shape is left to discovery.

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 50% — domain is documented, selector is not. The description partly compensates by framing the selector as the first thing 'tries', implying it is an optional hint rather than a strict filter, but it doesn't give format, default, or what happens if the selector misses. Marginal but real added 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?

Specific verb (find) plus specific resource (DKIM key) for a domain, so an agent knows exactly what the tool retrieves. It does not explicitly differentiate itself from siblings like check_spf or check_dmarc, but the DKIM-specific wording is unmistakable.

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

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

The description implies usage (domain DKIM verification) and explains the lookup strategy, but never states when to prefer this over check_dmarc/check_spf/domain_health, nor any prerequisites such as the domain being registered or DNS-managed here. Guidance is inferable rather than explicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds that it returns both the DMARC record and policy, but does not describe output format, rate limits, or authentication needs. With annotations carrying the behavioral burden, this is adequate but not rich.

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

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

The description is a single, front-loaded sentence with no wasted words. It immediately states the action and resource.

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

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

For a simple read-only lookup with complete schema coverage and annotations covering safety, the description is nearly complete. It could mention what the returned policy includes, but no output schema exists and the core purpose is clear.

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

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

Schema description coverage is 100%, and the single 'domain' parameter is documented in the schema with an example. The description does not add syntax or format details beyond what the schema already provides, so baseline 3 is appropriate.

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

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

The description states a specific verb and resource: 'Look up a domain's DMARC record and policy.' It is clear what the tool does, but it does not distinguish itself from sibling tools like check_dkim, check_spf, or domain_health.

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

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

There is no guidance on when to use this tool versus alternatives such as check_dkim, check_spf, or domain_health. The description implies a lookup but gives no context, prerequisites, or exclusions.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is clear. The description adds no further behavioral context such as error handling or what happens when no SPF record exists, but it does not contradict the annotations.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately sized for a simple lookup tool.

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

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

For a simple read-only lookup with complete parameter documentation and rich annotations, the description is nearly sufficient. It could mention return behavior or missing-record handling, but no output schema exists and the core operation is clear.

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

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

Schema description coverage is 100%, and the single domain parameter is documented in the schema with an example. The description does not add meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb and resource: looking up a domain's SPF record. It is clearly distinct from sibling checks like check_dkim and check_dmarc, though it does not explicitly name those alternatives.

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 the tool name and the phrase 'Look up a domain's SPF record,' but there is no explicit guidance on when to use this versus domain_health, list_dns_records, or other DNS-related siblings.

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 this is a non-readonly, open-world, non-idempotent, non-destructive operation. The description adds meaningful behavior beyond annotations: the login is tested before saving, and warm-up starts the same day, which tells the agent about validation and a side effect.

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

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

The description is short, front-loaded, and every sentence adds relevant information: purpose, validation behavior, password guidance, preset-or-host choice, and warm-up timing. No filler.

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

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

For an 11-parameter mutation tool with no output schema, the description covers purpose, validation, and a key side effect, but leaves gaps around SMTP configuration details and what a successful connection returns. It is adequate but not fully complete.

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

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

Schema coverage is 64%, so several parameters are documented in the schema. The description adds useful meaning for preset versus host configuration and clarifies the app-password case, but it does not explain the SMTP-specific parameters or ports beyond what the schema provides.

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

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

The description states a specific verb and resource: connect a mailbox via IMAP + SMTP. It is clear what the tool does, but it does not explicitly differentiate itself from the sibling connect_zoho_mailbox beyond saying 'any mailbox'.

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 useful setup guidance such as using an app password for two-factor sign-in and choosing a preset or hosts, but it does not explicitly say when to use this tool versus connect_zoho_mailbox or test_mailbox. The usage context is implied rather than fully 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?

Annotations already declare readOnlyHint=false, openWorldHint=true and idempotentHint=false, so the mutation and external-dependency profile is known. The description adds genuine value by disclosing the required auth artifacts and their source, but says nothing about re-connection behavior, failure modes, or what the tool returns.

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

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

Two short sentences, front-loaded with the action and followed by prerequisites. 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?

With no output schema and 6 parameters at 50% coverage, the description covers the credential-acquisition flow but leaves the return value, the 'dc'/'name' parameters, and post-connection behavior undocumented. Adequate for the happy path but incomplete for an agent that needs to handle edge cases.

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

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

Schema coverage is 50%, and the description compensates partially by explaining where client_id/client_secret/code come from. The 'dc' (data centre) and 'name' parameters are left entirely to the schema, and neither the description nor schema documents 'name' at all.

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 ('Connect a Zoho Mail mailbox') and scopes it to the Zoho API, which implicitly distinguishes it from the generic connect_imap_mailbox sibling. It does not explicitly name that alternative, so differentiation is inferential 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?

Prerequisites are given (Self Client id, secret, generated code from api-console.zoho.com), which tells the agent what must be gathered first. However, there is no explicit when-to-use-this-vs-connect_imap_mailbox statement or note about what happens if the mailbox is already connected.

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?

Goes well beyond the annotations by disclosing the human-in-the-loop payment requirement, the already-subscribed short-circuit, and that prices are returned in the result. It does not address that idempotentHint=false means repeated calls may spawn multiple checkout sessions, which is the one behavioral risk an agent could stumble into.

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?

Four short sentences, front-loaded with the purpose and the critical actor constraint before the follow-up step. Every clause carries information an agent needs to call this correctly; nothing is padding.

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-boolean tool with no output schema, the description covers the missing pieces itself: the key return fields (already, prices), the required next call, and the human action. Nothing an agent needs in order to invoke or follow up is absent.

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

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

Schema coverage is 100% and the single parameter is self-describing, so the baseline is already met; the description adds genuine economic meaning with 'yearly = 10 months' price for 12', telling the agent the actual trade-off behind the boolean.

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 and resource ('Get a Stripe Checkout url') plus the exact scope ('extra mailboxes beyond the free limit'), which separates it from the credit-purchase sibling create_credits_checkout without naming it. An agent immediately knows what asset is being purchased and that the result is a URL, not a completed transaction.

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

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

Explicitly states the workflow and the actor constraint ('The USER opens it and pays; you cannot'), names the required follow-up ('Then poll get_billing_status'), and gives a do-not-proceed condition ('Returns already:true when the account is subscribed'). Both when-to-use and the alternative path are covered.

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 (not read-only, not destructive, closed-world, not idempotent), so the description is free to add real context: the operation only creates a draft and sends nothing, and a warming mailbox will surface a warning. It does not address that repeated calls are not idempotent and will create duplicate campaigns, which is the one behavioral trait left uncovered.

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 short sentences, zero filler, and the most decision-relevant fact (nothing is sent) is front-loaded in the first sentence.

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 non-destructive creation tool with annotations present and no output schema, the description covers the draft semantics, templating, and mailbox behavior well. The remaining gap is that it never says what comes back (presumably a campaign id needed for start_campaign/update_campaign), and no output schema exists to fill that in.

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 50%, so the description must compensate, and it does for the two most semantically loaded parameters: emails support {first_name}/{company}/any contact field merge tokens, and mailboxes accept any connected mailbox. It says nothing about name or daily_limit, the latter of which the schema at least documents as per-mailbox-per-day.

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 plus the crucial scope qualifier: a draft campaign where nothing is sent. That qualifier implicitly separates it from start_campaign and update_campaign without the agent needing to inspect either 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?

Gives useful preconditions (a connected mailbox is needed; a warming mailbox produces a warning), which is implied usage guidance. However, it never says when to prefer this over siblings like update_campaign or start_campaign, or that a draft must later be started, so the routing decision is left to inference.

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

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

Annotations already declare this is a non-read-only, non-destructive, non-idempotent operation, so the safety profile is covered. The description adds genuinely useful context the annotations cannot: the human must complete payment and the agent must poll get_billing_status afterward. It does not mention URL expiry or what happens on repeat calls, which matters given idempotentHint=false.

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 compact sentences, front-loaded with the deliverable (checkout URL) and followed by the required next action. No filler.

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

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

No output schema exists, and the description does state the return value (a Stripe Checkout URL) plus the follow-up step. Minor gaps remain around URL lifetime and behavior on repeated invocation, but the essential call contract is 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?

Only one parameter, and the schema's enum already enumerates 5/10/25/100, so the description's list of amounts largely repeats structured data. It does add the 'one-off' framing and 'credits never expire', which gives the amounts meaning beyond the enum.

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

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

States a specific verb and resource: 'Get a Stripe Checkout url to top up prepaid credits', with the scope of what the credits fund (Outbound sending and AI drafts). It does not differentiate itself from the sibling create_billing_checkout, which an agent could easily confuse with this 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?

Gives a clear workflow: the USER opens the URL and pays, the agent cannot, then poll get_billing_status. That is actionable sequencing. It stops short of saying when to prefer this over create_billing_checkout or get_credits.

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 this is a non-readonly, non-idempotent, non-destructive mutation, so the safety profile is covered. The description adds a genuinely useful account-level quota (max 100), but says nothing about duplicate-name behavior, required permissions/plan, or what is created (and returned) beyond the record itself.

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

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

One sentence with the action front-loaded and no filler. The parenthetical quota is compact, though the "e.g." example sits slightly awkwardly against the hard limit in the same clause.

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 create tool with full schema coverage and clear annotations, the description covers what is created and the account cap. Remaining gaps (duplicate-name handling, plan prerequisites) are minor for this complexity level and no output schema exists to document returns.

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

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

Schema coverage is 100% and the single `name` parameter is fully documented with a 60-character limit, so the schema carries the burden. The description only adds the "company name" example; its "max 100 per account" refers to workspace count, not name length, so it adds no parameter-level detail 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?

States a specific verb and resource ("Create a client workspace") and clarifies what a workspace represents via the company-name example. It is clearly distinct from rename_workspace and delete_workspace, though it doesn't explicitly name those siblings.

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

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

No indication of when to create a workspace versus using an existing one (e.g., list_workspaces first) or how it relates to siblings like add_contacts or move_mailbox_to_workspace. The only constraint offered is the 100-per-account quota, which is a limit rather than usage guidance.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the description's added value is the concrete domain-specific consequence: deleting MX/SPF/DKIM/DMARC stops mailboxes working. It does not say whether deletion is permanent/reversible or whether confirmation is required, which is the main remaining gap for a destructive op.

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

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

Two sentences, zero waste: the operation and id source come first, the risk warning second. Every clause carries actionable information.

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

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

For a destructive, no-output-schema tool this covers operation, identifier source, and consequence. Missing only reversibility/confirm behavior, but annotations already carry the destructive profile, so an agent has enough to call it correctly.

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

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

At 50% schema coverage, 'domain' is documented in the schema while 'record_id' has only a type. The description compensates for exactly that gap by explaining the provenance of the id (obtained from list_dns_records), which is the non-obvious part an agent must know. It adds no format details beyond that.

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

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

Specific verb + resource + identifier basis: 'Delete a DNS record by id'. It also names the sibling (list_dns_records) that produces the id, distinguishing it cleanly from add_dns_record and list_dns_records.

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?

Tells the agent where to get the required record_id ('from list_dns_records') and flags the high-risk record types where deletion breaks mail. It stops short of stating prerequisites (e.g. domain must be in the account) or an alternative to deleting, but the use context is clear.

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

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

Annotations already flag destructiveHint=true and idempotentHint=false, yet the description adds genuinely non-obvious behavior: mailboxes survive the deletion, return to 'My mailboxes', and keep warming, while the client report link breaks. It stops short of saying whether the workspace itself is recoverable or what the response returns, which is the one remaining gap for a destructive tool.

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

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

Three short sentences, front-loaded with the action and then the two consequences that matter. Nothing repeats the structured fields and no sentence is filler.

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

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

For a single-parameter destructive tool with annotations covering the safety profile, the description supplies the key side effects an agent needs. Only irreversibility/recoverability and the return shape are unstated, both minor here.

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

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

Schema coverage is 100% and the single parameter is documented with format ('ws_…') and provenance ('from list_workspaces'), so the schema does the heavy lifting. The description adds no parameter-level meaning, which is the correct baseline of 3 for a fully documented one-param schema.

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

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

States a specific verb and resource ('Delete a client workspace') and immediately distinguishes its semantics from the generic delete expectation. An agent can tell it apart from rename_workspace, create_workspace, and move_mailbox_to_workspace without opening any 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 explains consequences but never says when to prefer this over alternatives (e.g. deleting vs. renaming vs. moving mailboxes out first), nor does it state any prerequisite such as confirmation or ownership. Usage is implied by the destructive framing rather than articulated.

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: read-only, idempotent, non-destructive, and closed-world. The description adds useful output-scope context by naming the DNS and email-auth records returned, but it does not explain whether results are live DNS checks or stored configuration.

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 economical sentence that lists the relevant record types and the domain scope without filler. It could be slightly more front-loaded with an explicit verb, but every phrase earns its place.

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

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

With no output schema, the description needs to describe return values. It names the record types and the per-domain scope, which is adequate for selection, but it omits result structure and whether this is an aggregated health summary versus raw records.

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

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

The tool takes zero parameters, so there is no parameter semantics to document beyond the schema. Baseline score of 4 applies.

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

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

The description clearly identifies the returned data (SPF, DKIM selector, DMARC policy, MX) and the scope (every connected domain). It is distinguishable from per-domain siblings like check_spf and check_dmarc, though it could state the verb more 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?

There is no explicit guidance on when to use this aggregate health view versus the individual check_spf, check_dkim, or check_dmarc tools. Usage is only implied by the phrase 'for every domain you have connected'.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds genuinely new behaviour-adjacent information: the exact contents of the response, including the non-obvious allowance rule (10 or 20 depending on creation date, plus referral bonus). It stops short of mentioning auth requirements or any failure modes.

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

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

A single front-loaded sentence with no filler; every clause names a distinct returned field. Nothing could be removed without losing a return-value 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?

With no output schema, the description carries the burden of describing return contents and does so specifically, including the conditional allowance logic. A brief note on auth/connection requirements would close the remaining gap for a no-parameter read on the user's own account.

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?

Zero parameters and an empty schema, so there is nothing to disambiguate — the baseline applies. The description correctly signals that no input is needed by describing only outputs.

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 enumerates exactly what the tool returns (email, credit balance, free mailbox allowance, paid extras, referral link), making the resource unmistakable. It lacks an explicit verb ('get/retrieve') and does not distinguish itself from near-neighbours like get_credits or get_billing_status, which overlap on the balance/allowance fields.

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

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

There is no statement of when to call this versus get_credits or get_billing_status, no prerequisites, and no exclusions. The agent must infer from the field list alone that this is the whole-account overview rather than a targeted balance lookup.

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

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

Annotations already declare non-read-only, non-destructive, non-idempotent behavior, so the description need not repeat safety hints. The description adds the status categories and timing ('straight away'), but given readOnlyHint=false it does not clearly explain what, if anything, is changed by 'confirms a paid checkout' or any permission requirements.

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

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

Two sentences; the first front-loads the returned status categories and the second adds a timing/confirmation note. No redundant restatement, so it is 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?

No output schema exists, so the description carries the return-value burden; it does enumerate the key status fields. It remains thin on error cases or write side effects, but for a zero-param status tool it is largely complete.

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

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

There are zero parameters, so the baseline is 4. The description has no parameter semantics to add, and none are needed.

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

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

The description states a specific resource (billing/payment status) and enumerates the returned fields: credit balance, extra-mailbox subscription state, mailbox quota vs free limit, and pending checkouts. It is distinguishable from checkout-creation siblings through the phrase 'after you gave the user a checkout link,' though it does not explicitly name an alternative 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?

It gives a clear trigger: use after giving the user a checkout link, and to confirm a paid checkout promptly. It does not explicitly state when not to use it or name the create_billing_checkout/get_credits alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, covering the safety profile. The description adds the useful detail of what is returned (emails, mailboxes, stats, time left), which matters because no output schema exists, but it does not mention permissions, error behavior, or rate limits.

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

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

A single short sentence with no wasted words, and the core resource identification is front-loaded. It is efficient, though the terseness contributes to the missing usage guidance.

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 rich annotations, the description covers what is returned, which compensates for the absent output schema. It remains incomplete on when to choose this tool over list_campaigns and on any failure modes, so it is adequate but not complete.

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

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

Schema description coverage is 100%, and the parameter schema already explains that campaign_id comes from list_campaigns. The description adds no further parameter semantics, so the baseline 3 is appropriate.

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

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

The phrase 'One campaign' signals a single-resource retrieval and lists the sub-resources it returns (emails, mailboxes, stats, time left), which distinguishes it from list_campaigns. However, there is no explicit verb such as 'get' or 'retrieve', so the purpose is inferred rather than stated 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?

There is no guidance on when to use this tool versus list_campaigns or update_campaign. The singular 'One campaign' weakly implies detail-view usage, but no conditions, prerequisites, or alternatives are named.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so safety is covered. The description contributes the actual payload contents (balance, prices, recent charges) but says nothing about scope (account-wide vs workspace), how far back 'recent' goes, or ordering — meaningful gaps since there is no output schema.

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

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

A single compact sentence with the core noun front-loaded and no filler. It is fragmentary rather than prose, which is acceptable for a one-liner but leaves no room for guidance.

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 and no parameters, the description is the sole window into the response, and it only partially covers it: it lists balance, prices and charges but omits format, time window, and whether charges are paginated or limited. Adequate for a simple read, not fully complete.

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

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

The tool takes zero parameters, so there is no parameter meaning to convey; baseline applies. The description correctly implies no inputs are required by describing a pure lookup.

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

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

Names the specific resource (prepaid credit balance) and the data returned (prices and recent charges, with examples of charge types). It is clearly a read of credit/billing data, though it stops short of naming the sibling get_billing_status or create_credits_checkout it must be distinguished from.

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

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

No when-to-use guidance at all. Nothing tells the agent how this differs from get_billing_status or when to call it rather than create_credits_checkout; the agent must infer usage from the noun phrase alone.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so safety and side-effect behavior are fully covered structurally. The description adds only that the payload concerns warm-up status and health, with no mention of what happens when the mailbox doesn't exist, whether warm-up must be enabled, or what the response contains.

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

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

It is a single short fragment with no filler, so nothing is wasted, but it is under-specified rather than concise. The key scope information is present up front, just too thin to be efficient 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?

There is no output schema, so the description carries the burden of explaining return values, and it only gestures at 'status and health' without naming what fields or signals come back. For a read tool in a family of mailbox tools, that leaves an agent guessing about both the response shape and error conditions.

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

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

Only one parameter exists and its schema description is complete (100% coverage) with a concrete example address. The description adds nothing beyond that, which is acceptable given the schema already does the work.

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

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

The description names the resource (one mailbox) and the data domain (warm-up status and health), which tells an agent this is a single-mailbox health lookup. However, it omits the verb entirely and reads as a noun phrase, and it does nothing to distinguish it from close siblings like warmup_stats, mailbox_activity, or test_mailbox.

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

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

There is no statement of when to use this tool versus list_mailboxes, warmup_stats, or mailbox_activity, and no prerequisites or exclusions. The agent must infer usage purely from the name, despite several siblings operating on overlapping concepts.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds genuinely non-schema information: the link requires no login and deliberately exposes no pricing and no cross-client data, which tells the agent what will be shared externally. It stops short of saying whether the link is permanent, expiring, or regenerable.

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, zero filler, with the resource and its scope front-loaded before the visibility caveats. 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?

For a one-parameter read tool with full annotations and complete schema coverage, the description does enough: it says what the tool yields and what the artifact reveals to third parties. Only the link's lifetime/regeneration behavior is unaddressed, a minor gap for this complexity level.

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

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

Schema coverage is 100% and the single workspace_id parameter already documents its format (ws_…) and its source (list_workspaces). The description adds nothing about the parameter, so the baseline 3 applies.

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

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

The description names a specific resource (the public read-only report link) and its scope (one client workspace) and enumerates the report contents (mailbox health, spam rate, SPF/DKIM/DMARC). It is distinguishable from siblings like domain_health or warmup_stats, though it is phrased as a noun rather than an explicit verb, leaving the act of fetching a link implicit.

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

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

The second sentence conveys the intended use case – handing a login-free report to a client – which implies when to reach for this tool. However, it never explicitly says when to use this versus domain_health, warmup_stats, or mailbox_activity, nor does it state exclusions or prerequisites.

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

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

The description adds useful behavior beyond annotations: the link is opened by the user, works with one click on any device, and the mailbox appears in list_mailboxes a few minutes after authorization. It does not contradict the readOnlyHint=false annotation, and it gives meaningful flow context. It still omits details such as link expiry or renew 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 two concise sentences with the core action and result front-loaded. Every sentence adds useful information without repetition or filler.

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

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

For a simple link-generation tool with no output schema, the description explains the user flow and the asynchronous mailbox appearance well. It could mention return format or link lifetime more explicitly, but it is largely complete for invocation.

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

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

There is only one optional parameter, renew, and the input schema already documents it fully as 'Make a fresh link'. The description does not add further meaning, but schema coverage is 100%, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: it gets a link to connect Gmail / Google Workspace via Google sign-in. It also distinguishes this Google-specific flow from sibling tools such as connect_imap_mailbox and connect_zoho_mailbox.

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

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

The intended use is implied: generate a link for a user to connect a Google mailbox. However, it does not explicitly say when to choose this over connect_imap_mailbox or connect_zoho_mailbox, nor does it state exclusions or prerequisites.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds meaningful behavioral context by revealing that this call surfaces a plaintext password plus IMAP/SMTP configuration — sensitive output an agent should know about — but says nothing about permission requirements or whether credentials are always present.

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

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

A single short sentence with no filler, front-loading the returned data. It is efficient, though slightly under-specified rather than optimally concise for a credentials-returning tool.

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

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

For a trivial one-parameter read tool with full annotation coverage this is close to adequate, and it names the three outputs. However, with no output schema present, the description could state the actual shape of the return (host/port/SSL per protocol) and should flag that credentials are exposed; those gaps keep it at minimum-viable.

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 one parameter and 100% schema description coverage ('Mailbox address, e.g. sales@yourdomain.com'), the schema already fully documents the input. The phrase 'for one of your hosted mailboxes' reinforces that email selects the mailbox but adds no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

The description names the concrete payload returned — password, IMAP and SMTP settings — for a hosted mailbox, which is far more specific than the tool name alone. It lacks an explicit verb ('retrieve'/'get') and does not distinguish itself from siblings like get_mailbox or connect_imap_mailbox, so it stops short of a 5.

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

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

There is no statement of when to call this versus get_mailbox, connect_imap_mailbox, or test_mailbox, all of which live in the same mailbox area. The agent must infer usage from the noun phrase alone, and no prerequisites or exclusions are given.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description contributes by disclosing what the response contains (mailboxes, renewal date, price, IMAP/SMTP config), which is genuine added value. It does not disclose pagination, ordering, or whether all purchased domains are returned at once.

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

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

A single front-loaded sentence with no filler; every clause names content that is actually returned. It is a noun fragment rather than a verb-led statement, which slightly weakens the framing but wastes nothing.

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

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

With no parameters and no output schema, the description carries the burden of describing return values, and it does enumerate the main fields. Only minor gaps remain — ordering, volume, and whether mailboxes are nested per domain — which matter little for a no-arg listing tool whose annotations already cover safety.

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

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

The tool takes zero parameters, so the baseline is 4 and there is nothing for the description to disambiguate. The schema is trivially complete with no additionalProperties.

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

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

The description names a specific resource — domains bought in the domain shop — and enumerates the payload (hosted mailboxes, renewal date, price, IMAP/SMTP settings). The 'bought' qualifier implicitly separates it from search_domains and buy_domains, though no sibling is named explicitly. An agent can tell what this returns without opening a 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?

There is no statement of when to use this tool versus list_mailboxes, list_dns_records, list_workspaces, or domain_health. Usage can only be inferred from the noun phrase. No prerequisites, exclusions, or alternative routing are provided.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description does add one genuine behavioral fact not in the annotations — results are truncated to the first 200 — which is useful, but it doesn't say whether truncation is detectable or how to get the rest.

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

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

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

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

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

For a one-parameter read tool with rich annotations, this is close but not complete: there's no output schema, and 'where each is in the sequence' is not explained (field names, possible position values, or ordering). An agent knows the call will succeed but not what it will get back.

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

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

Schema coverage is 100% with a single required campaign_id already documented as coming from list_campaigns. The description adds nothing about format or validation beyond that, so the baseline 3 applies.

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

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

The description names a specific resource (contacts within a campaign) and adds the returned dimension (sequence position), which cleanly distinguishes it from list_campaigns and get_campaign. It omits an explicit verb, but the name supplies it and the scope statement is unambiguous.

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

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

There is no guidance on when to call this versus get_campaign or list_campaigns, and no stated prerequisites. The only routing hint (campaign_id comes from list_campaigns) lives in the schema, not the description.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is clear. The description adds that results include status and statistics, which is useful beyond annotations, but it does not cover pagination, sorting, result limits, or response shape. Given the annotation coverage, a 3 is appropriate.

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

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

It is a single short sentence with no filler, and the key information ('campaigns', 'status and stats') is front-loaded. It is perhaps too terse, but under-specification is better assessed under contextual 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?

For a zero-parameter read-only list tool, the description gives a minimal sense of return content by mentioning status and stats. However, with no output schema, it should do more to describe what a campaign record contains, whether all campaigns are returned, and whether any pagination or ordering applies.

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

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

The tool takes no parameters, so the baseline is 4. The description does not need to explain parameter meaning, and the schema coverage is 100%.

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 name and description together indicate that this returns a collection of the account's outbound campaigns along with status and statistics. However, the description lacks an explicit verb like 'list' and never distinguishes this tool from siblings such as get_campaign or list_campaign_contacts. It is understandable but vague.

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 get_campaign, list_campaign_contacts, or other campaign-related siblings. The only implied context is that it returns a collection, which the agent must infer from the name and the phrase 'Your Outbound campaigns'.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered elsewhere. The description contributes nothing beyond the annotation set — no indication of what the response contains (record types, values, TTLs), no error behavior for unpurchased domains, no pagination or ordering.

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

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

It is short with zero waste, but it is a sentence fragment ending in a period rather than a front-loaded statement of action. Brevity here comes at the cost of completeness rather than from disciplined editing.

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

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

For a one-parameter, read-only, closed-world tool with no output schema, the description is minimally sufficient: it names the resource and the domain precondition. It still leaves an agent guessing at the return shape and at how this differs from domain_health or list_bought_domains.

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

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

There is a single parameter with 100% schema description coverage, so the schema already carries the meaning of `domain`. The description adds only the constraint that it must be a domain bought here, which is marginal added value; baseline 3 applies.

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

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

The fragment "DNS records on a domain you bought here" identifies the resource and adds a real scope constraint (only domains purchased through this platform), but it never states a verb and never distinguishes itself from sibling DNS tools such as add_dns_record, delete_dns_record, or domain_health. An agent must infer from the name that this is a read/list 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?

There is no explicit when-to-use guidance and no mention of alternatives. The only usage signal is the implicit precondition that the domain must have been bought here, which a reader must extract from the noun phrase rather than being told directly.

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 closed-world, so the safety profile is covered. The description earns credit by disclosing the payload contents (warm-up day, status, spam rate, daily numbers, outbound readiness), which matters since there is no output schema. It omits result-size/pagination behavior for what is an unfiltered 'every mailbox' listing.

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

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

A single dense sentence with no filler, and the scope ('every connected mailbox') is front-loaded before the field list. It is a sentence fragment without a leading verb, which is slightly less scannable than a verb-first opening.

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

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

For a zero-parameter read with annotations covering safety and no output schema, the description carries the return-value burden well by naming the fields. Only the absence of ordering/pagination or result-size guidance keeps it from being fully complete.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline for a no-param tool is 4.

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

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

It states the resource and the scope precisely ('Every connected mailbox') and enumerates the per-mailbox data returned, which separates it from single-item siblings like get_mailbox. It stops short of a full verb+resource statement (no explicit 'list' or 'returns') and never names the sibling it contrasts with.

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

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

There is no explicit when-to-use guidance and no mention of alternatives such as get_mailbox for a single mailbox, warmup_stats, or mailbox_activity. The plural 'Every connected mailbox' only weakly implies a bulk-overview use case.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and closed-world, so the safety profile is fully covered. The description adds content-scope context (which providers and fields appear in the payload), which is genuinely useful, but says nothing about whether the list is static, whether auth is required, or how results are ordered/grouped.

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 primary content (IMAP/SMTP presets) before the secondary (API routes). The long parenthetical provider list is illustrative rather than wasteful, though the trailing ellipsis is slightly sloppy.

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

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

With no parameters, no output schema, and full annotation coverage, the description carries the remaining burden of telling the agent what comes back. It does that by naming the two result categories (IMAP/SMTP presets with hosts and ports; Google/Zoho API routes). Missing only the precise return structure, which is a minor gap for a static list.

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

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

The tool takes zero parameters, so the baseline is 4 and there is no parameter semantics to explain. The description correctly implies no filtering or selection input is accepted, consistent with the empty schema.

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

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

The description names the exact resource returned: IMAP/SMTP provider presets with hosts and ports, plus Google and Zoho API routes. Combined with the verb in the tool name, an agent can tell this is a lookup of supported provider configurations. It does not explicitly contrast itself with connect_imap_mailbox or google_connect_link, but the content is unambiguous.

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

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

There is no statement of when to call this versus alternatives; nothing says 'call this first to discover the provider key needed by connect_imap_mailbox.' The mention of 'Google and Zoho API routes' hints at the connect siblings but never routes the agent. Usage must be inferred entirely from the name.

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

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

Annotations already establish read-only, idempotent, non-destructive, closed-world behavior. The description adds useful behavioral context by naming the returned fields and explaining the workspace id/null relationship with list_mailboxes.

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 short sentences with no wasted language. The resource concept is front-loaded, followed by return information and the cross-tool relationship.

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

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

For a zero-parameter read-only list tool with rich annotations, the description is complete enough. It covers what is returned and how workspace ids relate to mailboxes, with no output schema required.

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

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

The tool has zero parameters, so there are no parameter semantics to document. The schema is empty and fully described, making the baseline score 4 appropriate.

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

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

The description clearly identifies the resource as client workspaces and states the returned fields (id, name, mailbox count). It does not use an explicit action verb like "list," but the tool name and return statement make the purpose clear and distinguish it from list_mailboxes.

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 implies usage by explaining that each mailbox in list_mailboxes has a workspace id and that null means My mailboxes. However, it does not explicitly say when to call this tool versus siblings like get_workspace_report, create_workspace, or list_mailboxes.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds useful behavioral context by disclosing the cap of 100 events and the event types returned, which goes beyond what annotations provide.

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

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

The description is a single, front-loaded sentence that states the core behavior and immediately lists the event types. Every part of the sentence adds value without redundancy.

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

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

Given the tool's simplicity (one parameter, read-only, no output schema) and the annotations that cover safety, the description is nearly complete. It explains the event cap and categories, though it could mention ordering (e.g., most recent first) or that the output is a list, which would remove minor ambiguity.

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 'email' is fully described in the schema (100% coverage) with an example. The description does not add any syntax, format, or semantic detail beyond what the schema already provides, so the baseline 3 is appropriate.

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

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

The description states a specific resource (warm-up events for a mailbox) and specifies the return scope (last 100 events) with concrete event categories. It does not, however, differentiate this tool from siblings like warmup_stats or get_mailbox, which likely offer overlapping information.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as warmup_stats or get_mailbox. The implied use case is to inspect recent activity, but no conditions, exclusions, or alternatives 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?

Annotations already declare a non-read-only, non-destructive, non-open-world mutation, so the safety profile is covered. The description adds one genuinely new behavioral fact not in the annotations or schema: an omitted/empty workspace_id performs the inverse move. It says nothing about what happens if the workspace id is invalid, whether the mailbox must be unassigned first, or any permission requirement.

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, no filler, with the primary action first and the edge-case rule second. Nothing could be removed without losing information.

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

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

For a two-parameter tool with full schema coverage, annotations, and no output schema, this is close to sufficient: an agent knows what it does and what the empty case means. Minor gaps remain around failure modes (unknown workspace id, mailbox already assigned elsewhere), which matter for a mutation but are not critical here.

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

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

Schema coverage is 100%, so the baseline is 3. The description exceeds that by documenting the semantic effect of omitting workspace_id entirely, which the schema only describes as 'Workspace id from list_workspaces' without explaining the empty case. The email parameter is left to the schema, which is fine.

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: 'Put a mailbox in a client workspace.' That is unambiguous and distinguishable from siblings like create_workspace, rename_workspace, or list_mailboxes. It stops short of explicitly naming which sibling performs a related-but-different operation, so it lands at 4 rather than 5.

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

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

The second sentence gives an explicit rule for the reverse operation: omit or empty workspace_id to return the mailbox to 'My mailboxes.' That is real usage guidance for the optional-parameter case. There is no guidance on prerequisites (workspace must already exist, mailbox must be connected) or on when to prefer this over, say, creating a new workspace.

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 disclose that this is a non-read-only, non-destructive, non-idempotent operation. The description adds the useful 'running' state constraint, but it does not explain what happens when pausing an already-paused campaign, whether sends halt immediately, or what the response returns. With annotations covering the safety profile, a 3 is appropriate.

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

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

The description is a single short sentence with no wasted words, and the action is front-loaded. It is appropriately sized for a simple toggle operation, though it could have used the space for one routing or state 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 simple one-parameter mutation with annotations and full schema coverage, the description is minimally complete. It still omits the likely non-idempotent behavior (pausing twice may error) and the relationship to start_campaign, which an agent would benefit from knowing.

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 only one parameter, and schema coverage is 100%; the schema itself documents campaign_id as coming from list_campaigns. The description adds no additional meaning about the identifier format or sourcing beyond what the schema already provides, so the baseline 3 applies.

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

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

The description states a specific verb and resource: 'Pause a running campaign.' An agent can immediately tell this changes campaign state. However, it does not differentiate from sibling tools like start_campaign, resume_mailbox, or pause_mailbox, so it stops short of the sibling-routing clarity that earns a 5.

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

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

The word 'running' implies a state precondition (the campaign must currently be active), which gives some usage context. But there is no explicit guidance on when to choose this over start_campaign or update_campaign, and no mention of what to do if the campaign is already paused.

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 this is a non-read-only, non-destructive, non-idempotent mutation, so the safety profile is covered. The description adds the useful qualifier that only warm-up is paused (the mailbox itself is not removed or disconnected), but it omits whether the pause is reversible, what happens to in-flight sends, and whether repeating the call errors given idempotentHint=false.

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 clause with no filler; the key noun (warm-up) and verb (pause) appear immediately. It is efficient, though borderline under-specified rather than genuinely tight.

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, no-output-schema mutation with full annotation coverage, the description plus structured data give enough to call it correctly. The remaining gap — reversibility and effect on active warm-up — is modest for a toggle-style 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 100% — the single `email` parameter is documented with a format example — so the schema carries the parameter burden. The description adds no meaning beyond it, which is the expected baseline for a fully documented one-parameter 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?

"Pause warm-up for a mailbox" states a specific verb (pause) and a specific resource scope (a mailbox's warm-up), which distinguishes it from pause_campaign and remove_mailbox. It stops short of naming the inverse operation (resume_mailbox) as an explicit alternative, but the purpose itself is unambiguous.

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

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

There is no guidance on when to pause versus remove_mailbox or resume_mailbox, no prerequisites, and no statement about the effect on ongoing warm-up activity. Usage is only inferable from the tool name and the single word "warm-up".

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

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

Annotations already declare destructiveHint=true, but the description adds important behavior: both the mailbox and its stored login are deleted, and the action is irreversible. The explicit instruction to confirm with the user before passing confirm=true provides crucial safety context beyond the annotations.

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

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

The description is two short sentences, front-loading the destructive effect and then the confirmation requirement. Every clause adds useful information without 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 two-parameter destructive tool with annotations covering the safety profile and no output schema, the description supplies the essential missing context: irreversibility, login deletion, and the confirm=true requirement. Nothing critical to correct invocation is omitted.

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 50%, with email documented in the schema and confirm left bare. The description compensates by explaining that confirm=true is the required confirmation mechanism, though it does not elaborate on confirm=false behavior or any other parameter nuance.

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

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

The description states a specific verb and resource: "Remove a mailbox and delete its stored login." It distinguishes the operation from non-destructive mailbox siblings like pause_mailbox or update_mailbox by making removal and login deletion 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?

It gives a clear precondition for use: ask the user first, then pass confirm=true, and labels the action irreversible. It does not explicitly compare against alternatives such as pause_mailbox or delete_workspace, so it falls short of full alternative guidance.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and notably idempotentHint=false, but the description adds none of the behavioral context that would be valuable here — e.g., whether the old name is discarded, whether renaming is reversible, or whether permissions are required. It merely restates the mutation that the annotations already classify.

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

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

A single front-loaded sentence with zero waste. It is efficient, though the brevity contributes to the under-specification 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?

For a mutation tool with no output schema and a 50%-documented parameter set, the description leaves important behavior unstated: what is returned, whether the name must be unique, and how failures are surfaced. It is not enough for an agent to call this confidently beyond the bare minimum.

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 only 50% schema description coverage, 'name' is undocumented in both schema and description; the description only loosely implies it is the new workspace name. The workspace_id parameter is explained in the schema, not the description, so the description does little to fill 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 states a specific verb ('Rename') and resource ('a client workspace'), clearly separating it from siblings like create_workspace and delete_workspace. It does not, however, name those siblings explicitly to reinforce the 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?

There is no guidance on when this tool should be chosen over alternatives such as create_workspace or update_mailbox, nor any mention of prerequisites (e.g., needing an existing workspace id from list_workspaces). The schema's workspace_id hint partially compensates, but the description itself provides no 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?

Annotations declare a non-read-only, non-idempotent, non-destructive mutation, but the description adds no behavioral detail. It does not say what state changes occur, whether resuming twice is safe, what errors may arise, or what the tool returns.

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

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

The description is a single short sentence with no filler, and the action is front-loaded. Its terseness is efficient but contributes to the under-specification 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?

For a mutating mailbox-state tool with no output schema and only generic annotations, the description is too thin. It omits state-transition semantics, prerequisites, and expected outcomes that an agent needs to invoke this 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?

There is only one parameter, and schema description coverage is 100%, so the schema already documents the mailbox email and provides an example. The description adds no additional meaning about the parameter beyond what is 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 states a specific verb ('Resume') and resource ('warm-up for a mailbox'), making the operation distinguishable from pause_mailbox. However, it does not explain what 'warm-up' means or how this differs from other mailbox state tools beyond the 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?

There is no guidance on when to use this tool versus pause_mailbox, warmup_stats, or update_mailbox. It also does not state prerequisites, such as whether warm-up must already be configured or paused.

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 this as a safe, read-only, idempotent search with no destructive behavior. The description adds that results include first-term and renewal prices, which is useful output context, but it does not discuss result limits, ranking, or thoroughness of the 'lookalike' 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 a single, front-loaded sentence with no filler. Every element (action, resource, use case, return info) earns its place.

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

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

For a simple one-parameter, read-only search with full schema coverage and annotations that cover safety, the description is nearly complete. Minor gaps remain around result set behavior and how 'lookalike' domains are generated, but none are critical for correct invocation.

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

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

Schema coverage is 100% and the single parameter 'q' is already documented as 'Brand or domain, e.g. acme.' The description adds no additional meaning about formatting, scope, or interpretation 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?

States a specific verb ('Find') and resource ('available lookalike domains') with the added context of cold email and pricing. It is easy to distinguish from siblings like buy_domains and list_bought_domains, but does not explicitly call out those alternatives.

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 'for cold email,' suggesting when to use this search. However, it does not name alternatives (e.g., use buy_domains to purchase) or state when not to use it, leaving routing to the agent's inference.

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

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

Annotations already flag a non-read-only, non-idempotent mutation, so the safety profile is covered. The description adds mode semantics and the 2+ constraint, but omits what switching does to existing mailboxes, warm-up state, or whether the change is reversible.

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 the default mode front-loaded. The parenthetical style is efficient, though slightly fragmentary and reliant on the tool name for the action.

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

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

For a simple boolean setting with annotations present, the key option meanings and default are covered. It leaves ambiguous whether the setting is account-wide or workspace-scoped and what immediate effect toggling has on current mailboxes.

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 sole private_pool boolean, but the description effectively maps the false/default case to shared network and the true case to private pool with a 2+ mailbox requirement.

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?

Defines the two pool modes and the default, making the setting's purpose inferable alongside the name set_pool_mode. However, it never explicitly states that this tool changes the mode or what entity the setting applies to.

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 the default shared mode and a prerequisite (2+ mailboxes for private pool), which implies when private mode is appropriate. But it provides no explicit when-to-use/when-not guidance or named alternatives.

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

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

Annotations only cover the generic safety profile; the description adds the operationally critical facts an agent cannot infer: real outbound email is sent, credits are consumed, user confirmation is mandatory, and two named failure modes with their response flags (warming:true, credits_required:true). It also spells out the semantics of the terms acceptance.

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?

Front-loaded with the highest-stakes fact (sends real email, uses credits) and every sentence carries operational content. It is dense with parentheticals and the terms clause is a long run-on, but nothing is redundant.

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

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

No output schema exists, and the description compensates by documenting the two error payloads and their flags, plus the confirmation and consent requirements. An agent has everything needed to call this safely and handle its failure paths.

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% and accept_sending_rules has no schema description at all, yet the description fully defines it (agreement to the outbound-beta terms with concrete obligations). accept_warming_risk is given both meaning and a gating condition, which goes well beyond the schema's one-liner.

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 pair and resource ('Start or resume a campaign') and immediately clarifies the action's nature: it SENDS real email and consumes credits. That framing separates it from create_campaign (draft creation) and pause_campaign without needing to name them.

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

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

Gives an explicit precondition ('Confirm with the user first'), a conditional branch for the warming failure with the exact remedy (set accept_warming_risk=true only after explicit agreement), and names the alternative tool to use when credits are missing (create_credits_checkout). This is when/when-not/alternatives in full.

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

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

The annotations already declare read-only, idempotent, non-destructive, and closed-world behavior, so the safety profile is known. The description adds that the tool actively signs in using stored credentials and reports validity, which is useful context. However, it does not disclose whether session creation occurs, what happens when no stored login exists, or any rate-limit/error 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 one front-loaded sentence with no wasted clauses. The imperative 'now' is slightly informal but does not materially bloat the description. A 4 reflects the efficient structure while noting the wording could be marginally tighter.

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

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

For a simple one-parameter tool with no output schema, the description explains both the action and the result to expect: whether the stored login still works. It omits prerequisites and failure-mode interpretation, but with full schema coverage and rich annotations, the essential context is 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?

Schema coverage is 100% for the single required email parameter, so the schema already explains that it expects a mailbox address. The description's phrase 'stored login' suggests the email identifies the saved credential to test, but adds no format or selection semantics beyond the schema. Baseline 3 is appropriate.

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

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

The description states a specific action: sign in to the mailbox and report whether the stored login still works. This is clearer than the bare tool name and implies a credential-verification purpose. It does not explicitly distinguish itself from similar siblings like hosted_mailbox_login or connect_imap_mailbox, so it falls short of a 5.

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

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

There is no explicit guidance on when to use this tool versus sibling login or connect tools, nor are prerequisites such as an existing mailbox or stored credentials stated. The only usage cue is the phrase 'stored login,' which implies verification but does not define when that check is appropriate.

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

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

Annotations already declare this is a non-read-only, non-destructive mutation, so the safety profile is covered. The description adds real value with the PATCH semantic ("fields you leave out keep their value"), but says nothing about array replacement (emails/mailboxes), permission requirements, or what error occurs when the campaign is not paused/draft.

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, zero filler, with the mutation scope and precondition front-loaded. Nothing here could be cut without losing information.

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

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

For a 5-parameter mutation with 20% schema coverage and no output schema, the description is too thin: it neither compensates for undocumented parameters nor describes failure modes (active campaign, invalid ids). Annotations cover only the safety profile.

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 20% (only campaign_id is documented) and the description names none of the five parameters. The omit-keeps-value sentence conveys optionality semantics, but name, emails, mailboxes and daily_limit — including whether arrays replace or merge — remain undocumented in both places.

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 ("Edit a ... campaign") and adds a precondition ("paused or draft") that separates it from create_campaign, get_campaign, pause_campaign and start_campaign. It doesn't explicitly name those siblings, so it falls just short of a 5.

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

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

"Edit a paused or draft campaign" implies the usage condition, but the agent is left to infer what to do if the campaign is active (pause first? use start_campaign instead?) and no sibling is named as an alternative. Precondition is stated; routing guidance is missing.

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 this is a non-destructive mutation with openWorldHint=false and idempotentHint=false, so the safety profile is covered. The description adds that a null daily_cap resets to the default, which is real behavioral information, but it does not say whether omitted fields are left untouched (partial vs full update), what permissions are needed, or what the call returns.

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

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

A single front-loaded sentence that names the fields and packs the two non-obvious constraints inline. Nothing is wasted and nothing essential 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 4-parameter mutation tool with no output schema and light annotations, the description covers parameters well but leaves the update semantics ambiguous — whether calling with just email is a no-op, whether unspecified fields are preserved, and what a successful response looks like. It is adequate but has clear 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?

Schema coverage is only 25% (only email is documented), so the description must and does compensate: it gives the daily_cap range (1-100) and the null-means-default sentinel, plus the IANA format for timezone with an example. Only the display-name parameter gets no extra semantics, which is fair for a simple string.

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 (change) and resource (mailbox) and enumerates the three mutable fields, so the agent can immediately tell this is a settings update rather than pause/resume/remove/move. It does not explicitly contrast with the many sibling mutation tools (pause_mailbox, move_mailbox_to_workspace, remove_mailbox), which keeps it below a 5.

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

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

There is no when-to-use or when-not-to-use guidance and no named alternative. The reader must infer that this is the tool for editing mailbox attributes instead of its siblings such as pause_mailbox or move_mailbox_to_workspace.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint=false and destructiveHint=false, so the safety profile is fully covered structurally. The description's added value is the returned metric set and the two time windows, which matters because there is no output schema. It does not clarify account/auth scope or define the jargon terms 'rescued' and 'ready', so the addition is modest rather than rich.

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

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

A single sentence with zero filler, leading with the resource ('Totals across your mailboxes') and then the breakdown. Every clause carries information an agent would otherwise have to guess.

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

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

For a no-parameter, read-only, non-destructive aggregate tool with no output schema, the description covers the essentials: what is aggregated, over which windows, and which metrics come back. The remaining gap is scope (whose account/mailboxes) and the meaning of 'rescued'/'ready', which an agent calling this blind might misread.

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

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

The tool takes zero parameters and the schema is an empty closed object, so there is nothing for the description to disambiguate. Baseline 4 applies; no parameter-level gaps exist.

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 the resource and scope precisely: aggregate totals across all your mailboxes, split into 'today' and 'last 7 days', with the exact metric names (sent, received, rescued, replied, active, ready). That is far more specific than a bare name restatement. It stops short of naming a sibling it is not (e.g. mailbox_activity, get_workspace_report), so an agent still has to infer the distinction from the sibling list.

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

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

The 'totals across your mailboxes' framing implies a dashboard/overview use case, and the presence of per-mailbox and per-workspace siblings (mailbox_activity, get_mailbox, get_workspace_report) makes the intended niche inferable. However, there is no explicit when-to-use or when-not-to-use statement, and no routing cue telling the agent to prefer this over those alternatives for an aggregate snapshot.

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