Ranla

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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=true, and openWorldHint=false, covering the safety profile. The description adds no extra behavioral context such as permission requirements, effect on future sends, or rate limits. It does not contradict the annotations.

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

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

A single front-loaded sentence with no wasted words. It is terse but efficient, though arguably under-specified given the tool's side effects.

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

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

With an output schema and full parameter descriptions already present, the description need not explain return values. However, it omits usage context and the operational meaning of suppression, leaving minor gaps for a mutation tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no syntax or format details beyond what the schema already provides for email and reason.

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: 'Add an address to the suppression list.' It is clearly an additive operation, distinguishable from list_suppressions and remove_suppression, but it does not explicitly name or contrast those siblings.

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

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

No when-to-use, when-not-to-use, or alternative-tool guidance is provided. The agent must infer that this is for suppressing an address and that remove_suppression handles the reverse 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?

Annotations already declare destructiveHint=true and openWorldHint=true; the description adds value beyond them by explaining that the write happens against an external provider using a stored dashboard connection and that registrar credentials are never passed through. It could go further by warning that this mutates live DNS at the provider, but the auth-model disclosure is substantive.

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

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

Two tight sentences, front-loaded with the action and resource, followed by the prerequisite. Every clause carries information; nothing is redundant.

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

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

With an output schema present, return values need no explanation, and the description covers the two required inputs plus the auth prerequisite. It omits any mention of failure modes (e.g., provider not yet connected) but is otherwise sufficient for a two-parameter 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 100%, so both parameters (domain id/name and the provider enum) are already fully documented in the schema. The description's provider list mirrors the enum without adding format or lookup semantics, so baseline 3 applies.

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

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

States a specific verb and resource ('Create the sending domain's DNS records') and enumerates the supported providers, making it clearly distinct from generic sibling names like create_domain or verify_domain. It stops short of explicitly naming which sibling to prefer, so it does not reach the top tier of explicit differentiation.

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

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

Gives a concrete prerequisite ('Connect the provider in the dashboard first') and clarifies the auth route, which is genuinely actionable ordering guidance. It does not state when to choose this over verify_domain, so it lacks explicit exclusions/alternatives.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the mutation profile is covered. The description adds that cancellation applies only to scheduled sends before dispatch, which is useful context, but it does not disclose reversibility, idempotency, or the error behavior for already-sent emails.

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

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

One sentence, front-loaded with the action and resource, no filler. 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?

Output schema exists and annotations carry the safety profile, so the description need not explain return values. For a one-parameter cancel operation it is nearly complete, with only edge-case behavior (already-sent, repeated cancellation) left unaddressed.

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

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

Schema description coverage is 100%, so the single 'id' parameter is fully documented ('Email id (msg_…) of a scheduled send') including its format. The description repeats the scheduled-send qualifier but adds no new syntactic or semantic detail beyond the schema.

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

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

Specific verb+resource: 'Cancel a scheduled email', with the scope constraint 'before it sends' clarifying that only pre-send scheduled emails are affected. It is distinguishable from siblings like send_email or get_email, though it does not explicitly name them.

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

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

The phrase 'before it sends' implies the applicable condition, but there is no explicit when-to-use guidance, no statement of what to do if the email has already been sent, and no routing to sibling tools. Usage must be inferred.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds genuinely new context beyond them: that a newly created domain is not production-ready until DNS is applied and verified. It doesn't cover auth requirements or whether creation is idempotent, but the lifecycle caveat is a meaningful addition.

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

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

Two short sentences, zero filler, with the core action front-loaded and the prerequisite caveat immediately after. 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?

An output schema exists, so return values need not be explained. The description covers the action and the critical post-creation prerequisite, which is the main thing an agent needs to avoid a failed production send. It is only slightly thin on the inbound_enabled capability, which is arguably a distinct mode of the tool.

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

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

Schema description coverage is 100%, so both parameters (name, inbound_enabled) are already documented in the schema. The description adds only the framing of 'sending domain' and says nothing about the inbound_enabled toggle, so it does not meaningfully extend parameter meaning beyond the structured fields. Baseline 3 applies.

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

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

States a specific verb and resource ('Add a sending domain') with enough scope to distinguish it from siblings like apply_domain_dns, verify_domain, get_domain, and list_domains. An agent can tell immediately that this is the creation step of the domain lifecycle.

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 establishes the workflow context – DNS must be applied and verified before production sends – which implicitly positions apply_domain_dns and verify_domain as the required follow-up steps. It gives clear timing guidance but never names those alternatives explicitly or states 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?

Annotations declare readOnlyHint=false and destructiveHint=false, so the write-but-non-destructive profile is already covered. The description adds genuinely useful behavioral context beyond that: the created template is a draft, not immediately sendable, and must be published first. It does not mention duplicate-name/alias handling or permissions, but the key state transition 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?

Two short sentences, zero padding, with the core action (create draft) and the format scope front-loaded before the publish prerequisite. 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?

An output schema exists, so return values need no explanation here, and annotations cover the safety profile. The description supplies the essential lifecycle fact (draft must be published before sending), leaving only minor items like duplicate alias behavior unaddressed.

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

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

Schema description coverage is 100% and the schema already documents all six parameters including the html/blocks enum. The description's 'html or blocks format' merely echoes the format parameter, adding no syntax, default, or validation meaning beyond the schema, so the baseline 3 applies.

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

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

States a specific verb+resource (create an email template) and narrows the artifact to a 'draft' in html or blocks format, which separates it from publish_template, get_template, and list_templates. It stops short of naming a sibling explicitly, so it is clear but not fully differentiated.

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

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

'Publish it before sending with it' gives a concrete follow-up workflow step and implicitly frames this as the first stage of a two-step create/publish flow, distinguishing it from publish_template. There is no explicit when-not or alternative-selection guidance, 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?

Annotations already declare the write/openWorld/non-destructive profile, lowering the bar. The description adds a genuinely useful behavioral fact beyond that: the signing secret is returned and shown only once. It omits auth requirements, rate limits, and duplicate-endpoint behavior, keeping it from a 5.

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

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

Two short sentences, front-loaded with the core action and followed immediately by the key return-value caveat. 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?

With an output schema present and annotations covering the safety profile, the description needn't restate return structure. It still contributes the critical "shown once" secret semantics, which the schema would not convey. Complete enough for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents url and the events list (including the "all of them when omitted" default). The description adds no parameter-level detail, making the baseline 3 correct.

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

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

States a specific verb and resource ("Create a webhook endpoint"), which naturally separates it from delete_webhook and list_webhooks. It stops short of explicitly naming a sibling or differentiating itself, so it lands just under a 5.

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

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

The description offers no when-to-use guidance, no prerequisites, and no pointer to related tools such as send_test_webhook_event or list_webhooks. An agent gets no help deciding when this tool is the right call versus its siblings.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and openWorldHint=false, so the safety classification is covered. The description adds nothing beyond that—it does not state that deletion is permanent, whether in-flight deliveries are affected, or what happens to associated events, which is the value a destructive tool's description should add.

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

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

A single short sentence that front-loads the action and resource with no filler. It is efficient, though almost to the point of under-specification rather than tight prose.

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?

An output schema exists so return values need not be explained, and the input schema is fully documented. However, for a destructive operation the description should at minimum signal permanence or side effects; it is adequate but leaves real gaps.

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

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

Schema description coverage is 100% with a single 'id' parameter already documented as 'Webhook id'. The description only restates 'by id' and adds no format, prefix, or sourcing guidance, so the baseline 3 applies.

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

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

The description names a specific verb+resource combination ('Delete a webhook endpoint by id'), which is unambiguous and clearly distinct from create_webhook and list_webhooks. It stops short of explicitly differentiating siblings, but the action itself leaves no ambiguity.

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

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

There is no guidance on when to use this versus alternatives, no prerequisites (e.g., required permissions), and no warning about irreversibility. The agent must infer everything from the name alone.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds a genuinely useful caveat with 'best-effort', signaling the metrics may be approximate or incomplete, but says nothing about aggregation scope, latency, or account-level vs domain-level resolution.

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

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

A single sentence with the caveat ('best-effort') and the scope ('recent sends', window size) front-loaded. There is no filler and nothing redundant.

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

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

For a one-optional-parameter, read-only tool with full schema coverage, an output schema, and annotations covering the safety profile, the description supplies the two things the structured fields cannot: the accuracy caveat and the fact that results cover 'recent sends'. The missing usage guidance is a minor gap given the tool's simplicity.

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

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

Schema description coverage is 100% and the enum values and default (30d) are fully documented in the schema. The description only restates '7d or 30d window' without adding meaning such as what a 30d look-back actually aggregates, so the baseline of 3 applies.

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

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

States a specific verb and resource: 'Fetch deliverability metrics for recent sends', with the scope narrowed to a 7d/30d window. No sibling tool overlaps with deliverability reporting, so the purpose is unambiguous, though it does not explicitly differentiate itself from neighbors like get_domain or list_emails.

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 when-to-use guidance, no prerequisites, and no alternatives. It mentions the two windows but does not say which to pick or when this tool is the right call versus inspecting a specific domain or email.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, covering the safety profile. The description adds useful context beyond them by disclosing what the call surfaces (DNS records and verification status), which helps an agent judge the tool's richness and cost.

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

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

One front-loaded sentence with zero filler; the lookup key is stated before the returned content. 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?

With only one parameter, full schema coverage, an output schema, and annotations covering safety, the description carries enough to select and invoke the tool correctly. Only minor operational notes (e.g., behavior when the domain is not found) are absent, which is acceptable here.

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

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

Schema description coverage is 100%, with the single parameter documented as 'Domain id or name (example.com)'. The description's 'by id or name' mirrors the schema without adding format, validation, or lookup-precedence detail, so the baseline 3 applies.

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

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

The description states a specific verb (get), a specific resource (sending domain), and the lookup keys (id or name), and it notes the returned payload (DNS records and verification status). It contrasts implicitly with list_domains by emphasizing singular lookup, though it never names a sibling explicitly.

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

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

Usage is only implied: an agent can infer this is for fetching a single domain when the identifier is known. There is no explicit when-to-use vs. list_domains/get_deliverability guidance and no stated prerequisites, but the purpose does not mislead.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds nothing behavioral beyond that, only restating the id prefix that also appears in the schema, so it meets the minimum bar without adding 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?

A single front-loaded sentence that names the verb, the resource, the selector, and the id format with zero filler. Nothing in it is redundant within the description itself.

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

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

For a trivial one-parameter read, an output schema exists, annotations cover safety, and the parameter is fully documented, so the description is essentially sufficient. The only gap is that it does not distinguish this tool from get_received_email for an agent choosing between them.

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

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

Schema description coverage is 100% and the single parameter is fully documented with the same msg_… format hint the description repeats. Per the rubric, a fully-covered schema sets the baseline at 3, and the description adds no extra meaning.

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

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

States a specific verb and resource ('Get a single email') plus the key selector ('by public id (msg_…)'), so an agent knows this is a single-item fetch rather than a list. It does not differentiate itself from the sibling get_received_email, which is the main residual ambiguity.

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

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

Usage is only implied: the mention of 'by public id' signals it is the tool to call when you already hold a msg_ id, but there is no explicit when-to-use, no prerequisite statement, and no routing against list_emails or get_received_email.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds only the return content (headers and body), not pagination, body format, or error behavior for an unknown id; with annotations carrying the profile this is a modest addition.

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

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

One short sentence, front-loaded with the verb and resource, and the payload clause adds information rather than padding. No waste.

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

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

With an output schema present, the description need not describe return structure, and the annotations cover the safety profile. What remains thin is routing context – nothing says when to choose this over get_email or list_received_emails – but for a simple one-param read the description is nearly sufficient.

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

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

Schema description coverage is 100% and the single 'id' parameter is documented as 'Received email id'. The description adds no syntax, format, or source guidance beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('Get one inbound email') and enumerates the payload ('headers and body'), which tells the agent what comes back. It does not differentiate itself from the sibling get_email, leaving the inbound-vs-outbound distinction implicit in the word 'received' rather than explicit.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as list_received_emails or get_email. The agent must infer from the name alone that this is the single-item lookup counterpart to the list tool.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, covering the safety profile. The description adds no behavioral context beyond that — nothing about failure modes when the id/alias is unknown, or about draft vs published template 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?

A single eight-word sentence, front-loaded with the verb and resource. Every word earns its place; nothing is padded or redundant.

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

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

For a simple single-record read with an output schema, full parameter documentation, and annotations covering safety, the definition is nearly complete. The only gap is the absence of any routing hint toward list_templates or note on alias resolution, which is minor here.

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

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

Schema description coverage is 100% and both parameters are documented in the schema, including that alias is an alternative to id. The description's 'by id or alias' merely restates that, adding no format or precedence detail. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Get') and resource ('template') and clarifies the lookup key ('by id or alias'). This distinguishes it from list_templates and create_template, though it does not explicitly name those siblings. Clear and unambiguous, but not maximally differentiated.

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

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

There is no guidance on when to use this tool versus list_templates, nor on prerequisites such as whether the alias must be published. The agent must infer usage entirely from the name and schema.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered without description help. The description adds only the account-scoping fact; it says nothing about pagination behavior or result size limits, which would be the useful extra context given the cursor parameter.

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

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

A single short sentence with no filler and the resource stated up front. It is efficient, though arguably too terse for a paginated list tool.

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

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

An output schema exists, so return values need not be explained, and all parameters are documented in the schema. What is missing is any acknowledgement of paging behavior or the relationship to domain-management siblings, leaving the definition minimally viable.

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

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

Schema description coverage is 100%, so all three parameters (limit, cursor, inbound_enabled) are already fully documented in the schema. The description adds no parameter-level detail, which makes the baseline 3 appropriate.

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

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

The description states a specific verb+resource ('List sending domains') scoped to 'this account', which is enough to distinguish it from get_domain and create_domain by inference. However, it never explicitly contrasts itself with those siblings, so an agent must rely on the naming convention rather than the text.

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

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

There is no statement of when to use this tool versus get_domain (single domain) or list_emails, and no mention of pagination workflow despite the cursor parameter. Usage is only implied by the verb 'List'.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is structured data. The description adds only the scoping detail that results are limited to mail sent from this account; it says nothing about ordering, time window behind "recent", or pagination behavior beyond what the schema implies.

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

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

A single short sentence with no filler and the resource front-loaded. It is efficient, though it is lean enough that there was room to add scoping detail without bloat.

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

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

For a low-complexity, zero-required-parameter read tool with full schema coverage and an output schema, the description is largely sufficient — return shape and pagination are covered elsewhere. The one soft gap is that "recent" is never quantified.

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

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

Schema description coverage is 100%, and limit (page size 1–100) and cursor (opaque next-page cursor) are both documented in the schema. The description contributes no additional parameter meaning, so the baseline 3 applies.

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

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

Specific verb+resource ("List recent emails") with a scope qualifier ("sent from this account") that implicitly separates it from siblings like list_received_emails and get_email. It does not name those siblings directly, so differentiation is inferred rather than stated.

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

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

The phrase "sent from this account" implies usage (outbound mail listing) but the description never states when to use this tool versus list_received_emails, get_email, or get_received_email. It offers implied context only, with no explicit alternatives 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?

Annotations already declare readOnlyHint=true, openWorldHint=false, destructiveHint=false, establishing this is a safe read. The description adds the domain-scoping constraint but no pagination behavior, ordering, or empty-result semantics beyond what the schema hints. With annotations covering the safety profile, this is adequate but not rich.

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

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

A single, front-loaded sentence with no waste. However, at this brevity it could afford one more clause to route the agent or clarify scope, so it's efficient but slightly under-informative.

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?

Output schema exists, so return values needn't be described, and annotations cover safety. What's missing is differentiation from list_emails and any pagination or ordering context. For a list tool with a rich schema and annotations, this is minimally complete but leaves the sibling-routing 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 100%, so limit, cursor, and domain are fully documented in the schema. The description adds no syntax or format detail beyond what's already provided. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb (List) and resource (inbound emails) with a scope qualifier (domains with inbound enabled). Clear what it does, though it doesn't explicitly differentiate from sibling list_emails, which presumably lists outbound/sent emails. An agent can infer the inbound/outbound split, but it's not spelled out.

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 'on domains with inbound enabled' implies usage context (only meaningful when inbound is configured), but there's no explicit when-to-use vs alternatives. It doesn't say to use get_received_email for a single message or how this differs from list_emails. Guidance is implied rather than stated.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered without description help. The description adds nothing beyond this — no note on pagination behavior, filtering semantics, or result ordering — so it does no work the structured fields don't already do.

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

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

A single front-loaded sentence with zero filler or redundancy. It is efficient, though the brevity edges toward under-specification for a paginated list operation.

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 output schema covers return values and the annotations cover safety, so the remaining burden is light. However, the description omits pagination and filter behavior implied by the cursor/limit/email parameters, leaving it merely adequate for a low-complexity read tool.

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

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

Schema description coverage is 100%, so all three parameters (email, limit, cursor) are fully documented in the schema. The description adds no parameter meaning beyond that, making the baseline 3 appropriate.

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

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

States a specific verb ('List') and resource ('suppressed recipient addresses'), which is clear enough to distinguish it from add_suppression and remove_suppression by name alone. It stops short of an explicit sibling comparison, but the read vs. write distinction is unambiguous.

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

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

No guidance on when to use this tool versus alternatives, no mention of prerequisites, and no exclusions. The agent must infer that this is the read counterpart to add_suppression/remove_suppression and that pagination via cursor is expected.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds nothing further — no pagination behavior, no mention that the cursor drives paging, and no note on default ordering or result size.

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

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

A single short, front-loaded sentence with no padding or wasted words. It is efficient, though its brevity borders on under-specification rather than true conciseness.

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

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

Output schema exists, so return values need no explanation, and annotations plus the schema cover safety and parameters. Still missing is positioning against the many sibling list/get tools, which an agent needs to choose correctly.

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

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

Schema description coverage is 100%, with limit, cursor, and status fully documented and an enum on status. The description adds no meaning beyond the schema, so the baseline of 3 applies.

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

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

States a clear verb+resource ('List email templates'), so an agent knows it enumerates templates rather than fetching one. However, it is essentially a restatement of the name/title and adds only the word 'email', with no differentiation from siblings like get_template, list_emails, or create_template.

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

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

There is no guidance on when to use this versus get_template (single template) or list_emails, and no mention of the filtering behavior implied by the status enum. The agent must infer usage entirely from the tool name.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered without the description doing any work. The description adds only the 'for this account' scoping constraint and says nothing about result limits, ordering, or pagination cost beyond what the schema already carries.

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

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

A single front-loaded sentence with zero filler; the resource and scope are stated before anything else and nothing redundant is included.

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?

An output schema exists, so return values need not be explained, and the annotations carry the safety profile. The definition is complete enough to invoke correctly, though pagination expectations and the account-scoping boundary could have been made more explicit.

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

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

Schema description coverage is 100%, so both limit and cursor are fully documented in the schema. The description adds no format, default, or range detail on top of that, so the baseline 3 applies.

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

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

Clear verb + resource ('List webhook endpoints') with an account scope qualifier. It is readily distinguishable from create_webhook, delete_webhook, and send_test_webhook_event, but the description never names those siblings or contrasts itself with them.

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

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

Usage is only implied by the verb 'List'; there is no explicit when-to-use, when-not-to-use, or alternative routing. For a simple account-scoped listing this is adequate but leaves the agent to infer that this is the enumeration counterpart to create_webhook/delete_webhook.

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

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

Annotations declare a non-read-only, non-destructive, closed-world write. The description adds a crucial behavioral fact: publishing creates an immutable snapshot version, which informs the agent about versioning side effects. It does not cover auth, rate limits, or what happens to previous versions, but it meaningfully extends the annotation coverage.

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

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

Single sentence, front-loaded with the action and its key effect. 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?

With an output schema present and annotations covering safety, the description supplies the essential purpose and the immutability consequence. It could clarify the id vs alias requirement (both optional in schema) or label usage, but the schema descriptions likely suffice for invocation.

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

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

Schema description coverage is 100%, so parameter meanings are fully documented in the schema. The description adds no additional semantics for id, alias, or label. Baseline 3 applies.

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

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

States a specific verb 'publish' and resource 'template', plus the key effect: 'snapshotting an immutable version for sends'. This distinguishes it from create_template (creation) and get_template (retrieval) without needing the schema.

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

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

No explicit when-to-use or alternatives are given. The phrase 'for sends' implies the purpose (making a template sendable), but an agent must infer that this is the step after create_template and before send_email. No exclusions or prerequisites are stated.

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

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

Annotations already declare destructiveHint=true and openWorldHint=true, so the safety profile is covered. The description adds genuine value by stating the side effect that the run resumes, but it says nothing about irreversibility, required permissions, or what happens if the approval is stale.

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

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

A single, front-loaded sentence with no wasted words; the action and its effect are both immediately visible. It is appropriately sized for a one-parameter tool.

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

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

An output schema exists, so return values need not be described, and the single required parameter is covered by the schema. For a simple approve-and-resume mutation, the description is nearly complete; only the reversibility/permission behavior is unaddressed.

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

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

Schema description coverage is 100% and the single messageId parameter is fully documented in the schema, including where to obtain it. The description adds no parameter-level meaning beyond that, so the baseline of 3 applies.

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

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

The description names a specific verb and resource ("Approve a pending Ranla approval") and adds the consequential effect ("resume the run"), which clearly separates it from the sibling ranla_reject. It stops short of explicitly naming the alternative, so it is clear but not fully sibling-differentiating.

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

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

The phrase "pending Ranla approval" hints at the precondition, but there is no explicit when/when-not guidance and no reference to the counterpart ranla_reject. The agent must infer that reject is the sibling for the opposite decision.

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 goes well beyond the destructive/open-world annotations by explaining the approval-card model, pendingApproval plus ranla_approve, and which commands are irreversible or require sign-off. It also discloses side effects and constraints such as "removed cannot be undone," "delete ... for good," browser tasks stopping at a confirm step, and the rule never to enter passwords or card fields.

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

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

The core setup is front-loaded, but the description is an enormous command catalog and is not concise in practice. It also redundantly states that "help <noun>" lists every field and then enumerates every command and field anyway, which makes the definition very long and hard for an agent to scan.

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

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

Given the tool's complexity, the description is remarkably complete: it covers command grammar, the approval return path, irreversible behavior, help discovery, and per-command inputs. Since an output schema exists, the lack of a separate return-value section in the description is not a 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 already 100%, but the description adds substantial meaning: command is "<noun> <verb>" and input holds that command's fields, and every command entry documents its specific fields. The help <noun> convention further clarifies how to discover fields for any noun.

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 gives a specific verb and resource: "Run one of Ranla's commands in this account," and the command grammar plus catalog make the dispatcher role clear. It explicitly distinguishes ranla_command from ranla_message and ranla_approve, but it does not explain its relationship to the many other sibling tools such as add_suppression, create_template, or list_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?

There is explicit routing for strategy/research to ranla_message and for pending approvals to ranla_approve, and many individual commands include when-to-use guidance such as reading ad copy before rewriting it. However, the tool description never explains when to use this broad dispatcher versus the numerous specific sibling tools that cover overlapping domain, template, suppression, email, and webhook operations.

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

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

Annotations already declare readOnly/non-destructive/non-open-world, so the safety profile is covered. The description adds real behavior beyond that: results are ordered newest page first and older pages are reached via the before cursor, plus it surfaces that approvals appear inline and route to ranla_approve.

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

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

A single dense sentence front-loads the verb and resource, the parenthetical enumerates content, and the trailing clause covers pagination. No filler and nothing misplaced.

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

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

For a two-parameter read tool with an output schema, the description covers what the thread holds, the ordering, and how to page backward, so an agent has what it needs. Only explicit sibling routing and any auth/permission notes are 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 coverage is 100%, so the baseline is 3, but the description adds meaning the schema does not fully convey by tying the output field earlierBefore to the input parameter before, clarifying the pagination contract between the two fields.

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 ('Read') and resource ('a Ranla thread') and enumerates what the thread contains (role, text, tools used, artifacts by id, approvals). An agent can distinguish it from a list tool, though it never explicitly names ranla_list_threads or ranla_open_thread as 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?

It gives pagination guidance ('Pass earlierBefore as before for older messages') which is useful procedural context. However, it never says when to reach for this tool over ranla_list_threads or ranla_open_thread, so selection between siblings is left to inference.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds the genuinely useful fact that results span threads rather than being scoped to one thread, but says nothing about ordering, limits, or whether the list is user-scoped.

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

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

A single seven-word sentence with no filler, front-loading the verb and the scoping constraint. Nothing is wasted.

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

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

An output schema exists, so return values need no explanation, and with zero parameters there is little else to specify. Only minor gaps remain around result scope and ordering.

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

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

Zero parameters, so the baseline is 4. Nothing in the schema needs explanation and the description correctly does not invent parameters.

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

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

Specific verb (List) plus resource (pending Ranla approvals) and scope (across threads). This distinguishes it from ranla_list_threads and the action tools ranla_approve/ranla_reject, though it never names a sibling explicitly.

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

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

No statement of when to use this versus ranla_list_threads or ranla_get_thread, and no prerequisites. The only guidance is implied by the word 'pending'.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds useful non-annotation behavior: result ordering, the compact shape of each row, and the cursor flow from the response's nextBefore into the before parameter.

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 with the list/ordering information front-loaded, followed by pagination and routing instructions. No filler and every clause carries information.

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

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

An output schema exists, so the description need not enumerate return values; instead it usefully cross-references nextBefore from the output back to the before input. For a 0-required-param read tool with annotations covering safety, nothing needed to call it correctly 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 coverage is 100%, so both parameters are already documented, but the description adds meaning the schema does not: it explains that nextBefore from a prior response is what feeds the before parameter, turning two isolated params into a coherent pagination loop.

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

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

States a specific verb and resource ('List Ranla chat threads'), bounds the scope ('for this account'), and specifies ordering ('most recent first') plus the projected fields. It is clearly distinguishable from ranla_get_thread, which is named explicitly for the single-thread case.

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 guidance: how to paginate ('Pass nextBefore as before for older threads') and which sibling to use to read an individual thread ('Read one with ranla_get_thread'). It does not state when-not to use this tool, but the routing 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?

Beyond the annotations (readOnlyHint=false, destructiveHint=true, openWorldHint=true), the description discloses the blocking/waiting semantics, the artifact and pendingApproval return shapes, and the concrete 15-minute timeout behavior with running:true plus the follow-up path via ranla_get_thread. That timeout and follow-up contract is not derivable from annotations and is exactly what an agent needs to handle a long turn.

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

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

Four sentences, front-loaded with the action, then usage, then return shape, then the timeout edge case. Every sentence carries distinct information and nothing is repeated.

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

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

For a mutating, open-world tool with annotations and an output schema, the description covers when to use it, what it returns, and the async timeout path. The only gap is that it does not state that omitting threadId starts a new thread, leaving the optional-parameter behavior to inference.

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

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

Schema description coverage is 100%, so text and threadId are already documented in the schema (including the pointer to ranla_open_thread). The description adds no parameter-level detail and never mentions threadId or what happens when it is omitted, so the baseline 3 applies.

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

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

The description opens with a specific verb+resource ('Send a message to Ranla and wait for the turn') and scopes the tool via 'strategy and anything that changes the account.' It implicitly separates itself from ranla_command but never names that sibling, so an agent must infer the boundary.

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

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

'Use for strategy and anything that changes the account' gives clear positive selection criteria, and the closing sentence routes the agent to ranla_get_thread for late answers. There is no explicit 'do not use when...' statement or named alternative for simpler operations, so the boundary with ranla_command is left implicit.

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

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

Annotations already declare idempotentHint=true, openWorldHint=false, and non-destructive. The description adds that the thread is "durable" and states the return shape, which is useful, but adds little behavioral depth beyond the annotations (e.g., no mention of what happens if threadId is invalid, no auth notes).

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

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

A single efficient sentence that front-loads the core action and appends return shape. Nothing redundant or padded.

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

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

An output schema exists, so return shape needn't be spelled out at length, though it is. For a simple 2-param, 0-required tool with rich annotations, the description is largely complete; the only gap is interaction semantics when both params are provided.

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 both parameters are documented in the schema with descriptions, so baseline is 3. The description repeats the default title "MCP" but adds no semantics beyond what the schema already provides, such as precedence when both title and threadId are supplied.

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 or create) and resource (durable Ranla thread), making the upsert semantics clear. It distinguishes itself from ranla_message and ranla_get_thread by the "find or create" framing, though it doesn't explicitly name 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?

Usage is implied by the find-or-create semantics: use when you have no thread yet, or want to reuse one. But there's no explicit when-to-use vs alternatives like ranla_get_thread or ranla_message, and no exclusions stated.

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

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

Annotations already declare the mutation profile (readOnlyHint=false, destructiveHint=true, openWorldHint=false), so the description's job is narrower. It still adds real value by disclosing the post-condition — the run resumes — which annotations cannot express. It omits reversibility, staleness/error behavior, and any permission requirements, keeping it short of a 5.

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

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

A single front-loaded sentence pairing the action with its effect. No filler, no restatement of the title, and the behavioral consequence is placed where it will be read 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?

An output schema exists, so return values need not be explained, and the one parameter is fully covered. Still, for a destructive mutation it should say more about failure modes — already-resolved approvals, whether the rejection is reversible, and who can reject — leaving it adequate but with clear gaps.

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

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

Schema description coverage is 100% and the single messageId parameter is already documented in the schema, including its source (ranla_list_approvals or a pendingApproval result). The description adds no format, validation, or sourcing detail beyond that, so the baseline 3 applies.

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

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

States a specific verb ('Reject') and a specific resource ('a pending Ranla approval'), plus the condition under which rejection is valid. It implicitly contrasts with the sibling ranla_approve, but never names it, so an agent must infer the pairing rather than being told.

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

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

The word 'pending' supplies the precondition for use, implying the agent must have an unresolved approval (obtained via ranla_list_approvals/ranla_get_thread). However, there is no explicit when-not guidance, no mention of the approve alternative, and no statement about what happens if the approval is already resolved or expired.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, which tell the agent this is an irreversible-style mutation. The description adds nothing behavioral beyond restating the removal action - no note on irreversibility, auth requirements, or behavior when the target is absent.

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

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

A single front-loaded sentence with zero filler. It is efficient, though the brevity comes partly at the cost of the usage and behavioral context noted elsewhere.

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

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

An output schema exists, so return values need not be explained, and both params are fully documented in the schema. For a destructive tool it is still thin - nothing about irreversibility or missing-target behavior - leaving it only minimally adequate.

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

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

Schema description coverage is 100% and the schema already documents both id and email, including the 'alternative to id' relationship. The description's 'by id or email address' repeats the schema rather than adding format or constraint detail, so the baseline 3 applies.

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

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

States a specific verb (remove) and resource (suppression), and the id/email targeting clarifies scope. It is distinguishable from add_suppression and list_suppressions by the verb, though it does not explicitly name those siblings.

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

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

The description gives no when-to-use context, no exclusions, and no pointer to alternatives. It does not tell the agent when removal is appropriate versus using list_suppressions to inspect first, nor any prerequisites.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, and openWorldHint=true, so the risky/irreversible nature of a live external send is covered structurally. The description adds scheduling behavior and the cancel_email counterpart, but says nothing about deliverability consequences, rate limits, or what an outbound send does to suppression/opt-out state. Adds some value over annotations, not a lot.

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

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

Three short sentences, zero filler, and the core action is front-loaded ahead of the mode conditions and the scheduling escape hatch. Each clause carries distinct operational information.

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

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

With an output schema present, return values need not be described, and the schema carries the 17 parameters, sandbox-sender rule, and idempotency behavior. The description covers action, content modes, and scheduling, which is sufficient for correct invocation, though it omits any note on failure behavior or prerequisites like verified domains.

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

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

Schema description coverage is 100%, so per-parameter meaning is already documented in full and the baseline is 3. The description reinforces the cross-cutting rule that subject is optional when a template is used, but that relationship is already stated in the subject and html/text schema descriptions, so it adds little beyond the schema.

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

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

States a specific verb and resource (send an email) and immediately qualifies the two content modes: subject + html/text, or a published template_id/template_alias with variables. That is enough to separate it from siblings like create_template, publish_template, and send_test_webhook_event without opening any schema.

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

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

Gives conditional usage for the two send modes and explicitly names the alternative for the deferral case ('Set scheduled_at to send later (cancel with cancel_email)'). It stops short of when-not-to-use guidance, such as preferring a template over inline bodies or preconditions on domain verification, which is left to the schema.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the write-but-not-destructive profile is covered. The description adds that events can be delivered to subscribed endpoints, a real side effect, but 'Optionally deliver' sits awkwardly against the schema's default-true 'deliver' flag, leaving the default behavior ambiguous.

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

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

Two compact sentences with the core action front-loaded and the endpoint tucked into parentheses rather than padding the opening. No wasted clauses.

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?

An output schema exists, so return values need no explanation, and the purpose is clear. However, for a tool that fires real webhook deliveries, the description should clarify the default delivery behavior and any environment restrictions; that gap keeps it at adequate rather than complete.

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

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

Schema description coverage is 100%, so the four parameters are fully documented in the schema itself and the baseline is 3. The description adds only the loose notion of optional delivery and nothing about email_id, webhook_id, or the event enum's constraints.

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

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

The description names a specific verb and resource ('Simulate a webhook event'), pins the underlying endpoint (POST /emails/test), and states the intended scenario (CI or local webhook testing). That is enough to separate it from send_email or create_webhook, though it never names a sibling explicitly.

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

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

'for CI or local webhook testing' implies the intended context, but there is no statement of when NOT to use it (e.g. use send_email for real sends) and no named alternative. Usage is inferable rather than prescribed.

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

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

Annotations already declare idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds only the sequencing constraint; it says nothing about what state changes on success/failure, how long propagation takes, or whether the check is synchronous, which are the behaviors an agent actually needs here.

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

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

One sentence, front-loaded with the action and resource, and every clause (DNS, sending domain, after records applied) carries information. 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?

An output schema exists so return values need not be explained, and the single parameter is fully documented. However, for a DNS verification tool the description omits practically relevant context such as propagation delay, expected failure modes, or whether re-verification is safe to repeat.

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 'domain' parameter is documented as an id-or-name, so the schema carries the load. The description adds no format or syntax detail beyond that, which is the expected baseline when the schema is complete.

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 ('Verify') plus the resource and scope ('DNS for a sending domain'), which is more precise than the bare title. It is distinguishable from the adjacent write tool apply_domain_dns, though it never names it or any sibling explicitly.

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

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

'after records are applied' supplies a clear prerequisite/sequencing cue relative to apply_domain_dns, but there are no explicit when-not conditions, no mention of retry cadence, and no named alternative. Usage is implied rather than stated.

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