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

With no annotations, the description carries the transparency burden. It communicates the read-only nature through 'Get' and reveals the returned detail categories plus the ID prerequisite. However, it does not address behavior on invalid IDs, authorization requirements, or response format, leaving some ambiguity.

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

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

A single, well-structured sentence that front-loads the action and resource, then adds the prerequisite and detail scope. Every word earns its place; 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 one-parameter getter with no output schema, the description covers purpose, return contents, and the required prerequisite, making it nearly complete. It could be more explicit about response shape or error behavior, but this is minor for a simple read-only 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 already documents the id parameter at 100% coverage, so baseline 3 applies. The description adds minor value by naming the exact source tool (yeastar_list_extensions) and clarifying the parameter is an extension ID, but it provides no additional format or constraints.

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

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

States a specific verb and resource: 'Get full detail for a single extension', and enumerates the detail categories (call forwarding, voicemail, permissions, device bindings). This clearly distinguishes it from yeastar_list_extensions (single vs list) and from other sibling get_* tools for different resources.

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

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

Provides clear usage context by saying the tool 'Requires an extension ID from yeastar_list_extensions', which tells the agent the prerequisite call order. It does not explicitly state when not to use it or name alternatives, but 'full detail' implies the contrast with the list tool.

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

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

With no annotations, the description must signal behavioral traits itself. 'Get' implies a read operation and 'Requires an ID' implies validation dependency on an existing list result, but the description does not disclose error behavior, output format, or permission 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?

A single, compact sentence conveys the purpose and prerequisite without filler. The most important scoping information appears first.

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

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

For a one-parameter read tool with no output schema, the description gives an agent everything needed to select and invoke it. Minor omissions like expected response shape or invalid-ID behavior are acceptable at this low complexity level.

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

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

Schema coverage is 100% and the only parameter id is already documented as 'Object ID, from the corresponding list tool.' The description adds little beyond that, but it reinforces the correct provenance of the ID from yeastar_list_extension_groups.

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 opening verb 'Get' plus the object 'full detail (member extensions) for a single extension group' identifies both the action and resource. It is clearly distinguishable from sibling tools such as yeastar_list_extension_groups (all groups) and yeastar_get_extension (one extension) by specifying group scope and member-extensions detail.

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 the required prerequisite: an ID from yeastar_list_extension_groups. It also clarifies that this is for a single group, so an agent knows to first list groups when no ID is available, though it does not explicitly enumerate when to prefer sibling 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 the behavioral burden. It conveys a read-only 'get' operation returning 'full detail' for one route and warns that an ID is required, but it does not disclose error behavior for an invalid/missing ID or describe the return shape.

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

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

Two short sentences front-load the action and then give the prerequisite. There is no filler or repetition; every sentence earns its place.

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

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

For a simple one-parameter getter with no output schema, the description gives the operation, the required parameter, and where to obtain its value, which is sufficient to invoke the tool correctly. The main gap is the lack of return-value and error detail, but this is minor at this complexity level.

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

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

The schema already fully documents the single id parameter with 100% coverage, so the baseline is 3. The description names the exact source list tool, but this largely echoes the schema's 'corresponding list tool' and adds no new value constraints or formats.

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') and resource ('inbound route'), and clarifies it is for 'a single' route, distinguishing it from the list tool and from outbound-route getters. The ID prerequisite reinforces exactly what this 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?

It explicitly states the tool requires an ID from yeastar_list_inbound_routes, so an agent knows to list routes first and then fetch details. It does not explicitly name when-not-to-use alternatives, but the inbound/single scope makes the intended context clear.

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

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

There are no annotations, so the description carries the burden. It discloses that this is a read/get operation and that the ID comes from a list call, but it does not mention error behavior, permissions, or what is returned beyond the three example 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?

One compact sentence front-loads the purpose, adds concrete detail examples in parentheses, and states the prerequisite. 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 single-parameter get tool with no output schema, the description gives enough context to invoke correctly after the list step. The only gaps are error handling and authorization, which are minor for this simple read 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 coverage is 100% and the schema already says the id is 'Object ID, from the corresponding list tool.' The description adds the explicit tool name, but for the most part it restates rather than extends the schema.

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

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

The description uses a specific verb ('Get') and resource ('single IVR'), and enumerates what 'full detail' includes (key press mapping, prompts, timeout destination). It clearly distinguishes this detail-fetch tool from its list sibling, yeastar_list_ivrs.

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 specifies the prerequisite workflow: requires an ID from yeastar_list_ivrs. This gives clear context for when to call it, but it doesn't explicitly state when not to use it or name alternative detail tools.

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

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

With no annotations, the description carries the behavioral burden. 'Get full detail' reasonably implies a read-only operation returning complete information, but it does not disclose potential errors, authentication requirements, or whether the route data includes sensitive fields. This is adequate for a simple getter but not richly transparent.

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

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

Two short sentences convey purpose, scope, and prerequisite with no redundant wording. The description is front-loaded with the primary action and quickly gives the actionable instruction about obtaining an ID.

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

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

For a single-parameter read tool with no output schema, the description covers the essential context: what the tool does and where the required ID comes from. It could go further by describing the return structure or behavior when the ID is invalid, but these are minor gaps for a straightforward getter.

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

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

The schema already documents the 'id' parameter at 100% coverage, so the baseline is 3. The description adds value by naming the specific source tool (yeastar_list_outbound_routes) rather than the schema's generic 'corresponding list tool', giving the agent a precise way to obtain a valid ID.

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

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

The description states a specific verb ('Get'), a clear resource ('outbound route'), and the singular scope ('a single'), which clearly distinguishes it from yeastar_list_outbound_routes. 'Full detail' also sets user expectations about the response. This is a clear and specific purpose statement.

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

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

The description gives an explicit prerequisite: the ID must come from yeastar_list_outbound_routes, which tells the agent when this tool is appropriate. It does not explicitly mention alternatives or when not to use it, but for a simple get-by-id tool this 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 the burden. It communicates a benign read operation and implies failure behavior by requiring a valid ID from the list tool, but it does not describe error handling for invalid IDs, permission requirements, or the response format. This is adequate for a simple get tool but not rich.

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

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

Two sentences with no wasted words. The first sentence front-loads what the tool does and returns, and the second states the prerequisite. Every clause earns its place.

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

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

For a low-complexity single-parameter get tool with no output schema, the description covers the essentials: what is returned (configuration fields), and the required input source. Minor gaps remain around full return shape and error behavior, but nothing an agent needs to invoke it correctly is missing.

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

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

Schema coverage is 100%, so the schema already documents the single id parameter. The description adds value by naming the exact source tool (yeastar_list_queues) rather than the schema's generic 'corresponding list tool,' removing ambiguity about where the ID comes from.

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 ('full configuration...for a single queue') and names concrete contents (strategy, timeout, member agents). This clearly distinguishes it from the sibling status tools yeastar_get_queue_call_status and yeastar_get_queue_agent_status, which are about operational status rather than configuration.

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 a clear prerequisite workflow ('Requires an ID from yeastar_list_queues'), telling the agent to first call the list tool to obtain the ID. However, it does not explicitly state when to choose this tool over the queue status siblings, leaving that differentiation to inference.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It explicitly states that this is a read with no side effects ('does not log an agent in, out, or change their pause state') and that it returns current state per agent. It could add response shape or failure behavior, but it is adequately transparent for a simple read tool.

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

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

The description is two sentences with no filler. The main purpose is front-loaded, followed by a useful side-effect clarification and a prerequisite. Every sentence contributes necessary information.

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

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

For a one-parameter, read-only tool with no output schema, the description covers the purpose, the return concept (per-agent login/pause/busy states), the required input (a queue ID), and the non-mutating behavior. Nothing essential is missing for an agent to invoke it correctly.

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

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

The schema already documents the single 'id' parameter with 100% coverage, so the baseline is 3. The description adds value by naming the exact source tool, yeastar_list_queues, which is more actionable than the schema's generic 'corresponding list tool'.

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

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

The description names a specific verb ('Get') and a precise resource ('current login/pause/busy state of each agent in a queue'). It also clarifies that it is a read operation and does not change agent state, which distinguishes it from state-mutating tools and from the sibling yeastar_get_queue_call_status.

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

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

The description gives clear usage context: use it to read the current agent statuses, not to log agents in/out or change pause state. It also states the required prerequisite of obtaining an ID from yeastar_list_queues. It does not explicitly name an alternative tool, but the usage boundary is clear.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states this is a read-only operation that does not join, transfer, or otherwise touch a call, which is critical safety-relevant behavior for a telephony tool. It could add more about freshness, error behavior, or output shape, but the essential non-mutating trait is clearly disclosed.

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

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

Two concise sentences: the first defines what the tool returns, the second clarifies the read-only behavior and the input requirement. Every phrase earns its place, and there is no redundant or filler content.

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

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

For a one-parameter read-only status tool without an output schema, the description covers the purpose, the data returned (waiting calls, in-progress calls, wait times), the read-only nature, and the necessary ID source. Slight gaps remain around wait-time units and exact return format, but these are minor for a tool this simple.

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

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

The schema already fully documents the single 'id' parameter, so the baseline is 3. The description adds value by naming the exact source tool (yeastar_list_queues) for obtaining the ID, which goes beyond the generic 'from the corresponding list tool' schema text. This is sufficient for a single-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 states a specific verb ('Get') and resource ('current live call state of a queue'), then names concrete data points: calls waiting, calls in progress, and wait times. This clearly separates it from sibling tools like get_queue or get_queue_agent_status by focusing on live call flow rather than configuration or agent status.

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 a clear prerequisite: it requires an ID from yeastar_list_queues, which tells the agent exactly how to obtain valid input. It also signals the read-only context ('does not join, transfer, or otherwise touch any call'), implying it is for observation, not call control. It does not explicitly name alternatives or when not to use it, but the usage context is clear.

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

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

No annotations are provided, so the description carries the full burden. 'Get' implies a safe read operation and the description discloses the kind of data returned. It does not state error behavior for invalid or nonexistent IDs, auth requirements, or side effects, though those are low-risk for a single-parameter read 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?

One compact sentence, front-loaded with the primary action and resource, followed by the prerequisite. There is no filler or redundant restating of the tool name or schema.

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

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

For a single-parameter read tool with no output schema, the description covers the resource, the key fields returned, and where to obtain the required ID. It could mention behavior on a not-found ID or the return format, but nothing essential is missing 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?

The input schema already documents the sole parameter at 100% coverage ('Object ID, from the corresponding list tool'), and the description simply restates that idea ('Requires an ID from yeastar_list_ring_groups'). No new semantic detail is added, so the baseline of 3 applies.

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

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

The description states a specific verb ('Get'), a clear resource ('single ring group'), and enumerates the detail contents (member extensions, ring strategy, timeout destination). This makes it immediately distinct from the sibling list_ring_groups tool and from other get_* 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 says 'Requires an ID from yeastar_list_ring_groups', which tells the agent the proper prerequisite and workflow: list first, then fetch details for one ID. It doesn't explicitly name alternatives or list exclusions, but the single-vs-list distinction is clear enough from the phrasing.

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 implies a read-only operation ('Get') but does not explicitly state that it is non-mutating or whether it requires any permissions. It also fails to describe the return format or any potential side effects. This is a significant gap for a tool with zero annotation coverage.

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

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

The description is a single, concise sentence that front-loads the main action ('Get current ... usage') and includes the key context (against licensed capacity limits). There is no unnecessary verbiage, making it highly efficient for an agent to parse.

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

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

Given the simplicity of the tool (no parameters, no output schema, no annotations), the description gives a basic understanding of what it does but does not explain the return structure or edge cases (e.g., what happens when capacity is exceeded). Since there is no output schema, the description should clarify what the agent can expect in terms of data format, but it falls short. This is adequate but not complete.

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

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

The tool has zero parameters, so there is nothing to document. According to the rubric, a 0-parameter tool gets a baseline of 4. The description does not add parameter semantics because none exist, and the schema coverage is 100% (empty object), so this score is appropriate.

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

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

The description uses a specific verb ('Get') and clearly identifies the resource: current extension/trunk/concurrent-call usage against licensed capacity limits. It distinguishes itself from siblings like yeastar_get_system_information by specifying the exact metrics being retrieved, leaving no ambiguity 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?

There is no explicit guidance about when to use this tool versus alternatives, and no mention of exclusions or alternatives. However, the purpose is evident from the name and description, so usage is implied rather than stated. A mention of when to prefer this over get_system_information would have improved the score.

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

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

There are no annotations, so the description carries the behavioral burden. It transparently frames the call as a read-only retrieval of identity data, which implies no side effects. It does not discuss permissions or failure modes, but the operation is simple and self-describing.

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

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

Two short sentences, each earning its place: the first states what the tool returns, the second gives a practical reason to call it. No filler or redundancy.

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

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

For a zero-parameter, read-only identity tool with no output schema, the description is complete: it names the exact fields an agent should expect and a realistic scenario for use. Nothing an agent needs to invoke it correctly is missing.

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

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

The tool has zero parameters, so the schema already fully covers the input contract. The description adds no parameter detail because none is needed; the baseline of 4 applies.

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

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

The description uses a specific verb ('Get') with a clear resource: the PBX appliance's own identity, naming model, firmware version, and hostname. This distinguishes it from sibling tools like yeastar_get_system_capacity and yeastar_list_extensions, so an agent can select it unambiguously.

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 a concrete use case: 'confirm which appliance a set of credentials points at.' It does not explicitly name alternative tools or when not to use it, but for a zero-parameter identity lookup 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?

With no annotations, the description carries the full behavioral burden. It discloses a meaningful trait: SIP registration secrets and passwords are stripped from the response, and the connector never returns trunk auth credentials. This goes beyond the schema and helps the agent set expectations about sensitive data.

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

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

Two sentences with no filler. The core action and prerequisite come first, and the security behavior is a valuable second sentence. Every word earns its place.

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

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

For a single-parameter read tool, the description is nearly complete: it states what is returned ('full detail'), where the ID comes from, and the important redaction behavior. Since there is no output schema, a bit more detail about the response shape would be nice, but it is not essential 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 for the only parameter is 100%, with the id already documented as the object ID from the corresponding list tool. The description reinforces the source of the ID but adds little semantic value beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Get') and resource ('full detail for a single trunk'), clearly differentiating it from list-style siblings like yeastar_list_trunks. It also correctly routes to the prerequisite list tool, leaving no ambiguity about what this tool retrieves.

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

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

The description gives clear context: it is for a single trunk and requires an ID from yeastar_list_trunks. It stops short of explicitly stating when not to use it or naming alternatives, but the prerequisite and single-item scope make the intended usage evident.

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 clearly communicates that this is a metadata-only listing operation, that backup content is never returned, and explains the security rationale. It does not mention response pagination shape or authentication, but the most non-obvious behavior is well covered.

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

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

The description is two tight sentences with the core action and scope front-loaded. The security explanation earns its place by preventing misuse, and there is no redundant or filler content.

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

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

For a simple metadata-list tool with two optional pagination parameters and no output schema, the description covers the purpose, the returned fields, and the critical no-download behavior. Minor gaps remain around response envelope/pagination format and permission requirements, but they do not seriously hinder correct invocation.

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

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

Schema description coverage is 100%, and the parameter descriptions for page and page_size already explain their defaults and semantics. The tool description adds no parameter-specific meaning, so the baseline score of 3 applies.

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

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

The description uses a specific verb and resource: 'List configuration backup metadata for this appliance' and enumerates the returned fields (name, created time, size). It also distinguishes itself from any backup-content retrieval by explicitly saying file contents are not returned, making the tool's 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 states an explicit use case: 'for monitoring backup health (e.g. when did the last backup run)'. It also provides a clear when-not: the tool does not return backup file contents and download is never implemented, preventing agents from attempting a use it cannot satisfy.

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 implies a non-mutating list operation and clarifies the aggregate nature of the results, but it does not disclose authentication needs, rate limits, pagination behavior beyond schema defaults, or how the aggregation is computed. These are useful but not critical for a straightforward list tool.

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

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

Two short, purposeful sentences. The main action and scope are front-loaded, and the sibling distinction is placed second. No filler or redundant restatement.

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

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

For a simple optional-parameter list tool with no output schema, the description is complete enough to select and invoke it. It defines the result as aggregate summary call statistics and the only meaningful alternative. It does not enumerate expected summary fields, but that is a minor gap given the tool's straightforward purpose.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters including formats and defaults. The description only repeats the optional start_time/end_time bound, adding no new meaning beyond the schema. Baseline 3 applies.

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

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

The description names a specific action ('List') and resource ('aggregated call reports') and then clarifies the resource as 'summary call statistics'. It also explicitly distinguishes itself from yeastar_list_cdr, so an agent can tell the two list tools apart immediately.

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

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

The second sentence gives direct routing guidance: this tool is for aggregate summaries, while yeastar_list_cdr is for individual call records. This is an explicit when-to-use/alternative pairing rather than leaving the choice to inference.

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

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

With no annotations, the description carries the full behavioral burden. It discloses API-version targeting, optional time-bound behavior, and the lack of recording audio, all of which are real behavioral constraints beyond the schema. It does not mention pagination/default PBX page size in prose, but those are schema-documented.

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

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

Three concise sentences, front-loaded with the core list action and fields, then boundary/version exclusions. No filler or repetition of schema details.

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

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

For a no-required-parameter list tool, the description covers return content (who called whom, when, duration, disposition), filtering bounds, API version, and audio exclusions. The absence of an output schema is partially offset by the explicit field summary; minor gaps such as page-size defaults remain but are already in 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 description coverage is 100%, so the schema already explains every parameter; the description adds only the semantic framing that start_time/end_time are optional bounds atop that. That matches the baseline of 3 for full schema coverage.

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

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

Purpose is explicit: 'List call detail records (CDR): who called whom, when, duration, disposition.' The verb 'List', the resource CDR, and the scope are all present, and the v1.0 versus v2.0 and no-audio notes further differentiate it from nearby list/report endpoints.

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 context by stating optional time bounds and clarifying that the v1.0 CDR surface is used and recording audio is not included, which tells the agent when not to expect audio. However, it does not explicitly name a sibling alternative (e.g., list_call_reports) or state a condition for choosing another tool, so usage guidance remains partly implied.

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

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

With no annotations provided, the description takes on the burden of behavioral disclosure. It clearly states the tool is metadata-only and does not return private key material, which is important safety context. It could add pagination or error behavior, but those are minor gaps for a simple list 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 two sentences with no filler. The core action and purpose are front-loaded, and the second sentence provides an important limitation without unnecessary elaboration.

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

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

For a simple list tool with two optional parameters and no output schema, the description names the returned metadata fields and the key limitation around private keys. It could more explicitly describe the response shape, but the field list and purpose are sufficient for correct invocation.

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

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

Schema description coverage is 100%, so the page and page_size parameters are fully documented by the schema. The description adds no additional parameter-level semantics beyond the schema, maintaining the baseline score of 3.

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 ('List TLS certificate metadata') and enumerates the returned fields (name, domain, expiry date). This clearly distinguishes it from the many list/get sibling tools.

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

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

It explicitly states the intended use case: monitoring certificate expiry. It also warns that private key material is not returned and that certificate/get is never implemented, which prevents an agent from attempting an unavailable operation. Since no sibling tool is certificate-focused, explicit alternative routing is unnecessary.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It correctly implies a read-only list operation and clarifies the directory scope, but it does not describe pagination behavior, default page size behavior, or what the returned contact data looks like.

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

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

The description is a single compact sentence that front-loads the main purpose and then adds a valuable parenthetical distinction. Every word earns its place with no redundancy or filler.

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

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

For a simple list tool with fully documented pagination parameters, the description adequately conveys the object being listed and the boundary between company contacts and personal phonebooks. The absence of an output schema means return values are not specified, but this is a minor gap for this type of directory-listing operation.

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

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

The input schema already provides 100% description coverage for both parameters, page and page_size. The tool description adds no additional semantic meaning beyond that already present in 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 verb 'List' and the resource: the company-wide contact directory shared by all extensions. It explicitly distinguishes this from individual extension personal phonebooks, which removes ambiguity about the tool's 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 communicates that this tool is for company-wide shared contacts and explicitly notes that personal phonebooks are not exposed by this connector. It provides clear context for when to use the tool, though it does not name alternative tools or give an explicit 'use this when...' directive.

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 only says 'List extension groups,' which conveys the basic action but does not disclose pagination behavior beyond what the schema already says, nor any filtering, ordering, or response characteristics. The description adds minimal behavioral value beyond the tool name and schema.

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

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

The description is a single sentence that front-loads the core action. It has no fluff or redundancy. It loses one point because it could have also included the list-vs-get distinction concisely.

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 and no output schema, the description is thin. It names the resource but does not cover pagination semantics, default page size behavior, sorting, or how it differs from the single-group getter. For a straightforward list tool, this is minimally viable but not complete.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds no additional parameter meaning, but the schema carries the load adequately. The baseline of 3 is appropriate because the description doesn't improve parameter understanding but the schema compensates.

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

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

The description states a specific verb and resource: 'List extension groups.' This clearly identifies the primary action of retrieving extension group entries. However, it doesn't distinguish itself from the sibling tool yeastar_get_extension_group, which is a related operation; a mention of the list vs. get distinction would have made it fully clear.

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

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

The description provides no guidance about when to use this tool versus alternatives. There is no mention of when a list operation is appropriate, no exclusion criteria, and no pointer to yeastar_get_extension_group for retrieving a single group. The tool's name suggests a listing utility, but the description leaves usage decisions entirely to the agent.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It does this well by stating exactly what data is returned and explicitly calling out that the password field is never exposed. It does not explicitly discuss pagination behavior or side effects, but the operation is clearly a read-only list.

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

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

The description is three sentences with no filler: the first sentence states scope and output, the second routes to the alternative tool, and the third clarifies a critical exclusion. Every sentence earns its place.

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

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

For a list tool with no output schema, the description is complete: it enumerates returned fields, identifies the sibling for deeper detail, and discloses a data-availability constraint. The optional pagination parameters are covered by the schema, so nothing needed for correct invocation is missing.

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

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

The input schema already documents all four parameters with 100% coverage, including defaults and the sort_by caveat. The description does not add parameter-level guidance, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb and resource ('List extensions') and enumerates the exact fields returned. It clearly differentiates from yeastar_get_extension by characterizing this as 'basic info' versus full per-extension detail, so an agent can distinguish between them without opening schemas.

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

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

The description explicitly tells the agent when to choose this tool and when to choose the alternative: 'For full per-extension detail ... use yeastar_get_extension.' It also states a hard limitation (SIP/portal password is never exposed), which prevents incorrect expectations.

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

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

There are no annotations, so the description carries the behavioral burden. It adds context about the returned data's meaning (DID/pattern to destination mapping) beyond a bare 'list', which helps an agent understand what the operation provides. However, it does not disclose pagination behavior, potential size limits, authentication needs, or any side effects. The read-only nature is implied by 'List' but not explicitly stated.

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

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

A single, efficiently worded sentence that front-loads the primary action ('List inbound call routes') and uses a parenthetical to enrich meaning without redundancy. No filler or redundant restatement of the tool name.

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

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

For a simple paginated list tool, the description covers the conceptual content of the results well. The page parameters in the schema indicate pagination, and the parenthetical explains what a route represents. It is missing explicit linkage to get_inbound_route for detail retrieval, but this is a minor gap given the low complexity.

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

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

The input schema fully documents both parameters (page and page_size) with clear descriptions, and schema coverage is 100%. The description adds no additional meaning to these parameters, so a baseline score of 3 is appropriate per the high-coverage rule.

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

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

The description opens with a specific verb and resource ('List inbound call routes') and then clarifies the resource's meaning with a concrete explanation ('which DID/pattern sends calls to which destination - extension, ring group, IVR, queue, etc'). This clearly distinguishes listing from the sibling get_inbound_route, which targets a single route.

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. It does not mention the singular get_inbound_route for retrieving a single route, nor does it contrast with list_outbound_routes. The context is implicit from the tool name and description, but no explicit or even implied usage conditions are given.

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

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

No annotations are provided, so the description carries the behavioral burden. It clarifies that this lists a template catalog rather than configured trunks, and the verb 'List' implies a read-only operation. It does not elaborate on return shape or pagination behavior, but for a simple paginated list tool the scope clarification is the most important behavioral trait.

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

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

A single, well-structured sentence with zero wasted words. The core purpose is front-loaded, and the critical sibling distinction is included in the same sentence without making it unwieldy.

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

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

For a simple list tool with two optional pagination parameters and no output schema, the description is complete: it identifies the exact resource, clarifies what it is not, and names the alternative. An agent has everything needed to decide whether to call this tool and with what parameters.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters (page and page_size). The description adds no parameter-specific detail, but none is needed because the schema handles it.

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

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

The description states a specific verb ('List') and resource ('ITSP (VoIP provider) templates available on this appliance for trunk creation'), and explicitly distinguishes it from configured trunks. This makes the tool's purpose unambiguous and clearly differentiates it from yeastar_list_trunks.

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 when to use this tool (for ITSP templates used in trunk creation) and when not to use it (for the appliance's own configured trunks), and even names the correct sibling tool (yeastar_list_trunks). This gives the agent direct routing guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, but it only restates the core operation. It does not mention pagination behavior, what the response contains, or whether all IVRs are returned without filtering.

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, front-loaded sentence with no filler or redundancy. It is appropriately terse for the simplicity of the operation, though the brevity leaves behavioral details unaddressed.

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 fully documented optional pagination parameters, this is minimally viable for a basic call. However, with no output schema and no annotations, the description does not disclose the return format or how pagination manifests in the response, leaving clear gaps.

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

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

The input schema already describes both parameters with 100% coverage, including their defaults and types. The description adds no parameter-level meaning, 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 states a clear verb ('List') and resource ('IVR menus'), and expands the acronym to 'auto-attendant', making the purpose immediately understandable. It does not explicitly contrast with the singular 'yeastar_get_ivr' sibling, but the plural 'menus' and use of 'List' help distinguish collection behavior from retrieval of a single item.

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 like yeastar_get_ivr. The word 'List' weakly implies collection-style usage, but there are no exclusions, prerequisites, or conditions that would help an agent choose this tool over its siblings.

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

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

No annotations are provided, so the description carries the full burden. 'List' implies a read-only, non-mutating operation and the parenthetical clarifies the return concept, but the description does not mention pagination behavior, permission requirements, or whether full route details are returned. It is adequate for a simple list tool but not explicit.

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

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

A single sentence that front-loads the action and resource, with a concise parenthetical adding essential domain context. Every word earns its place; there is no filler or repetition.

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

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

For a straightforward list tool with two optional self-documenting pagination parameters and no output schema, the description provides the core return concept ('which trunk handles calls matching which dial pattern'). Minor gaps include the lack of an explicit read-only statement and no detail on the output structure, but these are largely inferable from the verb and 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 description coverage is 100% for both parameters (page and page_size), so the schema already documents their meaning and defaults. The description adds no parameter-specific detail, but none is needed since the schema is sufficient.

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

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

The description states a specific verb ('List') and resource ('outbound call routes'), and the parenthetical 'which trunk handles calls matching which dial pattern' gives the domain meaning that differentiates it from sibling list_inbound_routes. An agent can immediately tell what the tool does and how it relates to get_outbound_route.

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

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

The verb 'List' implies this is for enumerating all outbound routes, which suggests contrast with get_outbound_route for a single route, and with list_inbound_routes for the inbound counterpart. However, the description never explicitly names alternatives or states when to choose this tool, leaving usage to inference.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only states 'List call queues' and omits details about pagination behavior, response shape, or explicit read-only semantics, though 'list' weakly implies a 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, front-loaded sentence with no wasted words. It is appropriately concise for a simple list operation, though slightly terse in that it leaves out contextual details that could be helpful.

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 two optional parameters, so the description is minimally adequate. However, with no output schema and no annotations, it does not explain the return format, pagination details, or how this list relates to the queue-specific get tools.

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

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

Schema description coverage is 100%, with page and page_size already clearly documented in the input schema. The description adds no additional parameter context, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb, 'List', and a specific resource, 'call queues', making the tool's purpose immediately clear. This also distinguishes it from sibling retrieval tools like yeastar_get_queue, which fetches a single queue, and from list tools for 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?

No guidance is provided about when to use this tool versus alternatives such as yeastar_get_queue, yeastar_list_ring_groups, or yeastar_list_trunks. There is no mention of when to use a list versus a get operation, and no exclusions or alternative routing.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It doesn't state whether this is a safe read-only operation, whether pagination affects the result set completeness, what the return format looks like, or whether there are any system limits. For a list operation with no annotation safety profile, this is a notable gap.

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

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

A single, efficient sentence that defines the resource in a parenthetical. No wasted words; the definition of 'ring groups' is genuinely helpful for an agent unfamiliar with telephony terminology.

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

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

For a simple list tool with two optional parameters fully documented in the schema and no output schema expected, the description is mostly adequate. However, the absence of any behavioral context (read-only hint, pagination implications, return format) leaves minor gaps that an agent might need filled, especially given there are no annotations to compensate.

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

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

Schema coverage is 100%, so the schema already documents both parameters (page and page_size) with clear descriptions. The description adds nothing about parameter usage beyond what the schema provides, which matches the baseline 3 for high schema coverage.

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

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

The description states a clear verb and resource ('List ring groups') and adds a useful parenthetical defining what a ring group is. However, it doesn't explicitly distinguish itself from the sibling yeastar_get_ring_group (list vs. get single), though the 'list' verb implicitly signals plural collection.

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

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

No guidance on when to use this tool versus alternatives. It doesn't mention that yeastar_get_ring_group retrieves a single ring group, nor does it explain when listing would be preferred over retrieving. The context of when to list vs. get a specific group is left entirely to the agent's inference.

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

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

The verb 'List' implies a non-destructive read operation, but no annotations are provided, so the description carries that burden. It does not disclose pagination behavior, ordering, limits, or whether all trunks are returned in one call; those details are left to the schema.

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 clear sentence with no wasted words. It front-loads the operation and resource and includes useful type clarification.

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 paginated list operation with fully documented parameters, the description is mostly adequate. However, with no annotations, no output schema, and a closely related sibling tool, the description should at least hint at the all-trunk vs. ITSP-trunk distinction or return scope to be fully complete.

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

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

The schema describes both parameters fully with 100% coverage, so the description does not need to restate them. The description adds no parameter-level meaning beyond the schema, but the baseline 3 applies because the schema covers the parameters.

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

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

The description names a specific verb ('List') and resource ('trunks') and adds the type categories VoIP/ITSP/FXO, making the purpose clear. It does not explicitly distinguish this generic trunk list from the sibling yeastar_list_itsp_trunks, so it does not fully differentiate.

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 about when to use this tool versus yeastar_list_itsp_trunks or yeastar_get_trunk. The sibling set suggests an important distinction, but the description provides no selection criteria or exclusions.

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