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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that a step is appended and includes the POST endpoint, but does not mention prerequisites like an existing automation, validation of type/config, response behavior, or auth requirements. For a mutation tool, this is a significant 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 sentence with no filler, front-loading the action and including the endpoint for clarity. Every part 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 append operation, the description and fully documented schema are mostly adequate. However, without an output schema or annotations, it omits what response is returned and any constraints on valid step types/configurations, leaving the agent with some ambiguity about expected behavior.

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

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

Schema documentation covers 100% of the parameters, so the baseline is 3. The description itself adds no parameter details beyond the endpoint's id path, but the schema already documents id, key, type, and config sufficiently.

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 ('Append'), a resource ('a step'), and a target ('an automation'), reinforced by the endpoint. It clearly distinguishes from sibling tools like update_automation_step and delete_automation_step because it signals an add-at-the-end operation.

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

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

The intended use is implied by 'Append a step to an automation', but the description gives no explicit when-to-use guidance or alternatives. It does not mention that update_automation_step should be used to modify an existing step or delete_automation_step to remove one, leaving the agent to infer routing from sibling names.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action and POST endpoint but does not mention idempotency, duplicate handling, permission requirements, validation errors, or what the response indicates. This leaves significant behavioral ambiguity for a mutation 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 a single front-loaded sentence with no filler. It conveys the core action and the endpoint efficiently, making it easy for an agent to parse quickly.

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

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

For a simple two-parameter tool, the description plus fully documented schema is minimally sufficient. However, with no output schema and no annotations, it lacks practical context such as whether adding an existing membership errors or is a no-op, and what a successful response contains.

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 have clear descriptions ('The contact id.' and 'The segment id.'). The tool description adds no additional parameter meaning, but the schema already provides sufficient semantics for a straightforward two-parameter operation.

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: 'Add a contact to a segment.' It unambiguously identifies the action and clearly differentiates from the sibling remove_contact_from_segment, which is the inverse operation. The HTTP endpoint further confirms the intent.

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 associate an existing contact with an existing segment. However, it does not explicitly state prerequisites, exclude alternatives, or mention behavior when the contact is already in the segment. The usage context is clear but not fully elaborated.

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 discloses that the operation applies DNS records and triggers auto-verification, and it states the required token scope. However, it does not say whether this overwrites existing DNS records, whether it is reversible, or what happens on verification failure—important context for a mutating call.

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 that efficiently conveys the action, the endpoint, the verification step, and the credential requirement. Every clause earns its place, and the key verb and provider are 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 simple two-parameter tool, the description is largely complete: it states what happens, which API is used, and what credential is required. It does not describe the success or failure response, but given the lack of an output schema and the simplicity of the operation, this is a minor gap rather than a blocking omission.

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 both parameters already well-documented in the schema. The description mostly repeats the token scope already present in the schema and does not add meaningful new semantic detail about the parameters beyond endpoint 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 clearly identifies the action ('Apply a domain's DNS records'), the mechanism ('via the Cloudflare API'), and the follow-up behavior ('then auto-verify'). It also names the exact endpoint, and by specifying Cloudflare it distinguishes this tool from the sibling apply_domain_dns_godaddy and apply_domain_dns_namecheap 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 conveys when the tool is appropriate by explicitly naming Cloudflare and requiring a Cloudflare token, which differentiates it from the GoDaddy/Namecheap sibling apply tools. It does not explicitly state 'use this instead of the others when the domain uses Cloudflare,' but the provider-specific framing makes the intended context 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 burden of behavioral disclosure. It does disclose that the tool performs an API call and then 'auto-verifies' the result, which is useful. However, it does not mention side effects (e.g., whether existing DNS records are overwritten), authentication requirements beyond the key/secret parameters, or potential failure modes.

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

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

The description is a single, compact sentence that front-loads the primary action and includes the endpoint for clarity. It is efficient and contains no filler, though it could arguably omit the endpoint and still be clear.

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 3-parameter tool with no output schema and no annotations, the description is adequate but not complete. It tells the agent what the tool does and the endpoint, but it does not explain what 'auto-verify' means in terms of return values, what happens on failure, or whether the operation is destructive to existing DNS records. Given the tool's moderate complexity, more context would be helpful.

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 all three parameters (id, key, secret). The description adds no additional meaning beyond what the schema provides, 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 action ('Apply a domain's DNS records via the GoDaddy API') and includes the endpoint ('POST /domains/:id/dns/godaddy'), which clearly identifies the resource and operation. It does not explicitly differentiate from sibling tools like apply_domain_dns_cloudflare or apply_domain_dns_namecheap, but the provider name in the tool name and description makes the distinction clear enough.

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 the tool is used when a domain's DNS records need to be applied through GoDaddy, and the sibling names (apply_domain_dns_cloudflare, apply_domain_dns_namecheap) suggest provider-specific alternatives. However, there is no explicit guidance on when to choose this over the alternatives, nor any mention of prerequisites like domain ownership or prior DNS detection.

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. It does disclose a key behavioral requirement (calling server's IP must be whitelisted) and the auto-verify step, but it does not explain side effects on existing DNS records, error behavior, or what the verification outcome looks like. Adds some value but leaves significant behavioral gaps.

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

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

Two sentences carry all essential information: the action, the endpoint, and a critical prerequisite. No filler, clear front-loading, 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?

The tool is a mutation with no annotations and no output schema, so more explanation is needed. The description covers the core apply-and-verify flow and the IP whitelist prerequisite, but omits outcomes (e.g., whether records are overwritten), failure modes, and the response content. 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 100%, so baseline is 3. The description does not add any additional meaning to the parameters; it mentions the API context but does not clarify how apiUser, apiKey, or userName are consumed beyond the 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 uses a specific verb ('Apply') and resource ('domain's DNS records'), names the API provider (Namecheap), and includes the exact endpoint. This clearly distinguishes it from sibling tools like apply_domain_dns_cloudflare and apply_domain_dns_godaddy.

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 this tool is for Namecheap-managed domains by stating 'via the Namecheap API', but it does not explicitly state when to use it over alternatives or mention the other apply_domain_dns_* tools. Usage context is implied rather than explicit.

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

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

No annotations are provided, so the description carries the behavioral burden. It clearly discloses the state transition (scheduled → draft), which is useful. However, it does not mention whether cancellation is idempotent, what happens if the campaign is already sent or already in draft, or any authorization/rate-limit considerations.

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 compact sentence that packs the action, the state transition, and the endpoint. No filler words, and the most important information (cancel + return to draft) appears 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 single-parameter tool with a clear state-transition behavior, the description is mostly complete. Gaps: it does not clarify return value/response or edge cases (e.g., can a sent campaign be canceled? is cancel only for scheduled ones?). These are minor for a single-id mutation but worth noting.

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

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

Schema description coverage is 100% (the only parameter, id, is described as 'The campaign id.'), so the schema already documents the parameter. The description adds no additional meaning about the id (e.g., format) but no compensation is needed given full coverage.

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

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

States a specific verb (cancel), resource (scheduled campaign), and outcome (returning it to draft), plus the exact HTTP endpoint. This distinguishes it clearly from sibling tools like update_campaign or delete_campaign.

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 the tool is for scheduled campaigns that should be reverted to draft, which gives clear context. It does not explicitly name alternatives or when not to use it, but the 'scheduled' qualifier and the 'returning it to draft' behavior make the intended usage fairly unambiguous relative to delete_campaign.

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. It discloses the HTTP method and the cancel-before-send behavior, but it does not explain what happens if the email has already been sent, whether the operation is idempotent, or what response to 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?

One concise sentence contains the action, the timing constraint, and the endpoint. There is no filler, repetition, or unnecessary detail.

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

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

For a one-parameter cancellation tool with no output schema, the description is nearly complete. The main missing piece is an explicit failure case, such as attempting to cancel an already-sent email, but the core operation and input are fully specified.

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 fully documents the single 'id' parameter with 100% coverage. The endpoint's ':id' confirms it is a path parameter, but the description adds little meaning beyond what the schema provides.

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

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

The description states a specific verb ('Cancel'), a specific resource ('a scheduled email'), and the exact endpoint. The 'before it sends' qualifier makes the tool's scope clear and helps distinguish it from cancel_campaign and other email-related 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 phrase 'before it sends' gives a clear timing condition that tells an agent when this tool is appropriate. It does not explicitly name alternatives or exclusions, but the single-action nature of the tool makes the usage context unambiguous.

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 reveals that the tool performs a read-only DNS/MX inspection via GET, and precisely explains the returned fields and their meaning. It does not cover error cases or permissions, but for a simple preflight check the disclosure is solid.

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-load the purpose and immediately deliver the endpoint and return shape. Every sentence earns its place: the first states the action and timing, the second specifies the response contract.

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-only check with no output schema, the description is complete: it states what it checks, when to use it, and exactly what the response contains. No critical missing context would prevent an agent from selecting or invoking 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 input schema already provides 100% coverage by describing 'name' as the hostname to check with an example. The description reinforces that the hostname is the subject of the MX preflight but adds no significant format or constraints beyond the schema, so the baseline score 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: checking MX records for a hostname as a preflight step before enabling receiving. It also includes the HTTP endpoint (GET /domains/mx-check), which makes the tool's function unmistakable and distinct from the many domain and email 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 clearly states when to use the tool: as an MX preflight check before enabling receiving. It does not explicitly name alternatives or exclusion conditions, but the usage context is specific enough that an agent can determine applicability without further 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 provided, the description carries the full burden of behavioral disclosure. It does state that this is a POST request and that it returns a TXT record to add, which is meaningful. However, it does not disclose side effects, whether the claim creates a pending state, authentication requirements, or what happens after the TXT record is added.

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

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

The description is a single, efficient sentence. It front-loads the core purpose, then adds the endpoint and return value, with no wasted words or redundant restatements.

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 two parameters and no output schema, the description is nearly complete: it explains the action, the endpoint, and the return value. It could be improved by noting the natural next step with verify_domain_claim or get_domain_claim, but that is not necessary to correctly invoke 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 the input schema already documents both parameters ('name' and 'region'). The description adds no additional parameter-level meaning beyond what the schema provides, keeping this at the baseline score.

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 ('Claim'), a clear resource ('a domain already verified elsewhere'), and includes the HTTP endpoint. It differentiates this from sibling tools like verify_domain by explicitly scoping to domains that have already been verified elsewhere.

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 'already verified elsewhere' gives clear situational context for when to use this tool. It does not explicitly name alternatives or exclusions, such as using verify_domain when the domain is not verified elsewhere, but the context is strong enough for an agent to infer the intended use case.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It adds one valuable fact: 'The token is returned ONCE,' warning that the key cannot be retrieved later. However, it does not explain the security consequences of full_access versus sending_access, whether the key is immediately active, or any permission prerequisites.

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

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

The description is short and front-loaded with the core action, followed by the critical one-time-token caveat. The permission sentence is somewhat redundant with the schema enum, but it does not add significant clutter.

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 creation tool the description covers the essential one-time-token behavior, but with no output schema and no annotations it leaves gaps: it does not describe the response shape, the semantics of the two permission levels, or any post-creation behavior. An agent can call it correctly but may not understand which permission to choose.

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

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

The description mostly repeats information already in the schema: permission's enum values are already visible, and name and domain_id already have descriptions. It adds no meaning about what full_access versus sending_access actually allows, nor does it clarify how domain_id interacts with permission beyond the schema's existing note.

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

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

The description states a specific action and resource: 'Create an API key (POST /api-keys).' This clearly differentiates it from sibling tools like list_api_keys and delete_api_key, so an agent can identify its purpose without opening 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?

The verb 'Create' implies when to use the tool, but the description gives no explicit guidance on choosing it over alternatives, nor does it mention when not to use it. It also does not clarify whether permission is optional or what the default behavior is, leaving some usage nuance 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?

With no annotations provided, the description must carry the behavioral burden. It discloses the operation (create) and the HTTP method (POST), but does not mention side effects, duplicate handling, authentication needs, or what happens on success or failure. Adequate for a simple creation, but not richly 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?

The description is a single efficient sentence with no filler. It front-loads the core action and resource, then adds one useful clarifying detail (named list of contacts) and the endpoint.

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 creation tool with no nested objects and no output schema, the description plus the input schema is largely sufficient to invoke it correctly. It could mention the expected response or uniqueness constraints, but these are minor gaps 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 only parameter, 'name', is already described as 'Audience name.' The description adds no additional parameter meaning beyond the schema, so the baseline score 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 uses a specific verb and resource ('Create an audience'), defines the resource as 'a named list of contacts', and includes the endpoint. This clearly distinguishes it from sibling create tools like create_segment or create_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?

No guidance is provided about when to use this tool versus alternatives such as create_segment or import_contacts_batch. The purpose implies it is for creating an audience, but there are no explicit conditions, exclusions, or comparisons.

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 behavioral disclosure, and it does add useful specifics: POST /automations, domain-scoped triggering, and the inline steps/connections option. It stops short of stating permissions, idempotency, or the success response, so coverage 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?

Three tight sentences with no filler; the operation and endpoint are front-loaded and each subsequent sentence contributes a necessary behavioral constraint.

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 six-parameter creation tool with no annotations and no output schema, the description covers core mechanics well: trigger, domain scoping, and optional graph. It omits success-response behavior and does not point to step-building siblings, leaving moderate 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?

All six parameters have schema descriptions, so the baseline is 3. The description adds the conceptual term 'inline step graph' but no additional parameter semantics 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 names the exact operation ('Create an automation'), notes the event trigger, and gives the HTTP endpoint. It also adds a distinguishing constraint (one sending domain, only send_event calls with that domain trigger it), so it is easy to tell apart from update_automation or add_automation_step.

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

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

It gives clear contextual guidance about domain ownership and trigger behavior, and mentions the optional inline graph. However, it does not explicitly tell the agent when to prefer add_automation_step or update_automation, so alternative routing is only implied.

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 usefully reveals that creation is separate from sending and that campaigns target a domain's contact pool, but it omits other significant behaviors such as whether the domain must be verified, whether the campaign is created as a draft, what side effects occur, and what the response contains.

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

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

Two sentences with no filler; the core action is front-loaded, and the pointer to send_campaign earns its place. Every word adds value.

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 complex (16 parameters, nested objects, no output schema, no annotations), yet the description is only two sentences. It does not tell the agent what the API returns (e.g., campaign ID), mention any prerequisites (e.g., verified domain), or outline the broader campaign lifecycle beyond a single pointer to send_campaign. This is inadequate for the tool's 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?

Schema description coverage is 75%, so the schema already documents most parameters in detail. The description adds little beyond the 'domain-first' hint, which is largely redundant with the domain parameter's schema description. It does not compensate for the roughly 25% of undocumented parameters (e.g., html, text, reply_to, preview_text).

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 ('Create') and resource ('campaign'), and scopes it to 'a sending domain's contact pool,' which clearly differentiates it from related tools like send_campaign. The endpoint hint (POST /campaigns) and 'domain-first' add further precision.

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 routes the follow-up action to send_campaign ('Send it later with send_campaign'), giving the agent a clear division of labor between creating and sending. It does not mention alternatives like update_campaign, but the lifecycle clue is sufficient for the most important distinction.

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 and does add real value: it discloses that the same email address on different domains produces separate records with independent consent, preventing the common assumption of email-based global uniqueness. It does not cover duplicate-within-domain behavior or response details, but the key non-obvious side effect is surfaced.

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 first sentence front-loads the action, resource, and endpoint; the second adds the one genuinely non-obvious nuance needed to use the tool correctly.

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

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

The core domain-first identity semantics are well covered, but operational gaps remain: no mention of what happens on a duplicate within the same domain, no return/response information (and no output schema exists), and no explicit routing to batch import tools for large lists. These are meaningful gaps for an agent handling edge cases.

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

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

Schema descriptions already cover email, domain, properties, and unsubscribed (67%), and the description adds meaning beyond that by explaining the identity model: an address is only unique within a domain and consent is domain-scoped. This clarifies the relationship between domain, email, and unsubscribed beyond the literal schema text.

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 action ('create'), a clear resource ('contact in a sending domain's contact pool'), and the HTTP endpoint. The domain-first scoping distinguishes it from related tools like create_contact_property and 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?

Gives clear context: this is the single-contact creation path for a domain-scoped contact pool, and the domain-first note tells the agent where the resource belongs. It does not explicitly call out bulk alternatives like import_contacts_batch or import_contacts_csv, but the single-vs-bulk distinction is strongly implied by the wording and sibling names.

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

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

With no annotations, the description carries the full burden. It discloses a non-obvious behavioral trait: idempotency on key, returning the existing property with 'already_existed: true' instead of erroring. It also names the POST endpoint. It doesn't mention permissions or the normal success response, but the idempotency disclosure is substantial and 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?

Two compact sentences deliver the purpose, endpoint, type constraint, and idempotency behavior without redundancy. The most important information is front-loaded, and 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?

For a simple create tool with no output schema, the description covers the core action, the type enum, and the key edge case of duplicate keys. It omits the normal success return shape and authentication requirements, but the idempotency explanation addresses the most critical ambiguity an agent would face.

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 semantic meaning to 'key' by establishing it as the idempotency identity, which goes beyond the schema's 'Canonical merge-tag key' phrasing. Other parameters remain adequately covered by 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 ('Create') and resource ('custom contact property / merge tag'), and includes the HTTP endpoint. This clearly distinguishes it from siblings like update_contact_property, delete_contact_property, get_contact_property, and list_contact_properties without needing to inspect their 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?

The description implies usage for creating or ensuring a property exists, and the idempotency behavior suggests it can be used safely when a key may already exist. However, it does not explicitly route to alternatives like update_contact_property when modification is intended, nor give any when-not-to-use 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 carries the behavioral disclosure burden. It usefully discloses that the response contains DNS records and that verification depends on adding them at the DNS provider, setting accurate expectations for post-creation state. It does not cover all edge cases, but it discloses the most important 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 short sentences, each earning its place: the first states the action and endpoint, the second communicates the essential DNS follow-up. It is front-loaded and contains 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 two-parameter creation tool, the description covers the main workflow: create, receive DNS records, add them, verify. It could name the sibling verify_domain tool explicitly, but the information given is sufficient for the agent to invoke the tool correctly and understand the immediate next step.

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 both 'name' and 'region'. The description adds no parameter-specific detail, but none is needed 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 action ('Create a sender domain') and the exact endpoint ('POST /domains'), making the tool's purpose immediately clear. The phrase 'before verifying' also distinguishes this tool from the sibling verify_domain operation.

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

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

The description gives clear usage context: create the domain, then add the provided DNS records before verifying. It does not explicitly name alternatives or exclusions, but the sequencing is clear enough to guide an agent toward correct use.

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 a specific behavior: the schema validates /events/send payloads and returns 422 on mismatch, which is valuable. However, it omits other behavioral details such as whether the event name must be unique, whether the operation is idempotent, or any permission requirements. It provides some transparency but not a complete picture.

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 that front-loads the core purpose ('Create a custom-event definition') and then adds the most important detail about schema validation. Every word earns its place; there is no fluff or redundancy. It is compact yet 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?

For a simple create tool with two parameters and no output schema, the description covers the essential behavior: creating a definition and the optional validation side effect. It doesn't mention success responses or duplicate-name handling, but given the low complexity and full schema coverage, the description is reasonably complete. A brief note on return values or unique-name behavior would improve it, but it's not a major gap.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by specifying allowed schema values ('string'|'number'|'boolean'|'date') and explaining the validation effect (422 on mismatch). This enriches the agent's understanding of the 'schema' parameter without repeating the schema's own description.

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 creates a custom-event definition (POST /events), distinguishing it from siblings like send_event (which sends events) and list_events/update_event/delete_event. The verb-resource pair is specific and unambiguous. It also hints at the schema's role, making the tool's purpose immediately identifiable.

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: it defines an event schema that validates /events/send payloads, implying this should be used before sending events with a schema. However, it does not explicitly mention when not to use it or name alternatives like send_event, leaving some inference to the agent. It's clear but lacks explicit exclusions.

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

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

No annotations are present, so the description must carry the behavioral burden; it does disclose domain scoping, name uniqueness per domain, and filter capabilities. However it omits what happens on duplicate names, required permissions, and what a successful response looks like.

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

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

Two compact sentences front-load the core purpose and route, then add naming semantics and filter support. No filler or redundant restating of 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 and no output schema, the description covers domain model, name uniqueness, and filter, but lacks response/error behavior and prerequisites around domain ownership/verification. It is adequate, not complete.

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

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

Schema coverage is 100%, so baseline is 3; the description adds the important cross-domain name uniqueness constraint and summarizes the filter keys. This is extra meaning beyond the schema, though the filter info largely duplicates the schema's example.

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 names the exact operation (Create), resource (segment), scope (sending domain), and HTTP route (POST /segments). This clearly distinguishes it from sibling update/get/list/delete segment tools without requiring the agent to open 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?

No explicit when-to-use or when-not guidance and no named alternatives, but the create verb plus the uniqueness/domain-first context makes usage inferable. It does not tell the agent what to do if the segment already exists or when to prefer update_segment.

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 disclosure burden. It does disclose the POST endpoint and the templating behavior (subject/html/text with {{ variables }} and optional variable definitions), but it says nothing about authentication, duplicate-name behavior, validation, or response side effects, 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?

The description is two short clauses, front-loads the action and resource, and every phrase adds information: endpoint, supported fields, and variable behavior. There is 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 an 8-parameter creation tool with no annotations and no output schema, the description omits meaningful context: no usage guidance, no behavior on conflicts, no response expectations, and several parameters are only name-based. It is not complete enough for an agent to invoke with full confidence based solely on the description.

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 38%, so the description needs to compensate. It usefully adds the {{ variables }} injection syntax and identifies subject/html/text as the supported content fields, but it leaves from, alias, and reply_to semantics to bare property names in the schema.

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

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

The description names the exact action ('Create') and resource ('reusable email template') and gives the explicit endpoint, so an agent can distinguish this from update_template, duplicate_template, and list_templates without inspecting schemas. 'Reusable' adds useful scope beyond a generic create action.

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 verb 'create' and the endpoint imply this tool is for new templates, but the description does not explicitly state when to use it over update_template or duplicate_template, nor does it mention exclusions or prerequisites. Usage guidance is only implied, not stated.

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

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

No annotations are provided, so the description carries the full burden. It discloses the HTTP method and domain-first ownership, but does not mention return values, idempotency, permission requirements, duplicate behavior, or whether the sending domain must be verified before creating a topic.

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

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

The description is two concise sentences with the core action and route front-loaded. The second sentence repeats enum constraints already present in the schema, making it slightly redundant, but overall it remains scannable and free of 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?

The schema covers required fields and gives good descriptions for name and domain, and the description covers the remaining enums. However, with no output schema and no annotations, the description omits response behavior, error cases, and domain verification requirements, which would be valuable for a create operation.

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

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

Schema description coverage is only 40%, and the description adds explicit valid values for default_subscription and visibility. However, it does not explain the meaning of default_subscription, the purpose of the free-text description parameter, or any constraints on name/domain 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?

States a specific action ('Create') on a 'subscription topic' tied to a 'sending domain', and includes the exact endpoint 'POST /topics' plus the 'domain-first' model. This clearly separates it from sibling tools such as list_topics, get_topic, update_topic, and delete_topic.

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 create verb and resource type imply when to use this tool, but there is no explicit when-to-use/when-not-to-use guidance or mention of alternatives. It does not state prerequisites like needing a valid sending domain, which would help an agent decide between this and update_topic.

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, and it discloses the key one-time secret behavior and the persistent side effect of creating an endpoint. It could mention auth or full response contents, but the most operationally critical behavior is surfaced.

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

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

Two short sentences with no filler; the core purpose is front-loaded and the secret warning 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 create operation with a complete parameter schema, it says everything an agent needs to invoke it correctly and handle the signing secret. It does not spell out the full response schema or webhook ID, but no output schema is available and the critical return value is highlighted.

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

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

The input schema already documents both parameters completely (100% coverage), and the description adds no additional parameter-level detail. Per the baseline for high schema coverage, a 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 names a specific action and resource: 'Create a webhook endpoint (POST /webhooks).' This clearly differentiates it from webhook siblings like list_webhooks, update_webhook, delete_webhook, and rotate_webhook_secret.

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 establishes when to use it — when creating a webhook — and adds an important consumer warning that the signing secret is only returned once. It does not explicitly name alternatives or exclusion cases, but the create-vs-manage context is clear from the sibling set.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It states the action ('delete/revoke') but does not disclose irreversibility, immediate invalidation, permission requirements, or any side effects. This is a significant gap for a destructive tool.

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

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

The description is a single, compact sentence with no filler. It front-loads the primary action and includes the endpoint, every word earning 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 tool, the description covers the core purpose and resource. However, with no output schema and no annotations, it omits expected response behavior, idempotency, and whether the key is immediately unusable. It is minimally adequate but could be more complete.

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

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

Schema coverage is 100%, so the schema already documents the `id` parameter. The description adds no extra parameter-level semantics (e.g., where to find the id, format constraints), 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 uses a specific verb ('Delete (revoke)') and resource ('API key'), plus the HTTP endpoint, making the action unmistakable. It clearly distinguishes this tool from siblings like create_api_key and list_api_keys.

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 directly implies when to use it (whenever an API key needs to be revoked). There is no explicit alternative mentioned, but the context is clear enough that an agent can infer the correct usage without ambiguity.

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. It explicitly reveals a critical side effect: deleting an audience also deletes its contacts. However, it doesn't mention irreversibility, authorization needs, or rate limits, which would provide fuller transparency.

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

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

The description is a single, efficient sentence: the verb and object are front-loaded, and the HTTP endpoint is appended as supplemental context. No filler or redundant explanation exists.

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 delete operation with no output schema and full schema coverage, the description covers the key behavioral nuance (cascading contact deletion). It could mention that the deletion is permanent, but the combination of the DELETE method and the explicit side effect is sufficient for most agent use cases.

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

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

Schema coverage is 100%, and the only parameter 'id' is already described as 'The audience id.' The description adds no additional semantic meaning to the parameter, 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 clearly states the action ('Delete') and resource ('an audience'), with an important clarification that contacts are also deleted. It distinguishes itself from siblings like update_audience and delete_contact by naming the audience as the target and noting the cascade effect. The HTTP endpoint further reinforces the specific operation.

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

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

The description implies when to use the tool—whenever you need to delete an audience—but provides no explicit guidance on when not to use it or alternatives like delete_segment or delete_contact. There are no prerequisites, exclusions, or comparisons to sibling deletion 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?

There are no annotations, so the description must carry the full burden of behavioral disclosure. It only says 'Delete' without mentioning that deletion is likely permanent, whether associated steps or runs are removed, or what side effects occur. This is a destructive operation and deserves more warning.

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 compact sentence with no unnecessary words. It front-loads the core action and includes the endpoint in parentheses 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 simple operation with one fully documented required parameter, the endpoint and action are enough for an agent to select and invoke the tool correctly. The main gap is the lack of side-effect or return-value information, but the low complexity keeps the description reasonably complete.

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

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

Schema coverage is 100% and the single 'id' parameter is already described in the input schema. The endpoint 'DELETE /automations/:id' adds a small amount of context by showing id is a path parameter, which warrants the baseline 3 rather than lower.

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 action ('Delete'), the resource ('an automation'), and the exact endpoint. It is unambiguous and distinguishable from nearby siblings like delete_automation_step because the resource level is 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?

The usage context is only implied by the action verb and resource name; there is no explicit guidance on when to choose this over stop_automation, update_automation, or delete_automation_step. An agent can infer the intended use, but the description does not state exclusions or 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?

With no annotations, the description carries the behavioral burden. It discloses the DELETE method and the important stop-first requirement, but it does not mention irreversibility, required permissions, or what happens if the step is in use.

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

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

The description is a single, front-loaded sentence that conveys the action, endpoint, and critical usage warning without any 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 simple two-parameter delete operation, the description is largely complete: it identifies the action, endpoint, and precondition. It does not describe the response or side effects, but the operation's simplicity makes this a minor gap.

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

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

Schema coverage is 100%, and the two parameters are clearly documented as 'automation id' and 'step id to delete'. The description adds no new parameter semantics beyond confirming the endpoint mapping.

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: 'Delete a step from an automation', and reinforces it with the HTTP endpoint. This clearly distinguishes it from siblings like delete_automation, add_automation_step, and update_automation_step.

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 precondition: 'Stop (disable) the automation first if it is enabled.' It does not explicitly compare to alternatives, but the resource is specific enough that when to use it 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?

No annotations are provided, so the description must carry the burden of behavioral disclosure, but it only restates the destructive nature of the operation. It does not mention permanence, side effects, permissions, or whether the delete is idempotent; the endpoint method is the only added signal.

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 states the action, resource, and endpoint with no filler or repetition. It is appropriately sized for a tool with a single parameter.

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 destructive action, the description plus schema provide enough to invoke the tool correctly: the operation, the resource, and the required id. It lacks any warning about irreversibility, but delete semantics are sufficiently 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?

The input schema already fully documents the single id parameter with 100% coverage, so the description has little to add. The endpoint path '/campaigns/:id' reinforces that id is the campaign identifier but adds no new semantic detail.

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

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

States a specific verb and resource ('Delete a campaign') and adds the exact HTTP endpoint, leaving no ambiguity about what is being acted on. It clearly differentiates from sibling operations like delete_topic or cancel_campaign by naming the campaign resource.

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

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

The intended usage is implied by the verb and resource: use this when a campaign needs to be deleted. However, the description gives no explicit guidance about when not to use it or how it relates to siblings such as cancel_campaign or update_campaign.

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 the destructive nature (DELETE verb) and the subtle 'picks the pool' domain behavior, but does not disclose failure modes, idempotency, reversibility, or cascading side effects on associated contact data.

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 front-loaded sentences with zero waste: the operation and endpoint come first, then a single conditional usage note. Every element 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 2-parameter tool with 100% schema coverage and no output schema, the description covers the operation, addressing modes, and the domain ambiguity handling. Minor gaps remain: no statement of error behavior for unmatched ids/emails or consequences of the destructive action, which matter more in the absence of annotations.

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 schema already documents both parameters well. The description adds marginal value beyond the schema, mainly reinforcing the domain-omission rule and adding the 'picks the pool' pool-selection nuance. This matches the baseline of 3 for high schema coverage.

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

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

States a specific verb ('Delete'), a specific resource ('a contact'), and both addressing modes (id or email), with the HTTP endpoint clarifying the exact operation. It is clearly distinguishable from siblings like delete_received_email and delete_contact_property, which target different resources.

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?

Provides explicit conditional guidance: pass `domain` when addressing by email, omit it for a contact id. This gives clear dispatch context for the two addressing modes. It does not explicitly name alternatives or exclusions, though sibling differentiation is semantically obvious for a delete-contact operation.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action and HTTP method, implying mutation, but it does not disclose whether the deletion is permanent, what happens to contacts using the property, or any permission requirements. For a destructive operation, this is a significant 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 sentence that includes the essential action and HTTP endpoint, with no wasted words. It is front-loaded and 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 delete operation with one parameter, the description is adequate but incomplete. It does not mention irreversibility, return value, or error behavior. Given that there is no output schema and no annotations, a note about permanence or effects on dependent data would make it more 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 a 100% description coverage for the single 'id' parameter ('The contact property id.'). The description adds no additional meaning beyond what the schema already states, 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 states the action (delete) and resource (contact property), and includes the HTTP method and path (DELETE /contact-properties/:id), making it unambiguous. It is easily distinguished from sibling tools like get_contact_property or update_contact_property.

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 destructive action through the verb 'delete' and the HTTP DELETE method, but it does not explicitly state when to use it vs. alternatives, nor does it mention any prerequisites or consequences (e.g., irreversibility). It is clear enough for a simple delete operation but lacks explicit 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses that the tool deletes a domain, but does not mention irreversibility, cascading effects on DNS or email sending, required permissions, or whether confirmation is needed. The HTTP DELETE method is the only implicit signal of destructiveness.

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

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

The description is a single, front-loaded sentence with no filler. Every element—the action, resource, and endpoint—earns its place, and the syntax is immediately scannable by an agent.

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

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

For a destructive operation with no annotations and no output schema, the description is too sparse. It omits any context about deletion consequences, required state (e.g., unverified vs. verified), or what happens to dependent resources, making it less than minimally viable for safe invocation.

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

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

The schema covers 100% of the parameter landscape: one required id field with a clear description. The tool description adds no additional meaning beyond the schema, but since schema coverage is complete, 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 states a specific action ('Delete') on a specific resource ('a domain') and gives the exact REST endpoint (DELETE /domains/:id). This makes it immediately distinguishable from sibling tools like delete_received_email or update_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 no guidance on when to use this tool versus alternatives, no prerequisites, and no conditions such as 'only delete domains that are not currently in use.' It only states what the operation does, leaving usage decisions entirely 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?

There are no annotations, so the description carries the behavioral burden. It discloses non-obvious consequences: existing automations keep their trigger names and only the definition and validation are removed. This goes beyond a generic 'delete' statement, though it omits irreversibility and return-value details.

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 with no filler. The primary action is front-loaded, and the important side-effect caveat about automations is placed directly afterward. Every clause adds useful information.

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

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

The tool is simple: one required parameter, fully described schema, and no output schema. The description adequately explains what is deleted and what is preserved, making the tool safe to invoke. A small gap is the lack of explicit confirmation about permanence or the response format.

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

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

The input schema fully documents the single 'id' parameter with a clear description, and schema coverage is 100%. The tool description adds no extra parameter semantics, but none are needed given the schema's completeness.

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, 'Delete a custom-event definition', and includes the REST endpoint. It clearly distinguishes this from sibling tools like delete_automation or delete_contact by scoping the resource as the event definition rather than the event data itself.

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

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

The description clarifies the tool's exact scope, noting that automations retain their trigger names and only the definition plus payload validation are removed. It does not explicitly name an alternative tool for different deletion scenarios, but the context makes the intended use 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 full burden of behavioral disclosure. It explicitly discloses permanent deletion, irreversibility ('This cannot be undone'), and the full destruction scope (raw message plus attachments). This is exemplary transparency for a destructive operation.

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

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

Two tightly focused sentences that front-load the action and resource, then provide the critical irreversibility warning. No filler or redundant wording.

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

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

For a single-parameter destructive operation with no annotations and no output schema, the description is complete: it states what is deleted, the endpoint, and that the operation is permanent. An agent has everything needed to invoke it correctly and understand consequences.

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

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

Schema description coverage is 100% ('The received email id.'), so the baseline is 3. The description adds minor context by embedding the id in the endpoint path and tying it to the received email resource, but it does not explain how to obtain or validate the id. This is adequate but not additive beyond the schema.

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

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

The description states a specific action ('Permanently delete'), a specific resource ('received email'), and the full scope of what is deleted ('including its stored raw message and attachments'). This clearly distinguishes it from sibling tools like cancel_email, update_email, and forward_received_email, so an agent can tell what this tool does without opening 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?

The description provides clear context: use this when a received email must be permanently removed. It does not explicitly name alternatives or exclusions, but none of the sibling tools directly compete for received-email deletion, so the purpose statement effectively guides selection. Slightly more explicit when-not-to-use guidance would earn 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?

No annotations are provided, so the description carries the full behavioral burden. 'Delete' signals destructiveness, but the description does not disclose irreversibility, whether contacts or segment memberships are affected, required permissions, or any side effects. This is a meaningful gap for a mutating 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 a single concise sentence with the action and endpoint front-loaded. There is no filler, repetition of schema details, or unnecessary context.

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

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

For a one-parameter delete, this is minimally viable, but without annotations or an output schema it omits side effects, error/status behavior, and what a successful deletion returns. An agent would still have open questions about impact and confirmation.

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 only parameter (id) with 100% coverage, so the description does not need to restate it. The HTTP endpoint adds the minor detail that id is a path parameter, but otherwise adds no significant semantic value beyond the schema.

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

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

The description uses a specific verb ('Delete') and resource ('segment') plus the HTTP endpoint, making the operation unambiguous. It is clearly distinguishable from sibling segment tools like create_segment, get_segment, update_segment, and list_segments.

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 correct usage is implied by the verb and resource, but there is no explicit when-to-use guidance, prerequisites, or mention of alternatives/exclusions. For a straightforward delete, this is adequate but not actively instructive.

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 only says 'Delete', so the agent knows the operation is destructive, but it does not disclose whether deletion is permanent, what happens to templates in use, or any permission or error behavior.

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

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

One short sentence with the endpoint included, no filler. The essential verb and resource are front-loaded and 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 tool is simple and the only parameter is fully documented in the schema. However, there are no annotations, no output schema, and no mention of side effects or response behavior, leaving the destructive consequences partially implicit.

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 covers 100% of the single parameter with 'The template id', so the baseline is 3. The description adds no parameter-specific meaning, which is acceptable because the schema fully documents it.

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 the verb 'Delete', the resource 'template', and the exact endpoint 'DELETE /templates/:id'. This unambiguously distinguishes it from sibling tools like update_template, duplicate_template, or publish_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?

No guidance is given on when to choose this tool over alternatives such as update_template or publish_template. There are no prerequisites, conditions, or exclusions, so the agent must infer usage from the operation 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?

With no annotations, the description carries the full burden of disclosing behavior. It clearly states the destructive action ('Delete') and the HTTP method, which is transparent at a basic level. However, it does not mention whether deletion is permanent, irreversible, or whether it affects related resources like contacts or campaigns.

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 entire description is one short sentence that includes the action, resource, and endpoint. There is no redundant or filler content, and every word contributes to understanding the tool.

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

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

For a one-parameter delete operation with no output schema, the description provides enough call-level context: the action, resource, and endpoint. It could additionally mention what happens after deletion (e.g., success response shape), but this is a minor gap for such a 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 input schema already documents the single 'id' parameter at 100% coverage with 'The topic id.' The description adds no additional semantic meaning, but the schema is sufficient, 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 uses a specific verb ('Delete') and resource ('topic'), and reinforces it with the HTTP endpoint 'DELETE /topics/:id'. This makes the tool's action unambiguous and distinguishes it from siblings like create_topic, update_topic, get_topic, and list_topics.

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 about when to use this tool versus alternatives, nor any constraints such as prerequisites or consequences. The agent is left to infer that this is for removing a topic rather than updating or listing 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 provided, the description carries the full burden for behavioral disclosure. It only states the HTTP method DELETE, which implies destruction, but it does not mention permanence, side effects, permissions, or what happens to associated resources. This is minimal transparency for a destructive operation.

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

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

One short, front-loaded sentence with no filler. Every word contributes to identifying the action and resource, making it highly concise and clearly structured.

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 delete with no output schema and no annotations, the description conveys the core action but omits operational context such as whether the deletion is permanent, how success or failure is reported, or any prerequisites. It is adequate but not complete.

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

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

Schema coverage is 100% — the single parameter 'id' is already fully documented as 'The webhook id.' The description adds no additional parameter semantics or examples, 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 states a specific verb and resource — 'Delete a webhook' — and reinforces it with the REST endpoint 'DELETE /webhooks/:id'. This clearly distinguishes the tool from sibling webhook tools like create_webhook, get_webhook, update_webhook, and rotate_webhook_secret.

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

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

The description provides no explicit guidance on when to use this tool vs alternatives, nor any prerequisites or caveats. Usage is only implied by the name and action 'Delete', leaving the agent to infer context such as irreversibility or required ownership.

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 transparency burden. It includes the HTTP GET method, which signals a read-only operation, and states what the tool returns. It does not mention error cases, prerequisites, or permission requirements, but the read-only nature is reasonably 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?

The description is a single sentence that gives the purpose, the output type, and the exact endpoint with no filler or repetition. Every element 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 read-only detection tool with no output schema, the description adequately conveys what will be returned: DNS provider and available one-click apply methods. It could mention prerequisites like domain ownership or verification, but those may be shared across domain tools and are not critical for the primary 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?

The only parameter, id, is already fully described in the input schema as 'The domain id.' The description adds no additional parameter detail, but since schema coverage is 100%, the baseline score 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 clearly identifies the action ('Detect'), the resource ('a domain's DNS provider'), and the additional output ('one-click apply methods available'). It also includes the exact endpoint, making the tool's function unambiguous and distinct from the apply_domain_dns_* 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 implies the tool is used before selecting a one-click DNS apply method, as it detects the provider and available apply methods. However, it does not explicitly mention alternatives like check_domain_mx or state when not to use this tool, so the context is clear but not fully explicit.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals the HTTP method and path, but does not state that a new copy is created while the original remains unchanged, whether the operation is idempotent, or what is returned. For a mutating operation this is thin.

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

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

The description is a single front-loaded sentence with no filler. Every word contributes the action and the endpoint, making it highly efficient for an agent to parse.

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 3-parameter operation with no output schema, the description is minimally adequate but leaves out behavioral details and usage context. An agent can likely call it correctly, but it lacks the safeguards a well-rounded definition would provide.

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 fully documents id, name, and alias. The description adds no parameter semantics beyond the endpoint's :id placeholder, which is already represented in the schema, so the baseline 3 applies.

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

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

The description states a specific verb ('Duplicate') and resource ('a template'), and the endpoint POST /templates/:id/duplicate reinforces the action. This clearly distinguishes it from siblings like create_template, get_template, update_template, and delete_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?

The description makes the intended use evident from the verb, but it offers no explicit guidance on when to choose duplication over create_template or update_template. No exclusions or alternative routing are provided beyond the inherent meaning of the action.

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 disclose the 'from' must be verified, which is a useful constraint, but it does not mention side effects (e.g., that the email is actually sent), any authorization requirements, or what happens to the original email. For a mutation action, this is a notable 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 concise and front-loaded with the core action. It consists of two sentences with no filler. The HTTP endpoint is included but does not bloat the description. 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?

Given the tool's low complexity (4 params, no output schema) and full schema coverage, the description covers the essential action and the key 'from' constraint. However, it omits usage guidance and does not mention any prerequisites beyond the verified sender, which for a forwarding action might be expected. It is adequate but not exhaustive.

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

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

The input schema has 100% description coverage for all four parameters, so the baseline is 3. The description adds no new parameter semantics beyond repeating the 'from' constraint already present in the schema. It does not clarify the 'to' array format or the subject override beyond what is in the schema.

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

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

The description clearly states the action: 'Forward a received email to other recipients.' It specifies the verb (forward), the resource (received email), and the target (recipients). It also includes the HTTP endpoint, which adds precision. This distinguishes it from sibling tools like delete_received_email and reply_received_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 does not provide guidance on when to use this tool versus alternatives. It mentions the 'from' parameter must be a verified sending address, but that is a parameter constraint, not usage context. There is no explicit statement about when to choose forward over reply or delete, nor any exclusions.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the HTTP method GET, indicating a read-only operation, but it does not describe error behavior, authorization needs, or return format. This is adequate for a simple retrieval tool but not richly 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 sentence with the verb and resource front-loaded, and the endpoint parenthetical adds precise value without padding. Every token 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, no-nested-object tool with a complete schema, the description is essentially sufficient: it names the resource, the lookup key, and the HTTP method. Since there is no output schema, a brief note on the return value would make it fully complete, but this is a minor gap.

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

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

Schema coverage is 100% and the single id parameter is already documented in the input schema. The description adds no new meaning beyond restating that retrieval is by id, so the baseline score 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 ('Retrieve') and resource ('an audience') and qualifies it by id, which clearly distinguishes it from list_audiences, update_audience, and delete_audience. The inline endpoint GET /audiences/:id reinforces the exact operation.

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

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

The phrase 'by id' implies this is for fetching a single audience when the id is known, but the description does not explicitly name list_audiences as the alternative for fetching all audiences, nor does it provide a when-not-to-use condition. Usage guidance is implicit rather than explicit.

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

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

With no annotations, the description carries the full burden. It discloses the HTTP method (GET) implying read-only behavior, and explicitly mentions the step graph inclusion. However, it does not describe the complete return payload, error conditions, or whether run history is excluded.

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 that front-loads the primary action and resource, then adds the useful endpoint reference. There is zero redundancy or 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 simple GET tool with one parameter and no output schema, the description covers the core purpose and highlights the step graph, which is the distinguishing feature. It could mention what is not returned (e.g., run history) but is otherwise 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 coverage is 100% for the single 'id' parameter, and the schema already explains it as 'The automation id.' The description adds no additional semantics beyond what the schema states, 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 clearly states a specific verb ('Retrieve') and resource ('an automation'), and adds 'including its step graph' which distinguishes it from list_automations and get_automation_run. The REST endpoint provides an unambiguous reference.

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 its siblings like list_automations or get_automation_run. It does not mention when to prefer this over alternatives, so the agent must infer from the name alone.

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

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

No annotations are provided, so the description carries the full burden. 'Retrieve' implies a read-only operation, and 'including its step-by-step trace' discloses what the response contains. However, it doesn't explicitly state side-effect-free behavior, error handling, or permission requirements. For a simple GET this is adequate but not thorough.

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, tightly constructed sentence with no filler. It front-loads the main action and resource, then appends the differentiating trace detail and endpoint. Every element 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 two-parameter GET with no output schema, the description is nearly complete. It identifies the resource, the trace, and the endpoint. It doesn't describe the response format in detail, but the mention of 'step-by-step trace' gives the agent sufficient context to call it correctly.

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

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

Schema description coverage is 100%, so both parameters are already well documented. The description's endpoint '/automations/:id/runs/:runId' adds a modest clarification of the id/run_id relationship, but it doesn't add meaningful semantic value beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the verb 'Retrieve', the specific resource 'a single automation run', and adds the distinctive detail 'including its step-by-step trace'. It also includes the exact endpoint, which distinguishes it from sibling tools like list_automation_runs.

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 clear context: use this when you need a single run's full details. It doesn't explicitly mention alternatives or when not to use it, but the word 'single' implies contrast with the listing sibling. No exclusionary guidance is given, 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?

No annotations are provided, so the description carries the burden. It does disclose the HTTP method (GET) and resource path, which implies a read-only lookup with no destructive side effects. It does not mention not-found behavior, response shape, or error cases, but for a simple single-resource GET this is acceptable baseline transparency.

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

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

A single sentence that front-loads the operation and includes the endpoint in parentheses. There is no filler or redundancy, and every element 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 tool is low-complexity: one required id parameter, no nested objects, no output schema. The description plus schema is enough for an agent to select and invoke the tool correctly and to infer that the campaign object is returned. The only gap is explicit return/error behavior, which is minor for a simple GET.

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 defines id as a required string. The description adds only that the id identifies the campaign and appears in the URL path, which is minor extra context rather than substantive parameter semantics. 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 uses a specific verb ('Retrieve'), a clear resource ('campaign'), and a selection criterion ('by id'), plus the REST endpoint. This distinguishes it from siblings like list_campaigns (collection) and get_campaign_stats (analytics).

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 'by id' and the GET /campaigns/:id endpoint: call this when you have a single campaign id and need that campaign. However, it does not explicitly mention alternatives such as list_campaigns for multiple campaigns or get_campaign_stats for statistics, so the guidance is implicit rather than explicit.

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

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

There are no annotations, so the description carries the full burden. The GET method and the word "evaluation" imply a read-only operation, and the description notes the A/B-test precondition. However, it does not disclose error behavior, whether a winner may be absent, or what exactly is returned, so the transparency is only minimally adequate.

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 compact sentence that front-loads the purpose and includes the exact HTTP endpoint. There is no filler, repetition, or unnecessary detail.

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

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

For a single-parameter GET tool with a fully documented schema, the description is largely complete: it states the resource, the A/B-test condition, and the endpoint. Since there is no output schema, a slightly more explicit statement of the return value (e.g., the winning variant or a null result) would make it fully complete, but nothing essential to deciding whether to call it 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%, and the id parameter is already clearly described as the campaign id that must be an A/B test. The endpoint in the description reinforces that id is a path parameter, but it adds no meaning beyond what the input schema already 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 resource (an A/B-test campaign) and the specific concern (A/B winner evaluation), and the included GET endpoint helps distinguish it from general campaign tools like get_campaign_stats or list_campaigns. It is not quite a 5 because "evaluation" is slightly abstract; an explicit verb like "retrieve the winning variant" would be more precise.

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 "for an A/B-test campaign" gives a clear context for when this tool applies, and the endpoint name shows this is specifically about the A/B result rather than general campaign information. However, it does not explicitly say when NOT to use it or name alternatives such as get_campaign_stats, 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. The 'GET /campaigns/:id/stats' notation indicates a read-only operation, and the listed outputs (counts, engagement rates, top clicked links) describe some behavior. However, it does not disclose response format, error conditions, or whether data is aggregate over all time or a specific period.

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, information-dense sentence that front-loads the core purpose and includes the endpoint. Every element earns its place, and there is no filler or 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 one-parameter, no-output-schema read tool, the description is reasonably complete: it names the resource, the required identifier, and the specific data returned. Minor gaps like pagination, default time windows, and response shape are not addressed, but the description covers the essentials an agent needs to invoke the tool correctly.

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

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

The input schema describes the single required parameter 'id' as 'The campaign id,' so schema coverage is 100%. The description adds no additional meaning, format expectations, or validation details beyond the schema, matching the baseline for high schema coverage.

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

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

The description clearly identifies the tool as per-campaign analytics and enumerates the returned data: counts, engagement rates, and top clicked links. It distinguishes this from campaign CRUD tools like get_campaign or list_campaigns through the word 'analytics' and the stats endpoint, 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?

No explicit guidance is given about when to choose this tool over alternatives such as get_campaign, get_campaign_ab, or list_campaigns. The intended use is only implied by the phrase 'per-campaign analytics,' leaving the agent to infer that this is for metrics rather than campaign configuration or details.

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 behavioral burden. It discloses that this is a GET operation and explains the domain/email pool nuance, but it does not specify what happens if `domain` is omitted for an email id, nor the response format or error handling. It adds useful context but leaves important behavioral gaps.

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

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

Two sentences, front-loaded with the verb and resource. The critical nuance about email pools is delivered compactly with no filler or redundant restating of schema fields.

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

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

For a two-parameter read operation with 100% schema coverage, the description covers the main contextual pitfall (email ambiguity across pools) and the exact endpoint. It lacks response shape and error behavior, but given the low complexity and the presence of sibling tools for related operations, it is largely complete.

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

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

The input schema already describes both parameters, and schema coverage is 100%. The description adds genuine meaning beyond the schema by explaining why `domain` is needed and when it can be omitted, enriching the semantics of `id` as an ambiguous email reference rather than just a string.

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

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

The description opens with a specific verb and resource ('Retrieve a contact') and states the endpoint (GET /contacts/:id). It also distinguishes the tool by clarifying that the id may be a contact id or an email, setting it apart from sibling tools like get_contact_property or list_contacts without requiring schemas to be opened.

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 operational context: a contact id is exact, while an email needs the `domain` parameter to disambiguate across pools. It does not explicitly name alternative tools or state when not to use this one, but the single-contact retrieval scope is clear enough for an agent to select it 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?

Because no annotations are provided, the description must carry the behavioral burden. It does convey read-only semantics through 'Retrieve' and the GET verb, but it does not disclose potential 404 behavior, permission requirements, or response shape. For a simple getter this is adequate but not comprehensive.

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

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

The description is a single efficient sentence that front-loads the action and resource, then adds the endpoint for precision. There is no filler or redundancy, making it appropriately sized for the tool's simplicity.

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

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

Given the tool's low complexity—one required parameter, no nested objects, no annotations, and no output schema—the description plus schema is sufficient for an agent to call it correctly. Minor omissions like return format and error conditions are not critical for a standard GET-by-id tool, but would have made it 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 100% and the lone `id` parameter is already described as 'The contact property id.' The description adds no further semantic meaning beyond the endpoint placeholder, so the schema carries the parameter documentation burden.

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

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

The description clearly states the action 'Retrieve' and the resource 'contact property by id', and reinforces it with the concrete endpoint 'GET /contact-properties/:id'. This distinguishes it from sibling tools like list_contact_properties, update_contact_property, and delete_contact_property without needing to open 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?

The phrase 'by id' implies the intended use case: fetch a single contact property when the id is known. However, it does not explicitly contrast with list_contact_properties for enumeration or mention that this is a read-only alternative to update/delete, so the when-not guidance is only implied.

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 HTTP method and endpoint, indicating a read-only operation, but it does not mention response shape, error conditions, or whether subscriptions are returned in any particular order.

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 names the action, resource, and endpoint with no filler. The essential scoping 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 simple single-parameter read operation, the description gives enough context to select and invoke the tool correctly. The absence of an output schema is mitigated by the clear notion of 'topic subscriptions', though a bit more detail on the response would make it 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 schema already documents contact_id with 100% coverage grating, so the description adds no parameter detail beyond what is available. The endpoint does illustrate how the parameter is used, which is a small bonus.

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 'Get' with a clear resource ('a contact's topic subscriptions') and includes the endpoint. This distinguishes it from the sibling update_contact_topics and from generic list_topics without ambiguity.

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

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

The GET method and resource scope imply this is the read-only counterpart to update_contact_topics, but the description does not explicitly state when to use this tool versus alternatives. Usage is inferable but not directly guided.

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. It does disclose that the tool is read-only (retrieve) and mentions the response includes DNS records and verification status. However, it does not mention any side effects (likely none), authorization requirements, or rate limits. The mention of GET /domains/:id adds context about the underlying API operation.

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

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

The description is a single sentence that precisely states the action, resource, and return contents. It is front-loaded with the purpose and includes the endpoint for reference. 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?

The tool is simple with one well-documented parameter, and the description covers the return content. Since there is no output schema, mentioning the return fields is essential and is done. The only minor gap is not stating that the domain must exist or what errors might occur, but the description is adequate for a simple retrieval.

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 100% description coverage, so the parameter 'id' is well documented. The description does not add additional meaning beyond what the schema provides, but baseline 3 is appropriate given full schema coverage.

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

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

The description clearly states the tool retrieves a domain and explicitly includes the data returned: DNS records and verification status. The verb 'Retrieve' matches the GET operation, and the description differentiates it from sibling tools like update_domain or delete_domain by indicating a read operation.

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

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

The description implicitly indicates this is for reading a domain's information, as opposed to updating, deleting, or verifying. However, it does not explicitly state when to use this over verify_domain or list_domains, but the read 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 burden, and it does a solid job: the explicit GET method and 'retrieve' make this a read-only, non-mutating operation, and it discloses that both the claim and TXT record will be returned. It does not discuss prerequisites or error behavior, but for a one-resource getter this is a reasonable transparency level.

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

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

One tight sentence conveys the operation, the scope (placeholder domain), the return contents, and the raw HTTP endpoint. No filler, no repetition of schema fields.

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

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

For a simple getter with one fully documented parameter and no output schema, the description covers the essential selection and invocation facts. It could add an explicit alternative (e.g., use verify_domain_claim to trigger verification) or response shape, but nothing critical is missing for a basic 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 coverage is 100% (id is clearly documented), so the baseline is 3. The description adds no param-level meaning beyond the endpoint path, which is acceptable but not enriching; nothing is hidden.

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 ('Retrieve'), resource ('current claim ... for a placeholder domain'), and explicitly includes the endpoint GET /domains/:id/claim. It also names a concrete part of the return payload (TXT verification record), which distinguishes it from generic domain getters and from claim_domain/verify_domain_claim.

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 context is implied: an agent would call this when it needs the existing claim/TXT verification record rather than creating or verifying a claim. However, it never names the relevant siblings or states when not to use it, so the routing guidance 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?

No annotations are provided, so the description carries the burden of disclosing behavior; 'Retrieve metadata' and the GET endpoint clearly indicate a read-only operation with no side effects. It also discloses a key observable output, download_url, which helps set expectations, though it does not mention auth requirements or rate limits.

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

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

The description is a single efficient sentence that front-loads the action, scope, endpoint, and key output. There is no filler or redundant restatement of the tool name.

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 read operation with no output schema, the description provides the required inputs, the scope, and the main return value. It could be more complete with response shape or permission/error details, but an agent has enough to invoke the tool correctly.

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

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

Schema description coverage is 100%, with id and attachment_id already described simply in the schema. The description adds the endpoint mapping and clarifies the attachment belongs to a sent email, but it does not add format, constraints, or additional parameter semantics beyond the schema.

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

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

The description clearly states it retrieves metadata for one attachment and explicitly scopes the operation to sent emails via 'sent email' and the endpoint path. This distinguishes it from sibling tools like get_received_email_attachment and list_email_attachments.

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 sent-email context is implied through the wording and endpoint, which helps differentiate it from received-email attachment tools, but it never explicitly names alternatives or states when to use this tool over them. No exclusions or alternate tool routing is provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses that this is a retrieval operation and that request/response bodies are included, but it does not mention auth requirements, potential truncation of bodies, error behavior, or retention limits. This is adequate but not rich.

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

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

The description is a single, focused sentence with no filler. The endpoint parenthetical adds useful context, and the core capability 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?

This is a simple one-parameter retrieval tool with full schema coverage, and the description clearly identifies the resource and the response content. Although there is no output schema and some behavioral details are absent, the description is complete enough for an agent to invoke the tool correctly with a log id.

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 'id' is already described as 'The log id.' The description does not add materially beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb and resource: 'Retrieve a single API log entry', which clearly distinguishes this tool from list_logs and other sibling tools. Including 'request/response bodies' and the endpoint 'GET /logs/:id' adds precise scope.

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

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

The phrase 'a single API log entry' gives clear context for when this tool is appropriate versus listing logs, and the endpoint implies a direct lookup by id. However, it does not explicitly name an alternative or state exclusion criteria such as 'use list_logs to find IDs 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 must carry the behavioral burden. It does convey a read-only retrieval via 'Get' and 'GET', and it discloses the result concept of an aggregated breakdown. However, it does not mention behavior for missing polls, error conditions, or response shape.

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

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

The description is a single sentence that front-loads the action and resource, adds the endpoint for precision, and includes no filler or 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 one-parameter read-only GET tool, the description provides enough information for an agent to understand what it does and what input is required. The main gap is the lack of detail about the exact breakdown structure and error behavior, but these are minor for invocation purposes.

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

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

The input schema already fully describes email_id with 100% coverage, so the description does not need to add much. It adds no extra format, constraints, or usage detail beyond the schema, placing it at the baseline.

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

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

The description names the specific action ('Get'), the resource ('poll'), and the scope ('for one email'), while also specifying the result type ('aggregated answer breakdown'). It clearly differentiates itself from collection-level siblings like list_polls by emphasizing a single email's poll.

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 'for one email's poll' implies a singular retrieval context, and the GET endpoint clarifies the operation, but there is no explicit guidance about when to use this tool versus alternatives such as list_polls, nor any stated 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 full burden of behavioral disclosure. It does communicate that this is a GET operation and therefore read-only, but it does not mention authentication requirements, rate limits, response format, or behavior when the id is not found.

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

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

The description is a single efficient sentence with the verb, resource, and endpoint all front-loaded. There is no wasted text, and the inclusion of the GET path adds useful precision 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 one-parameter single-resource fetch, the description is mostly adequate, but with no output schema and no annotations, it does not clarify what fields the returned email object contains or how it differs from get_received_email_raw. Some additional context would improve completeness.

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 description reinforces that the id selects the received email. It does not add meaningful format or syntax details beyond what the schema already provides, 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 uses a specific verb ('Retrieve') and resource ('single received email by id'), and includes the exact HTTP endpoint. This clearly distinguishes it from sibling tools like list_received_emails and get_received_email_raw.

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 about when to choose this tool over alternatives such as get_received_email_raw or list_received_emails. The 'by id' phrasing implies a usage condition, but no explicit when/when-not guidance is provided.

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

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

No annotations exist, so the description carries the full burden. It usefully discloses that the tool returns metadata (not raw bytes), includes download_url, and is a read-only retrieval of an existing attachment entry. This is sufficient for a simple metadata-fetch operation and clarifies what the agent will and will not receive.

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, and the core purpose is front-loaded. The parenthetical efficiently prevents confusion with the raw-bytes endpoint without expanding the description unnecessarily.

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 metadata retrieval with two fully documented parameters, the description covers the essential behavior and return content. No output schema or annotations exist, but the description gives enough for an agent 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?

Schema description coverage is 100%: both id and attachment_id are already described. The description adds no new parameter-level meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

Clearly states the operation: retrieve metadata for one attachment of a received email, including download_url. The description explicitly distinguishes this tool from the raw-bytes endpoint and implicitly from sibling get_email_attachment by restricting scope to received 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 provides clear guidance by contrasting this tool with the raw-bytes endpoint and stating it returns the metadata entry instead. It could explicitly name sibling tools like get_email_attachment or list_received_email_attachments, but the distinction from the alternative HTTP endpoint gives practical usage context.

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

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

With no annotations provided, the description carries the full burden. It states the return format ('raw message as text') and that it downloads the original message, implying a read-only operation. However, it doesn't disclose any potential side effects, error conditions, or authentication requirements. For a simple GET operation, this is adequate but not rich; it provides the essential behavioral detail but no extras.

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 that efficiently conveys the action, resource, and return type. It includes the endpoint path as a helpful reference without unnecessary fluff. Every word earns its place, and the key 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 simple one-parameter read tool with no output schema, the description is nearly complete. It specifies the resource and the return type. It could optionally mention the message encoding or note that this is the raw content versus parsed, but given the simplicity and sibling context, nothing critical is missing. The description is sufficient 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?

The schema covers the single parameter 'id' with a basic description ('The received email id.'). Since schema description coverage is 100%, the baseline is 3. The description does not add any additional meaning to the parameter beyond what the schema already provides, so no bonus is earned.

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 ('Download') and a clear resource ('the original RFC822/MIME message of a received email'), and even includes the endpoint path. It distinguishes this from sibling tools like get_received_email (which would return parsed fields) and get_received_email_attachment by focusing on the raw message. The purpose is unmistakable.

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

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

The description implies when to use this tool (when you need the raw RFC822/MIME message), but it does not explicitly mention alternatives or exclusion conditions. For example, it doesn't say 'Use this when you need the raw message instead of parsed fields; use get_received_email for parsed data.' The guidance is implicit but not explicit, so it meets the baseline but lacks direct 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?

No annotations are provided, so the description carries the behavioral burden. 'Retrieve' plus the GET method make the read-only nature clear, but the description does not mention response format, error behavior (e.g., 404), or authorization requirements. It is adequate but lacks richer behavioral context.

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

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

The description is a single sentence with zero fluff. It front-loads the operation and includes the exact endpoint, making it easy to parse quickly.

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

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

For a simple single-parameter GET tool, the description and schema together are sufficient to call it correctly. It does not explain the response shape, but 'retrieve a segment' implies the returned object, and no output schema is present. Minor gaps remain around error handling and response details.

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

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

The input schema has 100% documentation coverage for the single 'id' parameter, so the schema already explains the parameter. The description adds only 'by id', which restates the schema rather than providing additional semantic 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 uses a specific verb ('Retrieve') and resource ('a segment by id'), and the endpoint GET /segments/:id confirms the exact operation. It clearly distinguishes from sibling tools like list_segments, create_segment, update_segment, and delete_segment.

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: this tool should be used when you have a segment id and want that single segment's details. However, there is no explicit guidance comparing it to list_segments or other segment tools, nor any when-not-to-use 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 provided, the description carries the full burden of behavioral disclosure. The 'GET /templates/:id' endpoint explicitly signals a read-only, non-mutating operation, which is useful. However, it does not mention behavior for missing/invalid ids, response format, or any auth requirements, leaving some gaps for a no-annotation 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 a single concise sentence that includes the HTTP endpoint. It contains no fluff or repetition, and the core behavior 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?

This is a simple single-parameter retrieval tool, and the description provides enough information for an agent to invoke it correctly. It does not detail the return value or error cases, but given the low complexity and the implied response of the template object, the description is nearly complete for practical use.

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

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

Schema description coverage is 100% and the single parameter is already described as 'The template id.' The description adds no additional meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Retrieve') and resource ('a template by id'), making the operation unambiguous. It is clearly distinguishable from sibling tools like list_templates or create_template because it specifies retrieval of a single template via its id.

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 explicit guidance on when to use this tool versus alternatives such as list_templates. The 'by id' phrasing implies single-item retrieval, but there is no explicit when-to-use or when-not-to-use instruction.

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 signals a read-only operation through 'Retrieve' and the explicit 'GET' method, which is a strong transparency indicator. It does not mention error behavior or permissions, but for a simple fetch these are minor 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?

A single sentence with no redundant words. The action is front-loaded, and the parenthetical endpoint is a compact, useful addition. Every element earned 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 read operation with no output schema, the description is largely complete: it names the action, the resource, and the endpoint. It does not describe the response shape or error handling, but 'retrieve' sufficiently implies a single-object response. Minor gaps prevent a perfect score.

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 describes the only parameter ('id' as a string), so schema description coverage is 100%. The description does not add new semantic detail about the id format or behavior, which is acceptable but not value-adding beyond the schema.

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

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

The description clearly states the action ('Retrieve a topic by id') and the resource, distinguishing it from siblings like list_topics, create_topic, update_topic, and delete_topic. The verb+resource combination is unambiguous, and the HTTP path adds precision.

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