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

With no annotations, the description carries the behavioral disclosure burden and does so well: it explains idempotency ('Safe to retry'), the one-contact-per-workspace rule, and that re-adding an existing email joins the audience rather than duplicating the contact. It does not cover permissions or errors, but the key behavioral edge cases are disclosed.

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

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

The description is three sentences with no filler. It front-loads the core action, then adds high-value behavioral context, and ends with the retry guarantee. Every sentence earns its place.

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

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

For a simple tool with no output schema and no annotations, the description covers the most important contextual details: idempotency, uniqueness across workspaces, and audience membership semantics. It is not exhaustive about response values or failure modes, but it is complete enough for correct invocation in most cases.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meanings. It refers to 'someone' and 'address,' which loosely maps to email, and 'audience' maps to audience_id, but it does not explain optional first_name/last_name, the role of email as the lookup key, or parameter relationships. The description adds little beyond the schema's field names.

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

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

The description clearly states the verb 'Add' and the resource 'someone to an audience,' which distinguishes it from siblings like add_suppression (adding to a suppression list) and remove_from_audience (removing membership). The addition of uniqueness semantics further clarifies exactly what the tool does.

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 when adding a contact to an audience and explains the behavior for existing contacts, but it does not explicitly state when to prefer this tool over alternatives or when not to use it. No sibling comparisons or exclusions are provided, leaving the agent to infer routing from the tool name and purpose.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses that two subdomains are provisioned, that the system chooses the right one per message, that this isolates marketing complaints from transactional delivery, and that risk_class changes the provisioning 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 front-loaded with the action and output, then gives a compact explanation of the subdomain behavior and the risk_class condition. Every sentence adds necessary value with no filler.

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

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

For a tool with only two parameters and no output schema, the description is complete: it explains what domain to provide, what happens by default, how risk_class changes behavior, and what the caller receives (DNS records to publish).

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?

Although the schema already covers both parameters at 100%, the description adds meaningful context: domain is the base domain under which mail.<domain> and news.<domain> are provisioned, and risk_class is used only to provision one subdomain on its own.

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 ('Register') and resource ('sending domain'), and clearly defines the expected output: DNS records to publish. It is easily distinguishable from sibling tools like list_sending_domains and verify_sending_domain.

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

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

The description gives clear context for supplying the sending domain and explicitly explains the condition for using risk_class: 'Pass risk_class only to provision one of the two on its own.' However, it does not explicitly name sibling alternatives or state when not to use this tool, so it stops short of a 5.

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

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

With no annotations, the description carries full burden. It discloses a key behavioral nuance: marketing scope preserves transactional mail. However, it does not mention whether suppression is permanent, reversible, affects scheduled sends, or is 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?

The description is two short sentences with no filler. The primary action is front-loaded and the scope clarification earns its place. It is as concise as possible while adding useful information beyond the schema.

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

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

For a mutation tool with no annotations, no output schema, and zero schema-level parameter descriptions, the description is too thin. It omits important operational context like reversibility, bulk alternatives, and effects on different message types beyond the marketing scope note.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning for the 'scope' parameter but leaves 'email' and 'reason' entirely unexplained, and the full semantics of 'all' and 'transactional' scopes are only implied. This is insufficient for a schema that offers no descriptions.

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

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

The description clearly states the tool's action ('Stop sending to an address') and adds a meaningful scoping detail about marketing scope. It is easily distinguishable from the sibling remove_suppression, though it does not explicitly name that alternative.

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

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

The description gives no guidance on when to use this tool versus siblings like suppress_many or remove_suppression. It explains one scope option's effect, but does not address tool-selection context 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?

With no annotations, the description carries the burden. It discloses the key behavioral constraint (status must be 'scheduled') and the timing window, but does not mention side effects such as irreversibility, permissions, or what happens when the status is not scheduled.

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 resource, with no wasted words. The status constraint is placed in the second sentence, keeping the primary purpose first.

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 cancellation tool the description covers purpose and precondition, but because there is no output schema or annotation and the parameter semantics are not elaborated, the agent is left to guess at identifier semantics and expected outcomes beyond success/failure. 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?

The schema provides only a bare string property with no description, and schema description coverage is 0%. The description does not explicitly state that id is the scheduled email identifier or where to obtain it, so the agent must infer this from the tool name.

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

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

The description uses a specific verb ('Cancel') and resource ('scheduled email'), and adds the temporal qualifier 'before it sends.' This clearly distinguishes it from send/list/update siblings and leaves no ambiguity about its function.

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

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

The status constraint 'Only works while status is scheduled' gives an explicit precondition for use and implicitly tells an agent not to call it for emails that are already sent or in draft. It does not name alternatives, but among siblings there is no direct alternative for this operation.

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

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

With no annotations, the description carries the behavioral burden. It conveys that this is a read-only, current-state count and provides a practical reason for using it. However, it does not disclose return format, error behavior, or whether the count is computed in real time, leaving meaningful gaps.

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

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

Two concise sentences, front-loaded with the core purpose and followed by a useful usage example. There is no wasted language or unnecessary repetition of schema details.

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

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

For a simple single-parameter read-only count tool, the description is largely complete: it states what is counted, when to use it, and implies the return is a count. It would benefit from explicitly confirming the response shape or behavior for invalid IDs, but those are minor 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 description coverage is 0%, and the description adds no explicit meaning to the required 'id' parameter beyond referring to 'a segment.' The agent must infer that 'id' is the segment ID from the tool name and prose, which is only minimal compensation for the lack of schema documentation.

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

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

The description clearly states the tool counts how many contacts a segment currently matches, with a specific verb and resource. It does not explicitly differentiate itself from sibling tools like list_segments, but the meaning 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 gives concrete usage context: run this before building a campaign to check whether a segment matches anyone. It does not mention when not to use it or point to alternatives, but the guidance provided is clear and actionable.

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

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

With no annotations, the description carries the full burden. It does disclose the most important side effect, that approving sends immediately, and states the human-authorization guardrail. However, it does not say what rejecting does, whether the action is reversible, or what permissions or response to expect, so the behavioral disclosure is only partial.

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 with no filler. The core purpose and immediate effect are front-loaded, and the important usage restriction follows naturally without adding bulk.

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 action tool the description covers the central purpose, guardrail, and approve side effect, and no output schema is expected. Still, with no annotations and sparse parameter descriptions, the missing behavior for reject and the unstated return value leave a noticeable completeness gap.

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

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

Schema coverage is only 25%: only decided_by has a description. The description clarifies the decision semantics ('Approving sends it immediately') but says nothing about id or the optional reason, and it does not compensate for the low coverage. The enum and schema carry most parameter meaning.

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

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

The description opens with a specific action on a clear resource: 'Approve or reject a held message.' It adds the concrete consequence 'Approving sends it immediately,' and this clearly distinguishes it from sibling listing tools such as list_pending_approvals or send_broadcast.

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?

'Only use this when a human has explicitly told you which decision to make' is an explicit condition, and 'the hold exists precisely so that an agent is not the one deciding' is a clear when-not. This prevents an agent from substituting its own judgment while deciding whether to call this tool.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It reveals a non-obvious behavior: suppression and topic preferences are intentionally preserved, with a rationale that the opt-out must outlive the contact record to prevent re-adding on import. It does not explicitly state irreversibility or permission requirements, but the key side effects are transparent.

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 tightly written sentences: the action, the important side-effect nuance, and the alternative tool. Information is front-loaded and every sentence earns its place.

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

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

For a one-parameter delete operation with no output schema, the description covers the action, scope, side effects, and alternative tool. Nothing an agent needs for correct invocation is missing.

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

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

Schema description coverage is 0% and the description adds no direct explanation of contact_id. However, the single parameter is self-explanatory from its name and the tool context, so minimal compensation is needed. The lack of any parameter detail keeps this at a baseline rather than higher.

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

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

States a specific verb ('Remove'), resource ('person from the workspace'), and scope ('entirely, along with every audience membership'). It explicitly contrasts with remove_from_audience, so an agent can tell this tool apart from the related sibling without inspecting schemas.

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?

Contains an explicit when-to-use alternative: 'To take someone off a single audience use remove_from_audience instead.' This establishes the clear condition for choosing delete_contact (full removal) versus the sibling, and also provides context about retained preferences.

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

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

With no annotations, the description carries the full burden, and it discloses the most important behavioral trait: the event is not a passive signal but 'start[s] every automation that waits on it,' implying fan-out and downstream side effects. It could further warn about the consequences of triggered automations, but the core mechanism is transparent.

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

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

Two sentences, no wasted words, with the core action front-loaded and examples embedded. Every clause 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?

The core concept and trigger behavior are well explained, but a required parameter ('email') is semantically opaque with no annotation or output schema to compensate. The tool is simple enough that the main gap is the unexplained required parameter, making this adequate but incomplete.

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 33% — only 'name' has a schema description. The description adds nothing about the required 'email' parameter (its role in an event is entirely unexplained) or the 'variables' object. An agent has no way to know what 'email' means in this context.

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

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

The description states a specific verb+resource: 'Emit a named event, starting every automation that waits on it,' with concrete examples ('trial_started', 'invoice_overdue'). It also distinguishes itself from the alternative of directly naming an automation, which separates it from siblings like enroll_in_automation.

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?

'Use this when you want the configured sequences to decide what happens, rather than naming an automation yourself' is an explicit when-to-use statement that contrasts with the alternative approach. It doesn't name a specific sibling tool, but the behavioral contrast makes the selection criterion 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?

With no annotations provided, the description carries the full disclosure burden and does well: it reveals that the sequence self-stops on unsubscribe/reply/bounce and that duplicate enrollment is a no-op, meaning retries are safe. It could additionally mention return behavior or error cases, but the most important behavioral traits are covered.

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

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

Three concise sentences: the first states the core action, the second explains the preferred use case and its benefit, and the third covers idempotency and retry safety. Every sentence earns its place with no filler or redundancy.

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

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

The description provides essential operational context such as automatic stopping and safe retries, which is helpful for a mutating tool with no annotations. However, it does not explain what a successful response looks like, what error conditions might arise, or how the optional 'variables' parameter is used, so an agent may not fully know what to expect after calling it.

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

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

Schema description coverage is only 33%, with only 'variables' described in the schema. The description does not clarify the semantics of 'automation_id' or 'email' beyond indirectly referring to 'a multi-step sequence' and 'someone'. Given the low coverage threshold, the description needs to compensate and does not sufficiently do so.

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

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

The description clearly states the action ('Put someone into a multi-step sequence') and the resource (an automation), which is specific enough to distinguish it from one-off sending tools. It could be stronger by naming a sibling tool or explicitly saying 'automation_id', but the purpose is unambiguous.

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

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

The description gives concrete guidance on when to prefer this tool: use it instead of manually scheduling several emails, because the sequence automatically stops on unsubscribe, reply, or hard bounce. It also notes retry safety due to idempotency. It does not explicitly list exclusions or alternative sibling tools, but the guidance is clear and actionable.

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

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

No annotations are present, so the description carries the disclosure burden. It discloses non-obvious behavior: rows are returned per audience membership (three lists = three rows) and each row indicates unsubscription status. It stops short of detailing pagination/cursor behavior, but the disclosed semantics substantially exceed a bare verb.

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

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

Three sentences, each with a distinct job: scope, match modes, and return semantics. No filler or repetition.

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

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

For a tool with no output schema and no annotations, the description covers core selection and invocation needs: cross-audience scope, match modes, and row multiplicity. Minor gaps remain around whether at least one of q/email must be supplied and pagination details, but the schema's next_cursor description mitigates this.

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 80%, so most parameter meaning is already structured. The description adds value by clarifying that email is exact while q is a prefix, and by explaining how results relate to parameters. It does not elaborate limit/cursor, but those are optional and the schema covers cursor.

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'), a resource ('contact by address'), and a clear scope ('across every audience') plus the qualifier 'without knowing which list they are on'. This distinguishes it from sibling contact tools such as get_contact or list_audiences by emphasizing cross-audience search.

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

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

The description gives explicit invocation guidance: 'Use email for an exact match, or q for a prefix,' which tells the agent which parameter to choose and how matching behaves. It establishes the intended case (searching across lists) but does not name sibling alternatives or state when not to use it.

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

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

With no annotations available, the description carries the full burden. 'Fetch' clearly implies a read-only operation and the description discloses the data payload. It does not mention behavior for missing IDs, errors, authentication, or pagination, but for a simple one-contact fetch this is a moderate gap.

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

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

The description is a single concise sentence that front-loads the core action and resource, then lists the included data. Every word contributes value with no redundancy.

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

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

For a simple single-parameter fetch with no output schema, the description adequately covers the return content and core purpose. It could be more complete by noting not-found behavior, but overall it provides enough context for an agent to call the tool correctly.

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

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

Schema description coverage is 0% and the description only confirms that the id parameter identifies the contact, adding minimal meaning beyond the schema's bare 'string' type. It provides no format, example, or constraints, so the description does not sufficiently compensate for the missing parameter documentation.

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

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

The description states a specific verb ('Fetch'), a resource ('one contact'), and the retrieval method ('by id'), and it enumerates the returned data (audience memberships, custom properties, engagement dates). It is clear and distinct from sibling search tools like find_contact, though it does not explicitly name 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?

The phrase 'by id' implies the tool is appropriate when a contact ID is already known, which gives some usage context. However, it does not explicitly state when to prefer this over find_contact or other contact-related tools, and provides no 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It explicitly describes the return content—event timeline with send, delivery, bounce, complaint, open, and click—and the diagnostic intent. It stops short of covering error cases, permissions, or id-not-found behavior, but for a simple fetch operation this is reasonably transparent.

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

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

Two sentences, front-loaded with the primary action and response content, followed by a practical use-case hint. Every sentence earns its place with no filler or redundancy.

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

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

For a single-parameter fetch tool with no output schema, the description sufficiently covers what the agent gets back and when to use it. It doesn't explicitly differentiate from get_thread or get_email_metrics, but the 'full event timeline' phrasing and diagnostic purpose make the tool's role clear.

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

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

Schema coverage is 100% and the single required parameter 'id' is described as 'Message id'. The description reinforces that this identifies a single message but does not add meaningful semantic detail beyond the schema, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Fetch one message' with a defined scope, including the full event timeline. It clearly distinguishes this from related sibling tools like list_emails, get_email_metrics, and get_thread by focusing on one message's event history.

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 use case: 'This is the tool to reach for when asked why an email didn't arrive.' It does not explicitly name sibling alternatives or state when not to use it, but the situational guidance is strong enough for an agent to route appropriately.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses a non-obvious metric detail: open and click rates are calculated over delivered messages, not sent messages. This is genuinely valuable context that prevents misinterpretation of the reported metrics.

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: the first states the tool's function, and the second provides a high-value interpretive nuance. There is no redundancy or filler, and the most important information is front-loaded.

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

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

For a single-parameter tool with no output schema, the description is largely sufficient: it explains what is measured, over what window, and how to interpret a key edge case. It does not spell out the exact return fields, but the named metrics give an adequate mental model.

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

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

The only parameter, 'days', is fully documented in the schema with range and default value, so schema coverage is 100%. The description's 'over a window' aligns with the parameter but adds no additional semantic detail beyond what the schema already states.

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

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

The description clearly states the tool reports delivery and engagement over a time window, and the second sentence names open, click, and bounce rates. It does not explicitly differentiate itself from sibling list/get tools, but the aggregate metrics focus is reasonably distinct.

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

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

The description gives clear context: use this for delivery and engagement analytics over a window, and it even clarifies how to interpret low open rates with high bounce rates. It does not name alternative tools or explicit when-not-to-use conditions, but the purpose is specific enough to guide selection.

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

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

With no annotations, the description carries the behavioral burden. It adds useful context by explaining that the tool surfaces opt-out preferences and warns against mistaking them for delivery failures. However, it does not explicitly state that the operation is read-only, nor describe error/empty-result behavior.

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

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

Two sentences, zero filler. The core meaning is front-loaded, and the second sentence earns its place by providing a concrete diagnostic heuristic that clarifies when the tool matters.

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

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

For a single-parameter read tool with no output schema, the description is nearly complete: it states what it returns and when to call it. It could add a little more about interpreting the returned preferences or explicitly naming the setter sibling, but the essential invocation 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?

The schema has 0% description coverage, so the description must compensate, but it never mentions the email parameter or says that the person is identified by email address. The phrase 'one person' only loosely implies the selection mechanism, leaving the agent to infer that the required 'email' property is the identifier.

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 this as the tool that retrieves one person's email-receipt preferences, using the name plus a succinct noun-phrase. The diagnostic framing — an opt-out looks identical to a delivery failure — differentiates it from siblings like set_email_preferences and list_suppressions, so an agent knows exactly what it returns.

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 explicit when-to-use guidance: check this before asking a human why someone isn't receiving email. It does not name sibling tools or give explicit when-not-to-use exclusions, but the context is clear and actionable.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden and does so excellently. It reveals that inbound text has quoted history and signatures stripped, that raw_text holds the untrimmed body as a fallback, and that spf_verdict and dkim_verdict must be checked before trusting a reply's sender. These are non-obvious processing details that materially affect how an agent interprets results.

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

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

The description is three sentences with zero filler. The primary purpose is front-loaded, followed by the most important processing caveat and then a security directive. Every sentence earns its place and the structure moves from general to specific.

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

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

For a simple one-parameter read tool with no output schema, the description covers the key response aspects: chronological transcript, stripped vs raw text, and authentication verdicts. It is nearly complete, but it does not mention pagination, error behavior, or any other top-level thread fields. This is a minor gap given the tool's low complexity.

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

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

The schema already documents the sole parameter `id` with the description 'Thread id', and schema description coverage is 100%. The tool description adds no additional meaning about the id parameter beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description clearly identifies the tool as reading a conversation and presenting it as a chronological transcript of outbound and inbound messages. The verb 'Read' plus the resource 'conversation' unambiguously differentiates this from list_threads (listing) and reply_to_message (writing), making sibling discrimination immediate even without naming 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?

The description implies when to use this tool — whenever you need the full thread transcript — but it does not explicitly contrast it with alternatives like list_threads, nor does it state when not to use it. The usage context is clear enough to infer, but there is no direct guidance on choosing between get_thread and other conversation-related tools.

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

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

With no annotations, the description carries the full burden. It correctly implies this is a read-only check and explains the consequence of exceeding quota, but it does not explicitly state that this tool has no side effects, does not consume quota, or what the response structure looks like. Some behavioral detail is present, but not complete.

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

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

Two sentences, front-loaded with the core purpose, followed by a clear use-case and rationale. Every sentence earns its place and there is no redundant 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 no-parameter tool, the description covers the key returned information: plan, monthly sent count, and remaining allowance. It could explicitly mention response formatting or units, but this is not critical given the simple nature of the tool and the absence of parameters.

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

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

The tool has zero parameters, so there is no parameter semantic burden. The description appropriately focuses on what data is returned rather than input details.

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

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

The description clearly states what the tool reports: the workspace's plan, emails sent this month, and remaining quota. It lacks an explicit verb like 'retrieve' or 'get', but the meaning is unambiguous and distinct from all sibling tools.

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

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

It gives a concrete usage context: check before a large batch send, because exceeding the included allowance without overage causes the whole send to be refused. It does not mention alternatives or explicitly say when not to use it, but the guidance is practical and sufficient for this simple read-only tool.

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

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

With no annotations, the description carries the full burden. It discloses a meaningful behavior beyond the obvious: 'Never returns key values,' which prevents an agent from treating this as a credential retrieval tool. It doesn't mention pagination or read-only guarantees, but the security-relevant detail is valuable.

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 delivers both the core purpose and a critical exclusion. Every word earns its place, and the security caveat is placed as a clear second clause without diluting the main message.

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 parameterless list operation with no output schema and no annotations, the description covers what is returned, the scope, and what is deliberately omitted. An agent has everything needed to select and invoke the tool correctly.

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

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

The tool has zero parameters, so there is no parameter ambiguity. The description correctly focuses on result semantics rather than input syntax, matching the baseline for a parameterless tool.

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

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

The description names a specific verb ('List'), a precise resource ('this workspace's API keys'), and the particular attributes returned ('scopes and limits'). It also explicitly states what it never returns, making it unmistakable among the many list_* 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?

The scope is clearly anchored to the current workspace, so the agent knows which keys are in play. It doesn't enumerate alternatives or exclusions, but for a resource-specific list tool the context is sufficiently clear without extra routing.

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

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

With no annotations, the description carries the behavioral burden. It explicitly uses 'List,' indicating a non-mutating read operation, and specifies that counts are included in the output. It does not mention pagination or rate limits, but for a zero-parameter, straightforward listing this is reasonably transparent.

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 concise sentence that front-loads the action and resource, then adds the key output detail (contact counts). Every word adds value and there is no redundant content.

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

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

The tool is simple, parameterless, and has no output schema. The description covers what is listed and the essential returned metric, which is sufficient for an agent to select and invoke it correctly. Minor omissions like pagination or sorting do not undermine usability.

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 no parameters, so there is nothing for the description to clarify about arguments. The baseline of 4 applies because parameter semantics are irrelevant and the description need not compensate for any schema gaps.

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 (List) and resource (contact lists), and adds the distinguishing metric 'how many contacts each holds.' This clearly separates it from sibling tools like list_segments, list_tags, and list_broadcasts.

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

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

No guidance is provided about when to use this tool versus alternatives such as list_segments or list_tags. The description implies a simple listing use case but does not state exclusions or direct the agent to a sibling when a different kind of list is needed.

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

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

With no annotations, the description carries the burden. It discloses that the tool returns sequences and active participant counts, which is useful, but it does not mention ordering, pagination, status filtering, or any side-effect profile. This is adequate for a simple list tool but leaves some behavioral aspects implicit.

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 exactly two sentences, front-loading the core function ('List multi-step email sequences') and then adding the usage context. Every word earns its place, with no redundancy or filler.

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

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

For a no-parameter list tool without an output schema, the description covers the main function and the user's goal. It lacks details on response shape or filtering options, but given the simplicity, it is sufficiently complete for an agent to invoke it correctly.

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

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

The tool has zero parameters, and the schema description coverage is 100% because the schema is empty. Per the baseline for 0-param tools, a score of 4 applies, and the description appropriately adds no parameter details since none 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?

The description clearly states the tool lists 'multi-step email sequences' with counts of people in each, using a specific verb and resource. It distinguishes itself from sibling tools like list_broadcasts or list_templates by focusing on multi-step sequences and the enrolling context.

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

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

The phrase 'Use this to find the right automation before enrolling someone' provides a clear usage context tied to the sibling enroll_in_automation. However, it does not explicitly mention when not to use it or name alternatives, so it stops short of full exclusionary 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?

With no annotations, the description must carry the behavioral disclosure burden, but it only states the result content. It does not mention pagination, ordering, response shape, rate limits, or whether this is a read-only operation beyond what is implied by 'list' in the name.

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

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

The description is very short with no filler, and the core output concept is front-loaded. However, it is concise to the point of being under-specified, so it does not fully earn its place by enabling correct tool invocation.

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

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

Given no output schema, no annotations, and two undocumented parameters, the description is not complete enough for an agent to call the tool reliably. It provides the basic idea but omits necessary details about parameters and result structure.

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

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

Schema description coverage is 0%, and the description adds almost no parameter clarity. The 'campaign' phrasing hints that 'id' references a broadcast, but the required 'id' parameter and the optional 'limit' parameter are never explained.

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 conveys the tool's output: recipients of a campaign and message-level outcomes. It distinguishes the resource ('campaign' / recipients) from sibling tools like list_broadcasts, though it lacks an explicit verb such as 'list' or 'retrieve'.

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 list_broadcasts, preview_broadcast, or list_threads. The intended use case must be inferred entirely from the tool name and the one-line 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only restates that the tool lists campaigns with status and send progress, without revealing pagination behavior, ordering, scope of campaigns returned, or any filtering semantics.

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

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

The description is a single sentence, front-loaded with the verb and resource, and every word contributes meaning. There is no redundancy or wasted text.

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

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

For a zero-parameter list operation, the description conveys the core purpose and what information is surfaced. However, with no output schema and no annotations, it leaves gaps around response shape, pagination, and the exact meaning of 'send progress', so 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?

The tool has zero parameters, so there is nothing for the description to add beyond the schema. The schema description coverage is complete at 100%, and the baseline of 4 for no-parameter tools applies.

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

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

The description clearly states the action ('List') and resource ('campaigns'), and adds the output focus of status and send progress. It distinguishes from list_broadcast_recipients by focusing on campaigns rather than recipients, though it does not explicitly differentiate itself from sibling tools and uses 'campaigns' while the tool is named 'broadcasts'.

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 list_broadcast_recipients or list_emails, and no exclusions or prerequisites are mentioned. The usage context is only implied by the tool's purpose rather than explicitly 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?

There are no annotations, so the description carries the full burden of behavioral transparency. It says 'recent messages' but does not define 'recent', disclose default limits or pagination, describe ordering, or state what fields the response contains. For a list operation this is a notable gap, though the read-only nature is weakly implied by the verb 'List'.

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

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

The description is two sentences with no filler. The core purpose is front-loaded in the first sentence, and the second sentence efficiently covers the filtering options. Every word earns its place.

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

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

Given no annotations, no output schema, and a partially documented parameter set, the description is not complete enough for reliable invocation. It omits return format, default limit behavior, definition of 'recent', and any differentiation from overlapping list tools. These are significant gaps for an agent deciding whether and how to call this tool.

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

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

Schema coverage is only 33%, so the description must compensate. It does add value by enumerating valid status values and clarifying that 'recipient' maps to the 'to' parameter. However, the 'limit' parameter is left completely undocumented in both the schema and description, so compensation is incomplete.

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

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

The description clearly states the action ('List'), the resource ('recent messages'), and the key concept ('delivery status'). The specific status filters (queued, scheduled, sent, delivered, bounced, complained, rejected) make the tool's purpose unambiguous and help distinguish it from siblings like list_threads or list_broadcasts.

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 a use case—finding messages by delivery status or recipient—but provides no explicit guidance on when to prefer this tool over closely related siblings such as list_scheduled_emails, list_webhook_deliveries, or get_email. No alternatives or exclusions are mentioned, leaving routing 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?

With no annotations, the description carries the burden of behavioral disclosure. It explains that approval is human-controlled, that the key drafts rather than sends, and that retrying is wrong. It does not mention whether the list is scoped to the current key or describe pagination/return envelope, but core behavior is clear.

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 concise sentences with no filler. Each sentence earns its place: what the tool lists, why messages are pending, and an operational warning about retrying sends.

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

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

For a zero-parameter list tool, the description covers what it returns, the approval workflow context, and the key behavior to avoid. It could be slightly fuller by pointing to decide_approval for taking action on the pending message, but it is otherwise 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 has zero parameters and schema coverage is 100%, so no compensating description is needed. The baseline 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 opens with a specific verb and resource: 'List messages held for human approval', and adds 'with their full content'. This clearly distinguishes it from sending tools and from decision tools like decide_approval.

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 an explicit trigger condition: after a send returns 'pending_approval', the message is waiting here and the send should not be retried. It does not explicitly name decide_approval as the tool for resolving approvals, which keeps it from a 5.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals that only unsent queued messages are included and hints at a workflow via cancellation, but it does not state that the operation is read-only, how results are ordered, or what a 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?

Two short sentences carry useful information without filler. The core definition is front-loaded, and the pointer to cancel_scheduled_email is a relevant, non-redundant addition.

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

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

For a simple list tool with one optional parameter, the description is minimally adequate: an agent can infer what to call and roughly what it returns. However, the lack of parameter explanation, explicit read-only behavior, and return-shape context leaves meaningful gaps, especially because no output schema or annotations compensate.

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

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

The schema has one optional parameter, limit, with 0% schema description coverage, and the description does not mention limit at all. The parameter name and numeric constraints suggest its meaning, but the description adds no semantic value beyond what the schema already exposes.

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 'Messages queued to send later but not yet sent,' which pins down what this tool operates on. It distinguishes scheduled emails from sent or broadcast emails, though it relies on the tool name for the explicit 'list' verb.

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

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

The description implies when to use the tool: to view unsent queued messages. It also points to cancel_scheduled_email as the follow-up action, which gives useful context, but it does not explicitly contrast this tool with alternatives like list_emails or list_broadcasts.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It communicates a read-only listing operation and the reuse/counting benefit, but it does not mention return shape, pagination, permissions, or other edge behavior. This is minimally acceptable for a zero-parameter list tool.

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

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

The description is two sentences with no fluff. The main operation is front-loaded, and the second sentence earns its place by explaining why segment IDs matter for campaign creation.

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

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

For a simple parameterless read-only list, this is reasonably complete: it states what is listed and why the IDs are useful. It does not describe the exact output structure, but the use-case sentence implies the response exposes segment IDs, so the gap is minor.

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

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

There are zero parameters and the empty schema fully covers them, so there is no parameter ambiguity. The description appropriately focuses on use context rather than parameter details, which matches the baseline for a parameterless tool.

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

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

The description clearly states the action ('List') and the resource ('saved audience filters'), so the core function is obvious. It does not explicitly contrast this with the sibling list_audiences tool, though the audience-filter framing helps distinguish segments from audiences.

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 practical usage context: use a segment id when creating a campaign rather than inline filters, so the definition is reusable and counted. It does not name alternatives or exclusions, but the intended scenario 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?

With no annotations, the description carries the burden of behavioral disclosure. It explains the output format ('verification status and DNS records'), notes that each record shows currently published values, and frames the tool's diagnostic value. The read-only nature is implied by 'List' and the diagnostic framing.

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

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

Two sentences with no filler. The core listing behavior is front-loaded, and the second sentence adds valuable diagnostic context without redundancy.

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

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

For a zero-parameter list tool with no output schema, the description fully covers what the agent needs to know: what is returned, what records show, and when the tool is useful. Nothing important is missing.

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

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

The tool has zero parameters, so the description needs to provide no parameter-level detail beyond what the empty schema shows. This meets the baseline for parameter-free tools.

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

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

States a specific verb ('List') and resource ('sending domains'), and clarifies the output includes verification status and DNS records. It also distinguishes itself from sibling tools like add_sending_domain and verify_sending_domain by focusing on listing and diagnosis.

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?

Clearly implies use when you need to see sending domains, their verification state, or diagnose a stuck verification. It doesn't explicitly contrast with verify_sending_domain, but the diagnostic purpose is specific enough to guide selection.

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

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

No annotations are provided, so the description must disclose behavior. It implies a read-only operation through 'List' and clarifies the content (suppressed addresses plus reasons). However, it does not discuss pagination, the default or maximum page size, ordering, or whether the list is limited to active suppressions. The description is not misleading, but it leaves several behavioral details unstated.

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

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

The description is two sentences with no wasted words. The main action and resource are front-loaded in the first sentence, and the second sentence provides a practical trigger for use. Every sentence earns its place.

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

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

For a one-parameter list tool with no output schema, the description adequately covers the core purpose, the reason taxonomy, and a concrete diagnostic situation where this tool is the right first choice. It does not describe the exact return shape or pagination behavior, but those are not critical for an agent to make a first correct call.

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

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

Schema description coverage is 0% and the description never mentions the sole parameter, `limit`. The agent must rely entirely on the parameter name and the schema's min/max constraints. The description does not compensate for the missing schema descriptions, though the parameter's purpose is reasonably inferable.

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

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

The description clearly states a specific verb and resource: 'List addresses we refuse to mail and why,' and enumerates the reason categories (hard_bounce, complaint, unsubscribe, manual). This distinguishes it from sibling tools like add_suppression, remove_suppression, and suppress_many, which are all mutations rather than read-only lists.

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

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

The description gives explicit guidance: 'Check here first when someone reports not receiving email.' This tells the agent when to use the tool. It does not explicitly name alternatives or state when not to use it, so it falls short of a 5, but the 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?

There are no annotations, so the description carries the behavioral burden. It discloses that only in-use tags are returned, not all possible tags, and that counts are included. It also implies a read-only, non-mutating operation through the verb 'list' and the pre-application context.

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

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

Two sentences, no filler. The first sentence states the result and scope; the second explains why the tool matters. Every word earns its place.

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

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

For a zero-parameter list tool with no output schema, the description is complete: it states the output (tag names plus contact counts), the scope (workspace, in-use tags), and the practical reason to call it. An agent can confidently invoke it without further clarification.

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 no parameter documentation is needed. The schema already covers everything, and the description adds context about the returned data rather than inputs.

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

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

The description clearly states the resource ('tags in use in the workspace') and the returned data ('how many contacts carry each'). It also distinguishes itself from tag_contact by explaining this is the only way to inventory free-form tags before applying one.

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 an explicit use case: check existing tags before applying one. It explains why this tool matters ('Tags are free-form, so this is the only way to know what exists'). It does not name alternatives or negative cases, but no sibling is a direct alternative, so the guidance is sufficient.

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

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

No annotations are provided, so the description carries the behavioral burden. It makes clear the tool reads stored templates and surfaces their variable requirements, implying a non-mutating list operation. However, it does not explicitly state side-effect-free behavior or what payload to expect beyond templates and variables.

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

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

The description is two sentences with no redundancy. The first sentence states exactly what the tool does, and the second adds useful context about why templates matter without bloating the description.

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

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

For a zero-parameter, read-only listing tool with no output schema, the description sufficiently covers the main return concept: templates and their variables. It does not mention pagination or ordering, but that is not critical for this simple 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?

The tool has zero parameters, so parameter semantics are not a concern. The schema coverage is 100% and the description does not need to explain any inputs; baseline 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 uses a specific verb ('List') and resource ('stored email templates'), and adds a meaningful qualifier: it also returns the variables each template needs. This clearly distinguishes it from related template tools like render_template and send_template_email.

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

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

The description gives general advice to prefer templates over hand-composed HTML for sending, which implies the value of template usage but does not explicitly say when to call list_templates versus a sibling like render_template or send_template_email. The guidance is present but indirect.

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 meaningful awaiting_reply filter semantics, which goes beyond the boolean parameter name. However, it does not disclose the default when the flag is omitted, what the returned list contains beyond 'conversations', or ordering/pagination behavior; with no annotations available, those details are left for the agent to infer.

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

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

Two sentences, front-loaded with the action and resource; the second sentence earns its place by explaining the key flag and use case. 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 a simple optional-parameter list tool, the description gives enough to select and call it, especially for the primary awaiting-reply workflow. It could be more explicit about the default mode and response shape, but those are minor for this complexity.

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

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

Awaiting_reply is given a precise, human-readable definition (someone wrote to you and you haven't answered), which the bare boolean schema cannot convey. Limit is not mentioned, but its name plus integer min/max in the schema make its cap semantics inferable, so the description covers the non-obvious parameter.

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

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

Names the resource (email conversations/threads) and action ('List'), and adds that this is the tool to poll for pending replies. It does not explicitly contrast with list_emails or get_thread, but the thread-focused wording makes the intended resource clear.

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

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

Explicitly instructs to pass awaiting_reply=true to filter for threads where someone wrote and you haven't replied, and calls it the tool to poll when deciding what needs a response. It stops short of naming alternatives or exclusions, so it is context-rich but not a full routing guide.

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

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

No annotations are provided, so the description carries the behavioral burden. It adds useful semantics by explaining that topics relate to opt-out categories, and 'list' implies a read-only operation. However, it doesn't disclose what the response contains, whether topics appear as IDs or names, or any additional constraints.

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, purposeful sentences with no filler. The main action and resource are front-loaded, and the second sentence provides valuable usage context in minimal words.

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

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

For a zero-parameter, no-output-schema tool, the description is largely complete: it explains what the tool returns the list of and why that list matters in the broader email-sending workflow. The only minor gap is that it doesn't describe the expected output format, but this is low stakes for such a simple list 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?

The tool has zero parameters and the schema properties are empty, so there is nothing for the description to clarify. The description appropriately focuses on the conceptual meaning of the resource rather than inventing parameter behavior.

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 ('subscription topics') and action ('list'), and clarifies what a topic is: a category a person can opt out of individually. This gives the agent a precise idea of the tool's purpose and distinguishes it from generic list operations.

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

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

The description explicitly tells the agent when topics are relevant: pass a topic when sending marketing mail so recipients can unsubscribe selectively. It doesn't name sibling alternatives or state when not to use it, but the practical guidance is clear and actionable.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It does disclose the core output contents: delivery attempts, status codes, and errors. However, it does not mention pagination, ordering, time window for 'recent,' or what happens when no attempts exist. These are meaningful gaps for a listing tool.

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

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

The description is two tight sentences with no filler. The primary function and output contents are front-loaded in the first sentence, and the second sentence adds practical diagnostic value. Every word earns its place.

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

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

The description covers the essential purpose and output, but with no output schema and no annotations, more is needed. It does not explain the exact return shape, how 'recent' is bounded, how limit affects results, or error behavior. For a simple two-parameter list tool, this 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 description coverage is 0%, so the description must compensate. It does clarify that the resource is a 'webhook endpoint,' which gives meaning to endpoint_id. The optional 'limit' parameter is not described beyond its schema name and min/max constraints, so the description only partially compensates for the lack of schema descriptions.

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

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

The description clearly states a specific verb and resource: 'list recent delivery attempts for a webhook endpoint.' It also tells what the output contains ('status codes and errors') and gives a concrete diagnostic purpose, distinguishing 'we never sent it' from 'your endpoint returned 500.' This makes the tool's role unambiguous and distinct from the provided sibling tools.

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

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

The description provides a clear context for when to use the tool: diagnosing webhook delivery failures by inspecting delivery attempts. It says 'This is how to tell...' which is an explicit use-case signal. It does not enumerate exclusions or alternatives, but none of the sibling tools appear to cover webhook deliveries, so this is a minor gap.

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

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

With no annotations provided, the description carries the behavioral burden. It discloses that the tool does not start the broadcast, which signals a non-mutating preview operation, and describes what it evaluates: reach count and reputation gate status. This is sufficient for a simple preview 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?

Two sentences, no filler. The key behavioral facts are front-loaded, and every sentence contributes: one states the output, the other states the usage rule.

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

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

For a tool with one parameter, no output schema, and no annotations, this description is complete. It tells the agent what to expect (reach count and gate result), that it is safe in the sense of not starting the broadcast, and when to invoke it. Nothing critical is missing.

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

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

The schema has one unadorned 'id' parameter with 0% description coverage. The description mentions 'a campaign,' which implies the id is a campaign identifier, but it never explicitly states that the id parameter refers to the campaign ID. Some meaning is added, but the description does not fully compensate for the lack of schema documentation.

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

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

The description clearly states what the tool does: it reports how many contacts a campaign would reach and whether the reputation gate would permit sending. It also distinguishes itself from send-type tools by noting it is the only way to see campaign size 'without starting it.'

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 an explicit when-to-use directive: 'Always run this before sending.' It also explains why this is the right tool over alternatives by stating it is the only way to see size without launching. It does not name specific alternatives, but the usage context is clear.

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

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

With no annotations, the description carries the behavioral disclosure burden. It clearly states that the contact remains in the workspace and retains other audiences, suppression, and engagement history. It could additionally mention idempotency or behavior if the contact is not in the audience, but the main side-effect boundaries are well covered.

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

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

Two sentences, zero filler. The primary action is front-loaded, and the crucial distinction from delete_contact is placed immediately after, making the description easy to parse and act on.

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 tool with no output schema and no annotations, the description covers what the operation does, what it preserves, and the key alternative. Nothing essential is missing for an agent to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. The action sentence maps 'contact' to contact_id and 'one audience' to audience_id, which gives minimal semantic grounding, but it does not explain ID formats or how to obtain these values. This is adequate but not rich.

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

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

The description uses a specific verb and resource ('Take a contact off one audience') and immediately distinguishes itself from delete_contact. An agent can clearly tell that this operation is scoped to a single audience rather than deleting the contact.

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

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

It explicitly states when to use this tool (removing from one audience) and when not to ('To remove the person entirely use delete_contact'). The contrast between 'leaving a list and being forgotten' gives clear decision 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?

With no annotations, the description must carry the behavioral burden. It discloses the effect of removal and a meaningful risk related to hard bounces and AWS bounce-rate enforcement. Still, it does not clarify scope-dependent behavior, idempotency, or what happens if the suppression does not exist.

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

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

The description is concise and front-loaded with the primary action, followed by a relevant warning. Both sentences serve a purpose, though the hard-bounce sentence is grammatically awkward at the end ('AWS enforces on').

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

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

The core purpose and a key risk are covered, making the description mostly adequate for a simple two-parameter tool. However, it lacks guidance on the optional scope parameter, default behavior, and return value, leaving some gaps for an agent trying to invoke it correctly.

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

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

Schema description coverage is 0%, so the description should compensate by explaining parameters. It only refers to the address generically and says nothing about the scope parameter, leaving its semantics entirely to the schema enum. It adds little meaning beyond what the schema already 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 clearly states the action: removing a suppression so the address can be mailed again. It is specific enough to differentiate from adding or listing suppressions, though it does not explicitly reference sibling tools or frame itself as the inverse of add_suppression.

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 purpose implies when to use it—when an address should be re-enabled for mailing. It also provides a caution against carelessly removing hard-bounce suppressions, which is useful guidance. However, it does not explicitly mention alternative tools or give a direct when-not-to-use condition.

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

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

With no annotations, the description carries the full burden. It clearly discloses the non-sending behavior and the error behavior for missing variables. It does not describe the success return value, but the render behavior is well conveyed.

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, each adding necessary information: the action, the intended use case, and the error behavior. No filler or redundancy.

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

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

For a simple two-parameter tool with no output schema, the description covers the essential behavioral context: side-effect-free rendering, the use case, and error reporting. The only notable gap is the lack of an explicit success return description, but the render action implies the rendered output.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'values' and 'missing variables', which loosely maps to the variables parameter, but it does not explain that 'slug' identifies which template to render or describe the expected structure of the variables object.

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

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

The description uses a specific verb ('Render') and resource ('a template'), and explicitly states 'without sending', which clearly distinguishes it from sending tools like send_template_email. The purpose is immediately obvious.

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

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

The description gives clear intended usage: 'Use this to check your copy reads correctly before mailing a real person.' This establishes when to use it, though it does not explicitly name alternatives or state when not to use it.

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

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

Without annotations, the description carries the behavioral transparency burden, and it does add meaningful detail: it sets threading headers so the recipient's client groups the response with the existing exchange. It does not cover side effects, permissions, or failure modes, but the core behavior is clearly disclosed.

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

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

The description is three tight sentences: the action, the behavioral mechanism, and the routing guidance. Every sentence earns its place, with the core purpose front-loaded.

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

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

The description fully covers selection and the key threading behavior, which is the tool's differentiator. However, with no output schema and no annotation safety profile, it omits practical invocation details like response format, error behavior, and how to handle content/recipient fields.

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

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

Schema description coverage is only 33%, yet the description provides almost no parameter-level guidance. It alludes to the message being replied to but does not clarify how to populate to, subject, html, or text, so the description does not compensate for the schema's gaps.

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

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

The description clearly states a specific action ('Reply to a message, keeping it on the same conversation') and explains the mechanism that distinguishes it from a new email. It also explicitly positions the tool relative to send_email, making its purpose unambiguous.

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

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

It explicitly says to prefer this tool over send_email whenever answering something, providing a clear decision rule. This directly addresses when to use this tool versus the most likely sibling alternative.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It clearly discloses that the action cannot be undone and that it emails every contact in the segment, which are critical non-obvious behaviors. It does not cover permissions, rate limits, or response format, but the most important side effects are explicit.

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

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

Two sentences with no filler. The core action is front-loaded, and the warning plus prerequisite are included without redundancy.

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

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

For a two-parameter tool with no output schema and no annotations, the description covers the essential operational aspects: purpose, scheduling, scope, irreversibility, and the recommended alternative. The only notable gap is that the required id is not explicitly defined, but it is strongly implied by context.

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

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

The schema documents scheduled_at as an ISO 8601 timestamp and mentions 'omit to send now'; the description reinforces this scheduling behavior. However, the required id parameter is undocumented in both the schema and the description beyond implying it is the broadcast/campaign identifier. With only 50% schema description coverage, the description only partially compensates.

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 precise verb and resource: 'Send a campaign now, or schedule it with scheduled_at.' It also clarifies scope by noting it mails every contact in the segment, which distinguishes it from preview_broadcast and list_broadcasts.

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

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

It explicitly gives both usage modes (send now or schedule) and warns to run preview_broadcast first. The irreversible consequence is stated, providing clear guidance on when to use this tool versus previewing first.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the verified-domain prerequisite and the scheduling behavior. However, it does not mention irreversibility, delivery failure handling, or that scheduled emails can later be cancelled via a sibling 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 core action, followed by parameter guidance and a constraint. Every sentence earns its place and there is no 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 tool with six parameters and no output schema, the description covers the essential points: purpose, scheduling syntax, and sender-verification requirement. It is sufficient for correct invocation, though it could be stronger by explicitly pointing to send_broadcast for bulk campaigns and noting cancellation via cancel_scheduled_email.

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 the description mostly restates parameter details already present in the schema, such as scheduled_at relative phrases and the verified-domain constraint on from. It adds no new meaning for subject or text beyond the schema's minimal descriptions.

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

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

The description states a specific verb ('Send'), a resource ('transactional email'), and the immediate/scheduled modes. The word 'transactional' clearly distinguishes this tool from sibling tools like send_broadcast and send_template_email.

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

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

The description implies when to use it by qualifying the email as 'transactional' and by explaining scheduling, but it never explicitly names alternatives like send_broadcast or send_template_email, nor does it state when not to use this tool.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It does add a valuable behavioral detail: variable values are HTML-escaped on substitution, which is safety-relevant for user-supplied text. However, it omits other behavioral aspects such as sending side effects, delivery guarantees, permission requirements, or behavior when a template slug is invalid.

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

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

The description is extremely concise: two sentences with no filler. The core purpose is front-loaded in the first sentence, and the second sentence adds a genuinely useful safety note. Every word earns its place.

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

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

Given 6 parameters, 4 required, no output schema, and no annotations, the description is too thin. It explains the core action and variable escaping, but omits essential operational details like scheduling behavior, required parameter roles, error/response expectations, and when to choose this over sibling tools. An agent would need more information to invoke it confidently in all cases.

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

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

Schema description coverage is low at 33%, so the description needs to compensate. It adds one useful semantic fact: variable values are HTML-escaped, informing how the variables object is used. But it does not clarify the format or constraints for from, to, scheduled_at, or how subject override interacts with the template, leaving significant parameter meaning undocumented.

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

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

The description clearly states the action ('Send an email') and the resource ('a stored template'), which distinguishes it from the sibling send_email that presumably sends non-template emails. It does not explicitly name the sibling or describe its unique scope, but the template-based nature is specific enough to be useful.

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

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

No guidance is provided about when to use this tool versus send_email, send_broadcast, or render_template. The phrase 'built from a stored template' implies the primary use case, but there is no explicit context, exclusions, or alternative routing.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does reveal a key side effect: setting preferences can re-subscribe an opted-out person, which is exactly the kind of behavioral warning an agent needs. It doesn't mention merge-versus-replace semantics or return values, but the most important safety-related behavior is disclosed.

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

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

The description is two sentences with no filler. The primary action is front-loaded, and the cautionary note directly follows. Every word contributes to either defining the action or constraining its use.

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

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

For a two-parameter tool with no output schema, the description plus schema cover the core requirements: what it does, when to use it, and a critical safety warning. The main missing piece is whether the topics object replaces all preferences or merges with existing ones, which is not specified in either the schema or the description. Still, the tool is simple enough that this is not a severe gap.

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

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

Schema description coverage is 50%: the topics parameter includes an example and boolean semantics, while email relies on its 'format: email' attribute. The tool description adds 'which topics a person receives,' which maps to the topics parameter but does not exceed what the schema already conveys. Since the schema already explains the nested object well, a baseline score of 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Set which topics a person receives.' This clearly defines the tool's purpose and naturally distinguishes it from the sibling get_email_preferences, which is the read counterpart. The resource is precise enough that an agent can tell it apart from suppression or broadcast tools.

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

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

The description gives an explicit condition for use: 'Only do this when they have actually asked.' It also communicates a clear when-not by warning against 'silently re-subscribing someone who opted out,' tying the misuse to spam complaints. This is direct, actionable guidance that leaves little room for misinterpretation.

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 are absent, so the description carries the full burden, and it does disclose the core effect (those addresses will no longer be mailed) and the failure mode if skipped. However, it leaves important behavioral traits unstated: whether the operation is idempotent, whether it merges with existing suppressions, or what happens when the 10,000-item cap is exceeded. The description frames purpose more than behavior.

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

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

Two sentences with zero waste, and the core action is front-loaded ahead of the use-case framing. Minor issues: 'at once' is momentarily ambiguous (bulk quantity vs. rate limiting) and 'the path for' is a casual construction, but every sentence earns its place.

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

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

The description fully covers the 'why and when' of the tool, which is the most important context for a bulk-suppression operation. But with no annotations and no output schema, operational completeness suffers: parameter selection semantics (scope/reason) are absent, and edge-case behavior (duplicate emails, limit overflow, reversibility) is unknown. Adequate for a simple list-mutation tool, thin for one with two undocumented enums.

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%, and the description mentions no parameters. Only 'many addresses' loosely hints at the required emails array; the scope enum (all/transactional/marketing) and reason enum (manual/list_hygiene/unsubscribe) are completely unexplained, so an agent cannot determine correct values. The description fails to compensate for the schema's lack of parameter documentation.

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

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

States a clear bulk action ('Stop sending to many addresses at once') with a concrete resource (a list of addresses). The 'many at once' phrasing differentiates it from singular suppression siblings like add_suppression/remove_suppression, and the unsubscribe-list import framing adds specificity. It loses a point for never using the word 'suppress' and relying on the informal verb 'stop sending to', which is slightly imprecise.

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 concrete trigger scenario: importing another provider's unsubscribe list before a first campaign, plus a consequence warning ('Without it, everyone who already opted out there gets mailed again here'). This is clear context for when to invoke the tool, but it names no explicit alternative or when-not-to-use condition, stopping short of a 5.

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

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

With no annotations, the description carries the behavioral burden. It discloses non-obvious behaviors: tags are lower-cased, spaces become hyphens, VIP and vip are treated as the same tag, and tagging applies to the contact across all audiences. It does not address edge cases like unknown tags or idempotence, but the key behavioral traits are 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?

The description is four compact sentences, front-loaded with the primary action. Every subsequent sentence adds distinct value: tag definition, normalization behavior, cross-audience scope, and a usage recommendation. No wasted words.

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

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

For a three-parameter mutation tool with no annotations and no output schema, this description covers purpose, tag semantics, normalization, cross-audience effects, and a recommended prerequisite call. The main gaps are edge behaviors such as whether unknown tags are created automatically and how remove behaves for a non-existent tag, but the list_tags guidance reduces the practical risk.

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 0%, so the description must add meaning. It provides valuable semantics for tag values: they are flat labels, normalized by lower-casing and hyphenating spaces, and should preferably be drawn from list_tags. The mapping of add/remove to adding/removing tags is clear, though it doesn't explicitly discuss combining both parameters or obtaining contact_id.

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

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

The first sentence clearly states the action ('Add or remove tags') and the resource ('on a contact'). The additional contrast between tags and custom properties helps an agent distinguish this tool from property-editing tools like update_contact.

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

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

The description gives concrete workflow guidance: call list_tags first and reuse existing tags rather than inventing equivalents. It also implicitly warns against using tags where custom properties are intended. It does not explicitly name an alternative tool for custom property changes, but the guidance is otherwise 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?

With no annotations, the description carries the burden of behavioral disclosure, and it does disclose the most important trait: updates are merged rather than wholesale replacement. However, it does not state whether an unknown id is an error, whether the contact is created if absent, what response is returned, or what permissions are needed.

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 with no filler, and the key behavioral caveat—merge semantics—is front-loaded after the action. Every sentence adds 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 4-parameter tool with a nested attributes object, no output schema, and no annotations, the description leaves important context unstated: the required id is not mentioned, the meaning/effect of attributes versus top-level fields is unclear, and return/error behavior is absent. The merge note is useful but not sufficient for fully correct invocation.

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

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

Schema description coverage is 0%, and the description does not explain id, first_name, last_name, or the attributes object beyond the generic merge behavior. An agent must infer from field names and the nested object schema what each parameter does, so the description does not compensate for the missing schema descriptions.

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

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

The first sentence 'Update a contact' names a specific action and resource, and the verb distinguishes it from sibling contact operations like add_contact, get_contact, and delete_contact. The follow-up about merging adds semantic precision, though it does not explicitly contrast with any sibling.

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

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

The description gives no guidance on when to choose update_contact over alternatives, nor does it mention prerequisites such as first retrieving an existing contact. The merge note implies a partial-update workflow, but it never says 'use this instead of delete+add' or 'use get_contact first to see existing fields'.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does add meaningful behavior beyond the name: 'now instead of waiting for the background monitor.' However, it does not mention whether the check triggers side effects, whether it is idempotent, or what result the caller should expect.

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

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

The description is a single sentence with no filler. The key contrast ('now instead of waiting for the background monitor') is front-loaded and each word earns its place.

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

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

For a simple one-parameter tool, the description covers the core operation and timing, but it does not explain what the tool returns, whether success is indicated, or what 're-check' means in terms of the background monitor. The lack of an output schema makes this gap more noticeable, though the operation itself is straightforward.

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

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

The schema has one required 'id' parameter with no description, and schema coverage is 0%. The description only implies that the id refers to a sending domain, but it does not explicitly explain what id should be passed, where to obtain it, or what format it takes. This leaves the agent to infer a critical input.

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

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

The description uses a specific verb ('Re-check') and resource ('a domain's DNS records'), and immediately distinguishes the action from the background monitor. This clearly differentiates it from siblings like add_sending_domain or list_sending_domains.

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

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

The description gives clear context: use this tool when you want an immediate DNS re-check rather than waiting for the background monitor. It does not explicitly name alternatives or exclusion cases, but the timing contrast provides sufficient selection guidance.

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