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

With no annotations, the description carries the full burden and explicitly discloses that passing null or empty unassigns, which is a key behavioral trait. It doesn't discuss permissions or error cases, but the core semantics are transparent for a simple mutation.

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 plus a minimal args list; every sentence serves a purpose and the main action is front-loaded. No redundancy.

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

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

For a simple two-parameter assignment tool with an output schema, the description covers the operation, parameter semantics, and unassign behavior. It doesn't address edge cases, but overall context is adequate.

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

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

Schema coverage is 0%, but the description compensates by explaining assigned_to semantics (empty/omit = unassign) and clarifying thread_id. The assigned_to definition adds meaning beyond the schema's type/default.

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 'assign' with a clear resource 'thread' and target 'agent or user', and distinguishes itself from sibling thread tools like tag_thread or set_thread_status by describing a distinct 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 (to manage thread assignment) and explicitly explains the unassign behavior, but it doesn't name alternatives or exclusion scenarios. It's functional but lacks explicit 'use this instead of X' 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 full behavioral burden. It discloses the required follow-up sequence (DNS records, verification), which is critical context. It does not mention potential side effects like cost or errors, but the workflow transparency is valuable.

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

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

The description is front-loaded with the core purpose, followed by a concise numbered list of required next steps and an Args section. Every sentence adds value, and the structure is easy to scan.

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

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

Given the presence of an output schema (not shown), the description need not explain return values. It covers the creation workflow and required post-steps, making it contextually complete for a create operation. Minor gaps like prerequisites or failure handling exist, but they are implied.

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

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

Schema description coverage is 0%, so the description must compensate. It does so effectively by explaining 'name' with a domain example and 'region' as an optional AWS region with examples. This adds meaning well beyond the raw schema types and required list.

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 'Create a new custom email domain' with a specific verb and resource, clearly distinguishing it from sibling tools like get_domain_records and verify_domain. The purpose is immediately obvious.

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

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

The description provides a clear post-creation workflow: call get_domain_records, add DNS records, then verify_domain. This implies this tool is the initial step, but it does not explicitly mention when not to use it or alternatives beyond the follow-up steps.

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 useful behavioral detail (auto-assign to available domain if domain_id omitted; no DNS setup needed) but does not cover failure modes, uniqueness constraints, or confirmation behavior. While it adds value, a more complete picture would improve safety and predictability for a write 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 well-structured with a lead statement, a concise explanation of the auto-assignment behavior, and a clear list of argument meanings. No word is wasted. Each part earns its place and the format is easy 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?

Given the tool's complexity (5 params, one required) and the presence of an output schema, the description provides near-complete invocation guidance. It covers all params, the core behavior, and a deployment nuance. It doesn't detail return values (output schema likely covers that) but is otherwise adequate for correct 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 coverage is 0% (no parameter descriptions in schema), but the description thoroughly documents all five parameters, including examples (e.g., local_part as 'support', 'billing', display_name as 'Support Agent'). It explains the role of `name` as a fallback for display_name and clarifies `domain_id` is optional, which is exactly the semantic information the schema lacks.

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

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

The description clearly states the tool's purpose: 'Create a new inbox for receiving emails.' It also provides the resulting email address format, distinguishing this tool from siblings like list_inboxes or create_domain. The verb is specific ('Create') and the resource is well-defined.

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

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

The description gives clear context for when to use this tool (when you need a new inbox) and includes a key benefit ('no DNS setup required'). It doesn't explicitly mention alternatives or exclusion cases, but the purpose is distinct enough from sibling tools, and the auto-assignment note helps the agent decide when to omit domain_id.

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

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

With no annotations, the description carries full burden. It discloses the primary output ('Returns a checkout_url') and valid bundle options, which is useful. However, it does not mention potential side effects, prerequisites (e.g., authentication), or error behavior (e.g., invalid bundle handling). For a payment tool, more transparency about the actual charge and session behavior would be expected.

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

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

The description is concise and front-loaded with the primary purpose, followed by the main output and valid bundles. The Args section is clean and directly useful. Every sentence contributes meaning without unnecessary fluff, making it well-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?

Given that an output schema exists (and the description already mentions the key output), the description covers the essential inputs and valid values. It lacks information about error cases, authentication requirements, or whether the checkout session is immediately charged, but for a straightforward purchase tool, it is reasonably complete. The 0% schema coverage raises the burden, but the Args section mitigates this.

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

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

Schema coverage is 0%, so the description must fully compensate. It does: the Args section explicitly explains both bundle (listing valid values) and return_url (optional, purpose). This adds significant semantic meaning that the schema itself lacks, making parameter understanding clear.

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+resource: 'Create a Stripe checkout session to purchase a credit bundle.' This distinguishes it from siblings like list_credit_bundles (listing) and get_credit_balance (querying). It is unambiguous about what the tool does.

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

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

The usage is implied: it is for purchasing a credit bundle and returns a checkout URL. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions. The description gives context (valid bundles, return_url) but lacks direct guidance on selecting this tool.

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

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

With no annotations provided, the description carries the burden of disclosing side effects. It only says 'Delete an inbox,' which restates the tool name and gives no details on permanence, permissions, 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?

The description is highly concise, using a single sentence for purpose and a simple arg list. It is front-loaded and free of fluff, but it omits useful context that could be added 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?

The tool has a destructive function, but the description gives no context about consequences, when to use it, or what output to expect. The presence of an output schema doesn't compensate for missing operational 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 description lists the two parameters with minimal explanations: 'The domain ID' and 'The inbox ID to delete.' These add only slightly to the schema's titles ('Domain Id', 'Inbox Id') and do not explain the meaning of a domain or why it's required.

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 'Delete an inbox,' which is a specific verb+resource statement. It distinguishes from siblings like create_inbox and list_inboxes by the delete verb, though it doesn't mention alternatives or 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 description provides no guidance on when to use this tool versus siblings such as create_inbox or list_inboxes. It lacks context about prerequisites, such as whether the inbox must be empty or belong to a specific domain.

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 full behavioral burden. It discloses that the URL is temporary and the default expiration (1 hour), but does not mention any other side effects, auth requirements, or error behavior. This is adequate for a simple get operation but lacks depth.

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

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

The description is two sentences, with a clear first sentence followed by a concise parameter list. Every word earns its place; no fluff.

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 (2 params, output schema exists). The description covers the core functionality and parameters, and with an output schema present, return values need not be spelled out. It could mention prerequisites like having an existing attachment ID, but overall it is sufficiently complete for an agent 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 has 0% description coverage, but the description explains both parameters: attachment_id as 'The attachment ID' and expires_in as 'URL lifetime in seconds (default: 3600 = 1 hour)'. This adds meaning beyond the schema types and defaults, effectively compensating for the lack of schema descriptions.

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

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

The description uses a specific verb 'Get' with a clear resource 'temporary download URL for an attachment', and the 'temporary' qualifier distinguishes it from any other URL retrieval tool. It clearly states what the tool does.

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

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

The description does not explicitly state when to use this tool vs alternatives, but the purpose is clear enough that it implies usage after an attachment has been uploaded. However, there are no exclusions or alternative tool references.

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 transparently lists the return components (included credits, purchased credits, total available, credits used this billing cycle), which gives the agent insight into what to expect. However, it doesn't mention any potential side effects or prerequisites, though for a simple getter this is largely sufficient. It adds value beyond the name by detailing the output.

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

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

The description is two sentences long, front-loaded with the primary purpose, and free of any fluff or repetition. Every sentence adds value: the first states what it does, the second details the return fields. This is an exemplary model of conciseness.

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

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

Given the simplicity of the tool (no parameters, no annotations, output schema exists), the description is fully complete. It clearly names the resource ('Commune account'), states the action, and enumerates the returned data. The agent has everything needed to select and invoke this tool correctly without additional context.

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

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

The tool has zero parameters, so the schema is empty with 100% coverage. The description doesn't need to explain any parameters. Per the rubric, a baseline of 4 is appropriate for a no-parameter tool.

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

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

The description clearly states the tool's purpose: 'Get current credit balance for your Commune account.' This is a specific verb+resource structure that distinguishes it from siblings like 'list_credit_bundles' or 'credits_checkout'. It also enumerates the exact pieces of information returned, leaving no ambiguity about the tool's function.

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

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

The description clearly conveys when to use this tool—whenever a user needs their current credit balance and its breakdown. It doesn't explicitly mention alternatives or exclusions, but the sibling tools are functionally distinct, so context alone is sufficient. The description is clear and unambiguous, warranting a 4 rather than 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 provided, the description carries the full burden of behavioral disclosure. It explains the metrics and rates returned, and recommends inbox_id filtering. However, it does not clarify aggregate scope when no filters are passed or mention read-only behavior explicitly, though the 'get' verb implies it. No contradiction with annotations (none exist).

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

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

The description is concise and front-loaded with purpose. It has a clean structure with a purpose statement, a sentence on outputs, a usage context sentence, and an args list. Every sentence provides value without waste.

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

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

The description sufficiently covers purpose, usage, and all parameters. An output schema exists, so return value details are encoded elsewhere. It could mention when to prefer get_delivery_events for individual events, but this is not critical for basic tool selection and 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 input schema has no descriptions (0% coverage), so the description fully compensates by explaining each parameter: 'inbox_id: Filter metrics by inbox (recommended)', 'domain_id: Filter metrics by domain', and 'period: Time period — "24h", "7d", "30d" (default: "7d")'. This adds meaning beyond the schema properties.

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 'Get email deliverability metrics: sent, delivered, bounced, complained, failed' with a specific verb and resource. It also lists derived rates (bounce, complaint, delivery) and distinguishes itself from siblings like get_delivery_events (which fetches individual events) and get_suppressions (which manages suppressions), making the tool's purpose unambiguous.

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

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

The description provides a clear use case: 'Use this to monitor sender reputation and identify deliverability issues.' It does not explicitly mention alternatives or when not to use the tool, but the context is sufficient for an agent to decide between this and related tools.

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

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

Since no annotations are provided, the description carries full responsibility for behavioral transparency. It clearly indicates a read-only operation via 'Get' and lists the event types. However, it does not disclose pagination behavior, ordering, or any potential side effects. The lack of explicit safety statements is somewhat mitigated by the inherently read-only nature of the tool, but important behavioral details are missing.

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 succinct and well-structured, with a brief summary followed by a clean Args list. Every sentence adds value, and there is no redundant or filler content. The format makes it easy for an agent to parse the core purpose and parameter semantics 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?

Given the tool's moderate complexity (five optional filters, output schema present), the description covers the essential aspects: purpose, filters, and default limit. It does not explain ordering or pagination behavior, but the presence of a limit parameter implies basic paging. Overall, the description is sufficiently complete for an agent to use 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 has no property descriptions (0% coverage). The description's Args list fully compensates by explaining all five parameters: message_id, inbox_id, domain_id, event_type, and limit. It provides enum-like values for event_type and the default limit, adding meaning beyond the schema's bare type information.

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 'Get delivery event log' and enumerates the event types (sent, delivered, bounced, complained, failed), specifying the resource and action. It also explains the use case: 'Track the lifecycle of individual emails or audit delivery across an inbox.' This distinguishes it from sibling tools like get_deliverability_stats and get_suppressions by focusing on the event log 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 provides clear usage context: tracking individual email lifecycle or auditing delivery across an inbox. It implies when to use the tool but does not explicitly contrast it with alternatives or state when not to use it. There are no exclusionary guidelines, so this meets the 'clear context, no exclusions' criterion.

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 transparency burden. It correctly specifies the return types (MX, TXT, CNAME) and the registrar context, but it does not explicitly state that the operation is read-only/no side effects, nor does it mention potential error conditions, leaving some 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 extremely concise and front-loaded, with the main purpose stated first. The return type summary and the parameter explanation each add value with no wasted words.

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

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

For a tool with a single parameter and an output schema, the description covers the essential purpose, usage context, and parameter origin. The output schema handles return structure, so the description is sufficiently complete, though it could mention error scenarios.

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 only defines 'domain_id' as a string with 0% description coverage. The description compensates by explaining that the ID comes from list_domains, adding practical source context that the schema lacks.

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 'Get' and the resource 'DNS records required to verify a domain.' It explicitly distinguishes from the sibling verify_domain by explaining these records are prerequisites for that 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 description provides clear context by stating 'before calling verify_domain,' indicating when this tool should be used. It does not explicitly name alternatives or when-not scenarios, but the guidance is clear enough for a simple read operation.

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

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

With no annotations, the description carries the full transparency burden. It explains that suppressed addresses are automatically skipped during sending and that the tool lists them, which conveys read-only behavior and domain context. It doesn't mention rate limits or pagination beyond the limit parameter, but the output schema covers return structure.

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 compact: a one-line purpose, a one-line usage note, and a clear Args list. Every sentence serves a purpose and the structure makes parameters easy to scan.

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

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

For a read-only list tool with an output schema and three optional parameters, the description covers purpose, usage, and parameters well. The existence of an output schema means return value details are already available. There are no missing critical 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 description includes an Args section that explains each parameter (inbox_id, domain_id, limit) and their optional/default nature, while the schema only provides types and defaults. This fully compensates for the 0% schema description coverage and adds meaningful 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 opens with 'List suppressed email addresses' – a specific verb and resource – and immediately clarifies the types (bounces, complaints, unsubscribes). This clearly differentiates it from sibling tools like list_sms_suppressions and get_delivery_events.

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

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

The phrase 'Use this to audit why certain recipients aren't receiving emails' provides a clear context for when to invoke the tool. It doesn't explicitly compare to alternatives or state when not to use it, so it falls short of a perfect 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 burden. It discloses the return shape and parameter behavior (limit range/default, order options). The phrase 'Get all messages' is slightly misleading given the limit cap, but the parameter details clarify the actual behavior, so the transparency 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?

The description is compact and well-structured: a one-line purpose, a one-line return summary, and an Args list with clear parameter explanations. Every sentence adds value, and the formatting makes the parameters scannable.

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

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

For a simple read tool with an output schema, the description covers purpose, return value, and all parameters. However, it could benefit from briefly mentioning when to prefer this over get_thread_metadata or search_threads, and clarifying the 'all' vs limit relationship.

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 no descriptions (0% coverage), and the description fully compensates by explaining each parameter: thread_id's source (from list_threads), limit's range and default, and order's allowed values with meaning. This provides essential semantic information beyond the raw 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 identifies the tool's function with a specific verb and resource: 'Get all messages in an email thread.' It distinguishes itself from sibling tools like get_thread_metadata (metadata) and get_sms_thread (SMS) by specifying email thread messages.

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 by describing the returned data (full conversation with sender, content, timestamps), which helps an agent decide when to use this tool. However, it does not explicitly name alternatives or exclusion criteria, so it lacks the 'when-not' guidance required for 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 present, so the description carries the full burden. It indicates a read operation ('Get') and enumerates the returned fields, which is some transparency. However, it does not disclose error handling, permissions, or response behavior beyond those fields.

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

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

The description is concise: a single sentence stating the purpose followed by a minimal args block. Every part is relevant and front-loaded, with no unnecessary fluff.

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 getter, the description is functional but sparse. It does not guide the agent on when to use this tool alongside many thread-related siblings, and the parameter documentation is unhelpful. The output schema may cover return values, but the description still lacks usage direction.

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 thread_id is described as 'The thread ID,' which merely restates the parameter name and schema title. It provides no additional meaning about format, source, or constraints, and schema coverage is 0%.

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 ('Get'), resource ('thread'), and scope ('triage metadata: tags, status, and assignment'). This distinguishes it from sibling tools like get_thread_messages (messages), list_threads (listing), and mutation tools like tag_thread.

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 provided on when to use this tool versus alternatives. It does not mention exclusions or recommend sibling tools for different use cases, leaving the agent to infer based on the name and description 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 provides the key behavioral detail – that it returns each bundle's ID, credit amount, price, and description. The verb 'List' implies a read-only operation with no side effects, which is transparent enough. It does not add extra context like auth requirements or rate limits, but for a simple list operation that's acceptable.

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

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

The description is two short sentences: the first states the action, the second lists the return fields. 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 very simple with no parameters, output schema exists, and the description covers the return content. There is no missing information for an agent to invoke it correctly.

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

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

The tool has zero parameters, so the description need not explain parameter details. The empty schema is fully covered. The baseline of 4 applies.

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

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

The description opens with 'List available credit bundles that can be purchased,' clearly identifying the action (List) and resource (credit bundles). It distinguishes from sibling tools like get_credit_balance and credits_checkout by focusing on purchasable bundles. The return fields further specify purpose.

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 context is clear: this tool is for retrieving purchasable credit bundles. It does not explicitly mention alternatives or exclusions, but the simple no-parameter nature and phrasing make the use case self-evident. However, it leaves any comparison to get_credit_balance or credits_checkout 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?

No annotations are provided, so the description carries the full burden. It discloses the read-only list behavior and specifies the return fields (ID, name, verification status), offering adequate transparency for a simple list operation. No side effects are mentioned, but none are implied.

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

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

The description is three sentences, each earning its place: first states the purpose, second lists return fields, third explains downstream usage. 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?

Given the zero parameters, the presence of an output schema (handling return details), and the simple list nature, the description covers purpose, output, and usage context. It is complete for this 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?

The tool has zero parameters, so the input schema is fully covered and there is no need for parameter documentation. Baseline score of 4 is appropriate for a parameter-free tool.

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

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

States the specific verb 'List' with resource 'email domains' and scope 'in your Commune account', clearly distinguishing it from sibling tools like create_domain, verify_domain, and get_domain_records which involve creation, verification, or record retrieval.

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

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

Provides clear context by explaining that the domain IDs returned should be used with other tools like list_inboxes or create_inbox, signaling when to call this tool. However, it does not explicitly mention alternative list tools or exclusion criteria.

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 is the sole source of behavioral context. It discloses the scope behavior (all domains vs. specific domain) and the local_part relationship, but does not explicitly state read-only status, side effects, or authorization requirements.

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

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

The description is compact, starting with a clear action and then elaborating on the optional parameter and the email address format. It is well-structured and avoids unnecessary verbosity.

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

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

For a simple list operation with one optional filter and an output schema, the description covers the core behavior and parameter meaning. It could optionally mention pagination or ordering, but these are likely captured in the output schema or are not critical for this tool.

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

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

The schema only defines domain_id as an optional string. The description adds that it filters by domain and that omitting it lists all inboxes, providing necessary semantic meaning that the schema lacks.

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

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

The description clearly states the tool's function with a specific verb ('List') and resource ('inboxes'). It then explains the two modes (all domains vs. specific domain) and provides useful context about email address composition, making its purpose unambiguous and distinct from sibling tools.

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

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

The description explains the behavioral difference when domain_id is present or omitted, which serves as clear usage guidance. It does not explicitly name alternative tools, but the context makes it obvious when to use this tool versus others like create_inbox or delete_inbox.

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 discloses pagination behavior (next_cursor), default ordering, response fields (subject, message count, last activity, snippet), and the necessity of filters. It does not mention permissions or rate limits, but for a read-only listing operation, this is sufficient.

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 well-structured with a brief introduction, return format note, usage requirement, and an Args list. Every sentence provides value, and there is no redundancy or fluff.

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

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

The description is complete for a list operation. It covers key behavior (pagination, filtering, sorting), return summary fields, and parameter constraints. Since an output schema exists, it need not describe every return field, but it still gives the essential information for correct usage.

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

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

Schema description coverage is 0%, but the description fully compensates by explaining each parameter's purpose and constraints: inbox_id for filtering, domain_id as alternative, limit range 1-100, cursor for pagination, and order with desc/asc defaults. This adds significant meaning beyond the schema's type-only definitions.

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 'List email threads (conversations) with pagination,' which is a specific verb+resource. It differentiates from sibling tools like search_threads and get_thread_messages by focusing on listing with pagination and summarizing thread attributes.

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 explicit usage context: returning thread summaries, pagination via next_cursor, and the requirement to provide at least one of inbox_id or domain_id. It does not explicitly discourage use of alternative tools, but the pagination and filter requirements are clear usage guidelines.

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 disclosing behavioral traits. It states only that it removes the schema, but does not mention side effects (e.g., whether extraction stops immediately, if the operation is reversible, or if any data is destroyed). This is a mutation operation with no disclosed consequences, similar to the under-transparent update_drive example.

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

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

The description is a single, short sentence that is front-loaded with the core action. It wastes no words and is easy to scan. However, it is so sparse that it barely adds value beyond the tool name itself, so it does not earn a 5, but it is certainly concise.

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 simplicity of the tool (2 params, no nested objects) and the presence of an output schema, the description is still incomplete. It lacks context about the relationship to set_extraction_schema, when removal is appropriate, what happens upon removal (e.g., does extraction stop immediately?), and any prerequisites. This would hinder an agent in deciding when to invoke it.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning, but it does not reference domain_id or inbox_id at all. The parameter names are somewhat self-explanatory, but there is no explanation of how to find these IDs or what values are valid. The schema provides only types and required flags, leaving the agent to infer the semantics.

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 ('Remove') and clearly identifies the resource ('structured extraction schema') and the target ('an inbox'). It distinguishes the tool from siblings like set_extraction_schema (which sets the schema) and delete_inbox (which removes an inbox entirely). The purpose is unambiguous and well-scoped.

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. It does not mention that it is the inverse of set_extraction_schema, nor does it suggest prerequisites such as listing inboxes first to obtain the inbox_id. There is no contextual information about typical workflows or conditions that would favor this tool.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the return format ('matching thread summaries with subject, snippet, and message count') and the constraint about requiring at least one filter. It implies a read-only operation by using 'Search' and 'Returns', but does not explicitly state it is non-destructive or mention any rate limits or authentication requirements. Overall, it provides solid context but leaves a few behavioral aspects implicit.

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

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

The description is concise and well-structured. It opens with a one-sentence purpose, then one sentence about return value, one sentence about the required filter condition, and a neatly formatted Args list. Every sentence earns its place, and the structure makes it easy to scan for key details like the filter requirement and parameter semantics.

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?

Despite having no annotations, the description is complete enough for an agent to select and invoke the tool correctly. It covers the main behavior, return format, filter prerequisites, and parameter ranges. An output schema exists, so detailed return types are not strictly necessary, but the description still provides a helpful summary. Minor gaps like pagination (beyond limit) and error behavior are not critical for a search 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 0%, so the description must compensate, and it does thoroughly. The 'Args' section explains each parameter's purpose in plain language: query 'searches subject and message content', inbox_id 'Filter by inbox (recommended)', domain_id 'Filter by domain', and limit 'Max results, 1-100 (default: 20)'. It also clarifies the domain_id/inbox_id relationship in the main description. This adds substantial meaning beyond the raw 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 what the tool does: 'Search across email threads by subject or content.' It uses a specific verb ('search') and resource ('email threads'), and it distinguishes itself from sibling tools like 'list_threads' (which likely lists all threads), 'search_sms' (different resource), and 'get_thread_messages' (retrieves messages). The mention of returning matching thread summaries further clarifies the 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 description provides explicit usage guidance: 'Provide at least one of inbox_id or domain_id.' It also labels 'inbox_id' as 'recommended' for filtering, giving a preference. However, it does not explicitly state when to use this tool over alternatives (e.g., 'use list_threads to list all threads'), so it misses the 'when-not-to-use' aspect. Still, the advice is actionable and 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 transparency burden. It discloses key behaviors: body supports html/text with fallback, attachments require a prerequisite upload, thread_id enables replying, and domain is auto-inferred from inbox_id. It lacks details on errors or permissions but provides meaningful context beyond a bare 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 front-loaded with a one-line purpose, followed by brief usage notes and a structured Args list. Minor redundancy exists (e.g., thread_id and attachments are explained both in prose and Args), but the overall structure remains clear and easy 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?

The description covers the essential operational context for a 10-parameter tool: attachment ordering, threading, html/text alternatives, and inbox/domain resolution. It does not mention error handling or authorization, but the output schema exists and the description equips an agent to invoke the tool correctly in the common paths.

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

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

Schema has 0% description coverage, and the Args section fully compensates by explaining all 10 parameters with practical details: comma-separated recipients, copy fallback, optional senders, and the upload_attachment dependency. This is a strong compensation for the silent 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 opens with 'Send an email message,' a specific verb+resource pair that clearly identifies the tool's function. It naturally differentiates from sibling tools like send_sms by specifying email, and the name itself reinforces the purpose.

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 practical guidance: html/text body options, reply via thread_id, attachment workflow requiring upload_attachment first, and inbox_id/domain inference. However, it does not explicitly state when to choose this over send_sms or mention exclusions, so it falls 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?

There are no annotations, so the description must disclose behavior. It does not mention whether this overwrites an existing schema, validates the JSON schema input, or has side effects on extraction. The `enabled` parameter indicates immediate activation but without further 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 concise and well-organized as an Args list. Each line is informative, though the format is a bit terse and lacks a narrative lead-in. No excessive verbiage.

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

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

Given no annotations, six parameters, and a configuration setter with potential overwrite/validation behavior, the description is incomplete. It does not explain preconditions (e.g., inbox must exist), failure modes, or whether this is an upsert versus create-only operation.

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

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

Schema description coverage is 0%, so the description carries the full burden for parameter meaning. It provides brief but useful definitions for all six parameters, including the crucial 'JSON string of a valid JSON Schema object' for `schema` and defaults for `enabled` and `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 states 'Set structured extraction schema for an inbox,' using a specific verb and resource. It clearly distinguishes itself from siblings like remove_extraction_schema and other unrelated 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?

No guidance is given on when to use this tool versus alternatives, nor are there prerequisites or exclusions mentioned. The description only states what it does, leaving the agent to infer context from the tool name and siblings.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It states valid statuses but does not mention side effects, reversibility, permissions, or what happens on invalid input. As a mutation tool, this lack of behavior context 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 short and front-loaded with the core action. However, the list of valid statuses is repeated twice (in the intro and in the Args section), which is slightly redundant but not overly verbose.

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 only two parameters and an output schema exists, so return values need not be described. The description covers the essentials for making a call, but lacks context about side effects, edge cases, or how this relates to other thread triage operations.

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

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

Schema description coverage is 0%, but the description fully compensates by explaining both parameters: thread_id is 'The thread ID' and status is 'New status — one of: open, needs_reply, waiting, closed' with the allowed values repeating in the prose. This adds meaning well beyond the bare 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 and resource: 'Set the status of a thread for triage.' It clearly distinguishes this from siblings like assign_thread, tag_thread, and untag_thread by focusing on the status field specifically.

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 triage' implies the tool is meant for updating triage status, but the description does not explicitly compare it to alternatives or state when not to use it. Usage is implied rather than fully spelled out.

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 full responsibility for behavioral disclosure. It thoroughly explains the submission behavior: what each feedback type means, what content to include in the message, and how to use the context dict. It even gives examples of good and bad feedback behavior. The description also states the message length limit (4000 chars), adding 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 well-structured and front-loaded: the purpose and usage appear in the first two sentences. It then uses clear headings for feedback types and an 'Args' section. Despite its length, every sentence is informative, with examples that replace verbose prose. No redundancy or fluff.

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 feedback tool with no annotations and zero schema descriptions, this description is exceptionally complete. It covers the tool's purpose, when to use it, how to categorize feedback, what to include in messages, and how to structure context. The output schema handles return values, so those need not be described. The presence of examples further enhances 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 0%, but the description compensates fully in the 'Args' section. It explains 'type' with its enum values ('error', 'feature', 'signal'), describes 'message' and its max length, and details 'context' with a concrete JSON example. This adds significant semantic meaning beyond the bare schema definition.

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 clear, specific statement: 'Submit feedback about Commune to the product team.' This uses a specific verb ('submit') and resource ('feedback about Commune'), and it is distinct from all sibling tools (e.g., send_sms, create_domain). It further clarifies purpose by defining three feedback types, eliminating 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 description explicitly states when to use the tool: 'Use this tool whenever you encounter something worth reporting — an error, a missing capability, or an observation.' It provides detailed criteria for each feedback type with concrete examples, giving the agent clear usage guidance. No alternative feedback tools exist among siblings, so no exclusions are needed.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It explicitly states 'Tags are additive — existing tags are preserved', which is a key non-obvious behavior. It also clarifies the comma-separated format. It does not cover edge cases like duplicate handling or permission requirements, but the core behavior is well disclosed.

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

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

The description is tightly structured: a one-sentence purpose, a usage note, and an Args block. Every sentence contributes vital information without redundancy or fluff.

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 covers purpose, behavior, and parameter format. The output schema exists, so return values need not be described. Minor gaps like idempotency or error handling are not critical for basic usage, so this is nearly complete 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 0%, so the description must compensate. It does so by explaining both parameters: thread_id is identified simply, while tags gets a clear format and example ('Comma-separated tags to add (e.g. "urgent,vip,sales-lead")'), adding significant meaning beyond the bare 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 'Add tags/labels to a thread' with a specific verb and resource. It differentiates from sibling tools like untag_thread by explicitly noting the additive behavior, making its purpose unambiguous.

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

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

The description provides examples of tag usage ('vip', 'bug-report', etc.) and shows a concrete argument format, which implies when to use this tool. However, it does not explicitly contrast with alternatives like untag_thread or state when not to use it, leaving usage guidance somewhat 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?

With no annotations, the description does not disclose behavioral traits such as reversibility, idempotency, permissions, or error behavior. It only states the action and parameters.

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, with a single purpose sentence and a minimal Args list. No filler 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?

While the tool is simple with only two parameters, the description lacks usage guidance and behavioral transparency. However, since an output schema exists, the absence of return documentation is not penalized. The description is adequate but could benefit from context on when to use it.

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

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

The schema has 0% description coverage, so the description's Args section is essential. It defines thread_id as 'The thread ID' and tags as 'Comma-separated tags to remove' with an example, adding format and meaning.

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

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

The description uses the specific verb 'Remove' with the resource 'tags/labels from a thread', clearly distinguishing it from the sibling 'tag_thread' which adds tags.

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 guidance on when to use this tool versus alternatives such as tag_thread or assign_thread, nor does it state prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It states that the tool uploads a file and returns an attachment_id, but it does not disclose any side effects, auth requirements, rate limits, or file size restrictions. The description is not misleading but adds only the basic behavioral expectation.

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 well-structured, with a one-sentence summary, a clear note about the return value, and an Args block with three lines of parameter guidance. Every sentence serves a purpose and nothing is redundant.

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

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

For a simple 3-parameter tool with an output schema, the description provides the essential context: what the tool does, what input is expected, and what the output is used for. It lacks but does not desperately require details like size limits or retention policies, so it is 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?

The description adds valuable meaning beyond the schema's bare property titles: it explains that 'content' must be Base64-encoded and provides concrete examples for 'filename' and 'mime_type'. This compensates for the 0% schema description coverage, though it does not mention limits or format edge cases.

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 'Upload' and the resource 'a file for use when sending emails', which distinguishes it from siblings like 'send_email' and 'get_attachment_url'. It also specifies the return value (attachment_id) and its purpose, making the tool's role obvious.

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

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

The description provides clear context that this tool is for uploading files to be used with 'send_email' via the returned attachment_id. It does not explicitly mention when not to use it or suggest alternatives, but the intended usage is evident from the wording and the sibling 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, the description must fully disclose behavioral traits. It states the action but does not mention side effects, asynchronous behavior, potential delays, or error conditions. The prerequisite about DNS records is useful but insufficient for a mutation-like tool.

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

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

The description is two short sentences plus a compact Args section. It front-loads the purpose and includes only essential information without any filler.

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

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

For a simple one-parameter trigger tool, the description covers purpose, prerequisite, and parameter source. The existence of an output schema reduces need to explain return values. However, it omits whether verification is synchronous or if the domain status updates immediately.

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

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

The schema has 0% description coverage, so the description must compensate. It does so by explaining domain_id as 'The domain ID (from list_domains)', which adds source context beyond the bare schema definition. However, format or examples are not provided.

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

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

The description clearly states the tool's function: 'Trigger DNS verification for a domain.' This is a specific verb+resource pair that distinguishes it from siblings like get_domain_records or list_domains.

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

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

Explicit guidance is provided: 'Call this after adding the required DNS records at your registrar. Use get_domain_records first to see which records are needed.' This tells the agent when to use the tool and directs it to a relevant alternative for prerequisite info.

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