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

With no annotations, the description carries full burden and discloses key behaviors: recording an assignment event, rejection if agent not a member, and required 'send' credential. Extra detail on pricing adds 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?

Three sentences are tightly written with no wasted words; the main action is stated first, followed by usage guidance and qualifications.

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

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

Given the tool's simplicity (2 required params, no output schema), the description covers all needed aspects: purpose, usage, conditions, and parameter sources, leaving no gaps.

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

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

Schema coverage is 100%, so the description adds value by specifying source functions for each parameter (list_tickets, list_agents), expanding on the schema's basic 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 ('Assigns') and resource ('ticket to a human agent'), and clearly distinguishes from siblings like 'create_ticket' and 'send_reply' by focusing on assignment.

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 provides explicit context for when to use ('route or hand off a ticket to a specific teammate') and includes necessary conditions (agent membership, credential tier), though it does not enumerate 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 provided, the description carries full responsibility for transparency. It discloses ownership (wallet paying), authentication requirements (no account needed), return values (URL, API key, deposit addresses), limitations (one board per wallet), recovery path (rotate_board_key), and costs (price: $5.00). No side effects are omitted.

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 informative but contains some redundancy (e.g., repeating 'one board per wallet' and the key-loss remedy). While each sentence adds useful detail, it could be tightened without losing clarity. It remains well-structured and avoids 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?

Since there is no output schema, the description adequately explains what the tool returns (board URL, API key, deposit addresses). It also covers ownership, constraints, and referral details, making the tool's behavior fully comprehensible in 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?

Schema descriptions are high coverage (100%) for both parameters. The tool description adds minimal value beyond the schema, only restating the referrer purpose in shorter form. The schema already provides detailed explanations of name and referrer, so the description adds little new 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 clearly states the tool's function: 'Create your own open bounty board'. It specifies the action (create) and the resource (bounty board), and distinguishes it from sibling tools like create_issue or rotate_board_key by focusing on board creation and explicitly noting the alternative for lost 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 description provides explicit guidance on when to use the tool: to create a new board, with no account needed, and mentions the one-board-per-wallet constraint. It also directs users to rotate_board_key for lost keys, serving as an explicit alternative, and explains the referrer mechanism for crediting agents.

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 provided, so description carries full burden. It discloses that it's a write operation that only adds a new issue without modifying existing ones. Mentions default status and cost.

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

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

Two sentences plus cost note, all front-loaded. First sentence states purpose and default, second gives usage and safety info. 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?

Given no output schema and simple creation tool, description covers purpose, usage, parameter guidance, and behavioral transparency completely.

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 cover all 3 parameters. The description adds value by instructing to compose body from conversation and write title from user request, and clarifies enum meanings.

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 it creates a bug report or feature-request issue in the tenant's issue tracker, with default status 'open'. Differentiates from siblings like 'create_ticket' which is for support tickets.

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 says to use when a defect or feature idea surfaces that needs triaging. Does not explicitly state when not to use, but context implies alternatives exist.

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 key behaviors: find-or-creates customer by email, records first message, and explicitly states no email/notification is sent. It also mentions the return values. This is transparent but could add more about side effects (e.g., whether the ticket is immediately visible or any persistence details). Still, it's substantially informative.

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 plus a price tag, front-loaded with the core purpose. Every sentence earns its place: the first states what it does and returns, the second gives usage context and key exclusions. 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 tool is a mutation with no output schema, but the description covers return values, side effects, and usage context. It mentions the find-or-create behavior, records the message, and the no-notification aspect. It doesn't mention defaults like priority (though schema does) or any authentication prerequisites, but those are assumed. Overall, it's fairly complete 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 100%, so the baseline is 3. The description doesn't add significant meaning beyond the schema's param documentation; it reinforces that 'records the customer's first message' ties to the body parameter, but the schema already explains that. No extra clarity is provided for parameters like priority or customerName beyond what's 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 it 'Files a new support ticket for an end customer on this tenant' and returns specific fields (ticketId, customerId, status). It distinguishes from sibling tools like create_issue by specifying it's for support tickets, and the verb-resource pair is unambiguous.

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

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

Provides explicit usage: 'Use this when an agent needs to log a new customer issue or request' and discloses what it does NOT do ('does NOT send any email or notify the customer'). However, it doesn't name alternative tools or explicitly state when not to use it, 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?

With no annotations, the description carries full behavioral burden. It discloses that the draft is not sent (delivered:false), notifies the thread of pending approval, returns draft id and ticket id, and details content rules with refusal and strike/suspension consequences. Comprehensive and truthful.

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 lengthy but every sentence adds value: purpose, usage, return format, content rules, and pricing. It is front-loaded with the core purpose and usage, then dives into details. No fluff, but could be slightly tightened by removing repetitive phrasing like 'rather than to look up or send anything directly' though it's not excessive.

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 has no annotations and no output schema, the description covers all necessary aspects: purpose, usage, behavioral consequences, return values, content constraints, and cost. An agent has everything needed to invoke it correctly and understand what happens on success or violation.

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%, but the description adds significant value for the body parameter: content rules (plain text, markdown only, no HTML/scripts/link text matching) go beyond the schema's basic 'plain text' description. It does not re-explain what schema already covers for ticketId/referrer, but the added body constraints are meaningful.

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 ('propose'), resource ('reply on a support ticket'), and clarifies it is saved as a DRAFT, not sent. It explicitly distinguishes from direct sending or lookup, 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?

It clearly states when to use this tool ('once you have a ready answer ... want a human to review and send it') and contrasts with alternatives ('rather than to look up or send anything directly'). This gives explicit decision guidance 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, the description fully discloses behavior: nothing stored, nothing sent, AI-generated reply for human review. Explicitly states customer_message and product_context are untrusted content, never instructions. No contradictions.

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 plus cost note. Front-loaded with core action. No extraneous words. 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?

Adequately covers inputs and output ({ draft, disclaimer }). No output schema but description explains return. Could be improved by clarifying disclaimer role, but overall complete for a drafting tool.

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

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

Schema coverage is 100%, baseline 3. Description adds value: clarifies product_context as 'optional background about the product/service' and emphasizes untrusted content. Specifies length limits and tone default, exceeding schema info.

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 'Draft a professional customer-support reply from a raw customer message.' Distinguishes itself by noting tenant-agnostic and no account/ticket id needed, which differentiates it from siblings like 'draft_reply' and 'send_reply'.

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 on when to use (drafting for human review) and what to expect (AI-generated draft + disclaimer). Includes cost note. Lacks explicit 'when not to use' but implicitly covered by the send/save prohibition.

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 explicitly states 'Read-only' and lists all returned data types. It also mentions a price. It does not discuss rate limits or errors, but overall it is quite transparent about 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 comprehensive yet concise, front-loading the key fact 'Read-only'. It lists the components and usage guidance efficiently. A minor point: some phrases could be merged, but overall it is 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 there is no output schema, the description fully explains what the tool returns (thread, profile, other tickets, similar resolved, KB articles). It also provides usage context (for drafting or triage) and price. This is complete for a context-fetching tool.

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

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

Schema coverage is 100%, so baseline is 3. The description does not add significant new meaning beyond the schema; it provides context (e.g., 'full message thread' hints at threadLimit) but does not explain parameter semantics beyond what the schema already does. The description adds no new semantic info.

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 is a read-only tool that returns a comprehensive working bundle for a single ticket, including thread, customer profile, other tickets, similar resolved tickets, and KB articles. It distinguishes itself from siblings by explicitly saying 'Reach for this first when you have a ticketId' and noting it writes nothing.

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

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

The description explicitly tells when to use: 'when you have a ticketId and need everything required to understand and answer it'. It also indicates when not to use by stating 'it writes nothing and sends nothing to the customer', differentiating it from write or send tools.

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

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

With no annotations provided, the description bears full responsibility and does well: it explains the effect (adds issue_link entry), the optional note, and failure case (NOT_FOUND). It also includes a price hint. It is transparent and covers key behavioral aspects.

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

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

The description is three sentences with no wasted words. It front-loads the purpose and then provides usage guidance and side effects. 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 simplicity and absence of an output schema, the description covers all essential aspects: purpose, use case, side effects, prerequisites, and failure mode. It is complete for an AI agent to decide and invoke 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 100% description coverage, so baseline is 3. The description adds value by explaining the relationship of the note parameter and noting the default behavior if omitted, which enriches 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 clearly states the action: 'Associate an existing support ticket with a tracked issue.' It uses specific verbs ('Associate', 'record') and resources ('ticket', 'tracked issue') and distinguishes itself from siblings like create_issue or create_ticket by focusing on linking existing entities.

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

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

The description explicitly tells when to use: 'when a customer's ticket is caused by, or asks for, a known issue.' It also clarifies what the tool does NOT do (change status or notify) and prerequisites (both must exist), providing clear usage guidance.

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

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

With no annotations provided, the description takes full responsibility for behavioral disclosure. It states the tool is read-only, never creates or modifies anything, returns only public information, is free, and explains the two types of work (plain bounties and contests with entry fees and capped entrants). This is exhaustive 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 with clear sections for plain bounties and contests, and uses formatting like ALL CAPS for emphasis. It is slightly verbose with some repetition (e.g., 'read-only' and 'never creates or modifies anything' convey similar meaning), but every sentence adds meaningful detail about how to earn bounties.

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

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

Given no output schema, the description provides enough detail to understand what the tool does and what it returns (each row gives ticketId and bounty in USD). It also covers the workflow for acting on the bounties and the constraints (public, not workspace-limited, entry fees for contests), making it complete for an agent to decide when and how 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 description covers 100% of the single 'limit' parameter, including default and behavior. The description adds context about 'richest first' and the public board, but doesn't add new semantic 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 clearly states the tool lists the public bounty board, with a specific verb ('list') and resource ('public bounty board'). It differentiates from siblings by explicitly noting 'Unlike the other tools this is NOT limited to your own workspace,' and details what is returned (ticketId and bounty in USD).

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 on when to use it (to see public bounties and earn cash) and mentions alternatives for acting on it (draft_reply or propose_resolution). However, it lacks explicit exclusions or 'when not to use' guidance, though the differentiation from workspace-limited tools implies 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?

No annotations are provided, so the description carries full burden. It discloses 'Read-only' behavior and explicitly states that only published entries are returned (drafts/scheduled excluded). This provides sufficient transparency for a simple read 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 paragraph but well-organized: read-only declaration, what it returns, sorting, usage context, and exclusions. Every sentence adds value with no redundancy. Slightly longer than necessary but still 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 tool's simplicity (1 parameter with full schema coverage, no nested objects, no output schema), the description covers key aspects: return fields, filtering, usage context. The return fields are listed, compensating for lack of output schema. It is complete for a changelog listing tool.

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

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

Schema coverage is 100% with the single parameter 'limit' fully described in schema. The description adds value by stating the sort order ('newest-first'), which is not in the schema, and implicitly confirms the default limit behavior. Baseline 3 plus additional sort info yields a 4.

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

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

The description clearly identifies the tool's action ('list'), resource ('this tenant's published changelog entries'), and provides specific details: entries are product updates/release notes, sorted newest-first, and return specific fields (id, title, body, publishedAt). It effectively distinguishes from sibling tools that are about issues/tickets.

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 states when to use the tool: 'when you need to tell a customer what recently changed or shipped, or to check whether a feature/fix has been announced.' It implies not for drafts/scheduled entries. While it lacks explicit 'when not to use' or alternatives, the context is clear and helpful.

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, so description carries full burden. Labels tool 'read-only', mentions filter and limit behavior, and lists return fields. Does not discuss authentication or rate limits, but those are minor for a tenant-specific read 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 sentences, no fluff, front-loaded with key information. Efficient and to the point.

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

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

Given no output schema and two optional params, description covers purpose, usage, and return shape. Omits mention of default limit (25) from schema but still 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 100%, so description adds limited value beyond the schema. It mentions optional filtering and cap on count, but this is redundant with the schema descriptions. 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 clearly states it lists issues (bugs and feature requests), sorted newest first, and distinguishes from sibling tools like create_issue and list_tickets.

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 says when to use: to check status, vote counts, avoid duplicate before reporting. Provides clear context and implicitly suggests not to use it for creating issues.

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?

Read-only and non-destructive behavior is explicitly stated ('never creates or modifies anything'). Returns lightweight summaries with specific fields and total count, sorted by most recent message. With no annotations, this fully discloses behavioral traits.

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?

Description is concise and well-structured: read-only flag first, then use cases, then filtering options, then return format, then safety guarantee. Every sentence is informative with no waste.

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

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

Given no output schema, the description covers the return values (lightweight summaries with specific fields). It also explains sorting, limits, and filtering, making it complete for a list tool.

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

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

Schema coverage is 100% with descriptions for each parameter, so baseline 3. The description adds value by explaining the default and max for limit, and the purpose of filters (e.g., 'poll for recently active tickets'). Slightly above 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 clearly states 'list support tickets' with a specific verb and resource, and distinguishes from siblings like search_tickets by focusing on listing vs searching. It also notes the sorting order.

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 use cases: 'discover ticket ids, triage the queue, or poll for activity'. While it doesn't directly say when not to use, the context and sibling tools imply alternatives. Could be improved by contrasting with search_tickets.

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?

Even without annotations, the description fully discloses behavior: it costs nothing, changes nothing, runs conditional checks based on wallet presence, and returns specific info including refusal reasons. This is comprehensive for a read-only check tool, covering side effects and conditions.

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, tightly packed with essential information: purpose, checks, return values, and side-effect disclaimer. Every clause earns its place; no redundant words. The '[free]' tag is a concise cue.

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

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

For a two-parameter tool with no output schema, the description covers the main behavior and inputs. It could specify exact output format or edge cases (e.g., what happens if ticketId doesn't exist), but the description is sufficient for an agent to call it correctly. The lack of output schema isn't a gap since return is described qualitatively.

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%, but description adds value by explaining the purpose of wallet (enables chain-match and entry-limit checks) and ticketId (from list_bounties). It also hints at wallet format (0x for EVM, base58 for solana), which is beyond the schema. Slight deduction for not detailing the acceptance condition field, but params are well-explained.

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

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

The description clearly states it is a free pre-check before paying to enter a bounty, listing specific checks (row open/funded, wallet chain match, existing live entry, KB coverage) and what it returns (eligible, refusal reason, acceptance condition). It is distinct from sibling tools like list_bounties or get_ticket_context by emphasizing the pre-check nature.

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 says 'free pre-check before paying to enter a bounty' and states what happens with or without the wallet parameter, which implies when to use it (before paying). It also contrasts with list_bounties by mentioning ticketId from it, though not naming siblings explicitly. The usage context is clear and actionable.

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

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

With no annotations, the description carries full burden and does so thoroughly: it discloses draft status, queuing, tenant validation, refusal on content violations, strike system, and cost. This is exemplary 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 detailed but tightly organized; the first sentence captures core purpose, followed by usage trigger, content rules, and cost. No redundant phrasing.

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 covers all operational aspects: execution flow, validation, refusal, wallet impact, and content constraints. Nothing an agent needs to call correctly is missing.

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

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

All parameters are described in the schema (100% coverage), so baseline is 3. The description enriches referrer semantics (wallet share, cost source) and ticket requirement, adding value beyond 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 as submitting a proposed resolution as a draft for human approval, explicitly stating it does not send to customer or close ticket. This distinguishes it from sibling tools like send_reply, resolve, and draft_reply, making the purpose unambiguous.

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

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

It explicitly instructs to use this after diagnosing a ticket with a concrete answer, and contrasts with immediate send/close behaviors. It gives a clear trigger condition, though it doesn't name sibling tools explicitly, the context is sufficient.

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

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

With no annotations, the description carries the full burden. It discloses that the tool is read-only, free to call, scoped to published articles in this tenant, and never returns drafts or other tenants' articles. This provides clear behavioral expectations without relying on annotations.

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

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

The description is moderately sized but every sentence earns its place. It covers purpose, usage, rationale, cost, and constraints without fluff. The structure front-loads the core action and follows with contextual guidance.

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

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

Given the tool's simplicity (one parameter, no output schema), the description is complete. It explains what the tool does, when to use it, what to expect in terms of scope and limitations, and why it is beneficial. No critical information is missing for an agent to select and 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 schema already provides a detailed description for the 'ids' parameter, including count limits and usage guidance. The tool description only repeats 'by id' without adding new semantic information, so it does not exceed the baseline for 100% 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's action: 'returns the FULL text of published knowledge-base articles in this tenant, by id.' It distinguishes itself from search_kb, which returns snippets, making the specific purpose and scope unambiguous.

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

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

It explicitly says to 'Use it straight after search_kb' and explains the workflow: 'search to find the right articles, then read them here before you answer.' It also gives the rationale for using it (grounding answers in real text) and notes the limitation that drafts/other tenants' articles are not returned.

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

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

No annotations are present, so the description carries the disclosure burden. It discloses the approval flow, the owner's decision role, and that subsequent payments need no key. It could also mention the immediate outcome of the request, but the provided behavior is otherwise 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 short and front-loaded with the most important trigger condition. Minor redundancy: 'Free' and '[free]' repeat the same information, so it is not perfectly waste-free.

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 tool with two simple parameters and no output schema, the description covers the trigger condition, the workflow, and the post-approval behavior. It does not describe the immediate response or how the caller learns about the owner's decision, but the core calling context is adequately 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?

Schema description coverage is 100%, so the schema already documents the parameters. The description adds contextual meaning by clarifying that the wallet is the one used for bounties and that approval is wallet-based rather than key-based, which goes slightly 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 verb and resource: 'Ask this desk to allow your wallet on its bounties.' It clearly identifies what the tool does and is distinct from sibling tools like create_ticket or list_bounties.

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 tells the agent when to invoke this tool: 'Use when a call was refused AUTH_REQUIRED or WALLET_NOT_ALLOWED.' This is a precise trigger condition and leaves little room for mis-selection.

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

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

With no annotations, the description fully covers behavioral traits: idempotency (no-op for already closed), reversibility (human can reopen), required credential tier ('send'), cost indication, and that the note is internal. This exceeds the burden 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, well-structured paragraph with no filler. Every sentence adds value: action, usage timing, idempotency, reversibility, credential requirement, note behavior, and cost. It is front-loaded with the primary action.

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

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

Despite no output schema, the description explains the tool's complete behavior: what it does, side effects, prerequisites, idempotency, reversibility, and note handling. It provides enough context for an agent to use it correctly without guessing.

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%, but the description adds significant meaning: the note's internal-only nature and default value, plus the ticketId's scoping and error behavior (NOT_FOUND). This goes beyond the schema's basic 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 begins with a specific verb-resource pair ('Marks a ticket as resolved') and clearly states the action (setting status to closed, recording a note). It distinguishes itself from siblings like 'assign' or 'create_ticket' by focusing on the resolution workflow.

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 says 'Reach for this once the issue has been handled and you want to close it out', providing clear when-to-use guidance. It does not explicitly list alternatives or when-not-to-use, but the context is sufficiently clear for an agent to decide.

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 describes the destructive nature (revoke all existing keys), the action (mint a fresh one), and a precondition. Adding detail about return value or effects on active integrations would improve transparency, but it is adequate for a sensitive 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 sentences plus a price note, every word serves a purpose. Action verb first, condition second, prerequisite third. No fluff or redundancy.

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

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

For a single-parameter destructive tool with no output schema, the description covers purpose, trigger condition, and a key prerequisite. It does not specify the return value (e.g., whether the new key is returned), but given the simplicity and common patterns, 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 description coverage is 100% and the single parameter's schema already clearly states its purpose and behavior (must be true, immediate revocation). The tool description does not add any additional meaning beyond what the schema provides, so baseline 3 is appropriate.

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

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

The description uses specific verbs ('revoke', 'mint') and identifies the resource ('all existing API keys for the board'), clearly distinguishing this from sibling tools like create_board or create_issue which deal with other 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?

Explicitly states the trigger condition ('Use this if your board key leaked or was lost') and a prerequisite involving wallet ownership. Does not list alternatives or when not to use, but the context is sufficiently narrow.

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 provided, so description carries full burden. It discloses read-only nature, AND search semantics, fixed tenant based on credentials, and that drafts are excluded. Lacks details on rate limits or error behavior but covers key behavioral traits.

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 short fragment, front-loaded with purpose. Every sentence adds value: 'Read-only full-text search...' immediately conveys function, then scope, then usage advice. 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?

Given no output schema, description covers return fields (id, title, snippet, updatedAt) and ranking by relevance. Constraints like limit range and AND semantics are explained. For a 2-parameter tool, this provides all necessary context 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%, but description adds significant meaning: explains AND semantics, recommends keeping query to key terms, and specifies default limit (10) which is not in schema. This helps the agent use parameters effectively.

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 it's a read-only full-text search over PUBLISHED knowledge-base articles, distinguishing it from sibling tools like search_tickets. The description explicitly mentions the scope (tenant-specific, published only) and purpose (ground answers in official guidance).

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 tells the agent to 'Reach for this FIRST' before replying, and clarifies what it does NOT do (return unpublished drafts). Provides context for when to use it (grounding answers) and implies alternatives for other search needs.

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

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

Without annotations, the description carries full transparency burden. It discloses read-only nature, search algorithm (ranked full-text with substring fallback), return structure (lightweight summaries), and scoping. It could mention idempotency or lack of side effects more explicitly, but 'read-only' suffices.

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 (3 sentences), front-loaded with purpose, then usage, then output and scoping. Every sentence adds value with no redundancy.

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

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

Given no output schema, the description adequately explains return fields (id, subject, status, priority, lastMessageAt) and how to use the id. It covers search behavior and scoping. Could mention pagination or error handling, but 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 coverage is 100% with good parameter descriptions. The description adds value by explaining the query's matching behavior and fallback mechanism, and clarifies the default limit. This goes beyond what the schema alone provides.

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

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

The description clearly states it is a read-only full-text search over support tickets, specifying matched fields (subject and first customer message) and tenant scoping. It distinguishes itself from sibling tools like list_tickets (browsing full list) and search_kb (knowledge base) through explicit use-case guidance.

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 when-to-use guidance ('Reach for this when you need to find specific tickets by keyword... rather than browsing the full list') and gives concrete examples (check for duplicates, locate related conversations). It does not explicitly state when not to use, but the context is clear enough.

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; description fully covers behavior: immediate delivery, not a draft, credential requirement, rejection if no email, and cost. Provides all needed side-effect info.

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

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

Four sentences, highly efficient. Front-loaded with action, then constraints, then alternative, then details. 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 simple tool with 2 params and no output schema, description fully covers purpose, usage, prerequisites, alternatives, and cost. No gaps.

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

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

Schema coverage 100% with good descriptions. Description adds context: body is final customer-ready message, ticketId ties to customer and delivery. Adds value beyond 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?

Clear verb 'sends' and resource 'reply to customer on ticket' with immediate delivery. Distinguishes from draft tool.

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

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

Explicitly states when to use (final answer), when not (use draft for approval), and names alternative. Also mentions credential and prerequisite.

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 discloses multiple non-obvious behaviors: calling again for the same url replaces the event list, rotates the HMAC secret, [] disables the subscription, limits to 5 urls per wallet, and charges $0.02.

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

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

Four short, dense sentences with no filler. The main purpose is front-loaded, and each subsequent sentence adds a distinct fact about persistence, rotation, limits, or cost.

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

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

With no output schema and no annotations, the description still states the return value (HMAC secret once), the idempotence/replacement semantics, the disable mechanism, per-wallet limits, and price. It leaves minor gaps such as how wallet identity is resolved or what happens on payment/billing failure, but invocation details are mostly covered by the schema.

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 url, events, and min_bounty_usd. The description adds useful lifecycle context like secret rotation and replacement, but it does not meaningfully extend the per-parameter semantics 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?

Description names the exact action (subscribe), the resource (paying wallet), and the event types pushed. It clearly distinguishes this from any list/draft/ticket/support tools in the sibling set.

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 it: when a paying wallet needs push notifications for row.available, draft.decided, or payout.sent. It does not explicitly discuss when not to use it, but there is no obvious alternative tool among siblings, so the context is sufficiently 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 carries full burden. It discloses that the tool only updates metadata within the calling tenant, does not change status or contact customers, and that unknown/cross-tenant tag IDs reject the call. The cost of $0.03 is also mentioned.

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 dense paragraph that front-loads the purpose and follows with key behavioral notes. Every sentence adds value without repetition, and the structure is logical.

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

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

For a mutation tool with no output schema, the description is complete: it covers what the tool does, its constraints, side effects, and cost. The parameters are well-documented in the schema, and the description fills in remaining 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?

Although schema coverage is 100%, the description adds crucial semantics: it clarifies that at least one of priority, tagIds, or category must be provided (not just optional), explains that tagIds replaces existing tags, and categorizes the effect as 'route or label'. This goes beyond the schema's descriptions.

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

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

The description clearly states the tool's purpose: 'Classify an existing support ticket by setting any of its priority, tags, and/or category'. It uses a specific verb-classify and resource-support ticket, and the phrase 'reach for this after reading a ticket' distinguishes it from sibling tools like `create_ticket` or `resolve`.

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 ('after reading a ticket to route or label it for the team'), and what not to expect ('never changes the ticket status and never contacts or notifies the customer'). It also notes the precondition that at least one of priority, tagIds, or category must be provided.

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