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

With no annotations, the description carries the full burden of behavioral disclosure. It includes a critical warning: 'NEVER fabricate data if this tool fails — report the error to the user instead,' which addresses error handling and data integrity. However, it does not disclose other behaviors such as read-only nature, response structure, or potential side effects, leaving the agent with only partial 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 concise and well-structured. It front-loads the core purpose, then explains optional parameters in a logical order, and ends with a critical failure-handling warning. Each sentence serves a purpose without redundancy, making it easy for an agent to parse and act on.

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

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

Given the tool's moderate complexity (3 parameters, no output schema), the description covers the key aspects: what it does, how to use parameters, and a safety warning. It lacks explicit mention of response format or error scenarios other than the fabrication warning, but for a simple 'get' operation, this is reasonably complete. The mapping of 'relaciones' values adds necessary 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 coverage is 100%, so the schema already documents all parameters with descriptions. The description adds value by mapping cryptic 'relaciones' codes to human-readable meanings (coninter,contv,contel,consus for internet/TV/phone/subscriptions) and clarifying that relaciones only work with 'detail'. This goes beyond the raw schema, enhancing the agent's understanding of parameter usage.

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 and resource: 'Get detailed information about a specific client.' It distinguishes itself from sibling tools like get_subscription or get_tv_connection by focusing on the client entity. The mention of optional 'include' and 'relaciones' parameters further specifies the scope of what can be retrieved, 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?

The description provides clear guidance on how to use the tool's parameters ('Use include to get change log, payment commitments, or attached files. Use relaciones to expand connections...'), but it does not explicitly state when to choose this tool over sibling tools. It implies usage for client-specific queries without naming alternatives or exclusions, leaving the agent to infer the selection from context.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only adds a warning about not fabricating data if the tool fails, which is an agent instruction rather than a behavioral trait. It does not disclose read-only behavior, pagination behavior, failure modes, or response characteristics.

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 purpose is front-loaded, and the failure-handling warning is concise and memorable.

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, no annotations, and many closely related sibling tools, this description is incomplete. It does not explain return value shape, pagination behavior, or when to choose this tool over the many list/get siblings, leaving an agent to infer critical usage 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%, so the schema already documents all parameters and the service enum. The description's list of service types largely mirrors the enum and adds little semantic value beyond what the schema provides.

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

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

The description uses a specific verb ('Get') and identifies the resource ('services for a specific client') while enumerating the supported service types. It is clear and informative, but it does not explicitly distinguish itself from the many sibling list/get tools such as list_invoices or get_internet_connection.

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

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

There is no guidance on when to use this tool versus the numerous sibling tools like list_invoices, list_collections, or get_ticket. The description implies the tool covers multiple service types, but it never states when an agent should prefer this aggregator over a more specific sibling.

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 must disclose behavior. It clearly states the tool is read-only (no mutation) and includes a strong honesty directive to avoid hallucination. This adds trustworthy behavioral context beyond 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 extremely concise with two well-structured sentences. The warning is front-loaded with an emoji for attention, making it efficient and scannable.

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

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

Given the tool is parameterless and has no output schema, the description is nearly complete. It explains the behavior (read-only), the expected output (summary counts), and provides a fail-safe instruction. The only minor gap is not specifying the time period or criteria for 'active'.

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 0 parameters, so no explanation is needed. The description adds meaning by specifying the output content (total and active client counts), which is helpful.

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 specifies the verb 'Get' and the resource 'a quick summary of total and active client counts', making the purpose clear. It does not explicitly differentiate from siblings like 'search_clients' or 'get_client', but the mention of 'summary' implies a broader, aggregative function.

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

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

The description provides a usage note about not fabricating data on failure, but does not explain when to use this tool over siblings. The summary nature is implied, but explicit guidance on when not to use it or alternatives is missing.

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 includes a notable behavioral instruction—not to fabricate data on failure—which is valuable for agent behavior. However, it lacks disclosure of read-only status, authentication needs, rate limits, or error response format. The warning prevents hallucination but does not comprehensively describe the tool's 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 one clear sentence plus a warning—short, front-loaded, and no redundant information. Every part earns its place.

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

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

For a single-item retrieval tool with two parameters and no output schema, the description covers the core purpose and provides a critical behavioral warning. It does not detail the return values (basic vs consolidated), common errors, or when to prefer basic over consolidated. Overall, fairly complete but could benefit from a brief output summary.

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

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

Schema description coverage is 100%, so both parameters are already documented. The description only echoes the optional consolidated flag ('optionally with consolidated data') without adding new meaning or usage details. 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 clearly states the tool retrieves details for a specific collection/payment, with optional consolidated data. This distinguishes it from sibling tools like list_collections (which returns multiple items) and get_invoice (different entity).

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

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

No explicit when-to-use or when-not-to-use guidance is given, nor are alternatives mentioned. However, from the tool name and sibling context, its intended use (getting a single collection) is implied. A clearer statement like 'Use this instead of list_collections when you have a specific collection_id' would raise this 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly indicates the tool is a read operation ('Trace') and warns about failure behavior ('NEVER fabricate data… report the error'). This is strong transparency for an unannotated tool. However, it does not mention whether the trace is recursive, what the depth limit is, or how errors manifest.

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 zero waste. The first sentence conveys the core purpose and chain, and the second adds a critical usage rule. Every word earns its place. It is front-loaded with the action and target.

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 moderate complexity (2 params, enum, no output schema), the description covers the essential behavioral and usage aspects. The missing output schema is offset by the description implying the trace chain. The only gap is the lack of mention of error conditions (e.g., what happens if the resource is not found).

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 adequately. The description adds value by stating the tool's upward-navigation purpose, which implicitly explains the role of 'resource_type' (starting point) and 'resource_id' (specific element). However, it does not elaborate on valid enum values beyond what the schema lists, nor does it explain the expected format of resource_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 clearly states the action ('Trace'), the target ('FTTx element'), and the direction ('upward through the hierarchy'). It also enumerates the specific chain of resources (port→box→PON→backbone), leaving no ambiguity about what the tool does. The purpose is distinct from sibling tools like 'get_network_element' (which likely fetches a single element without tracing) or 'list_fttx_infrastructure' (which lists elements).

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 warns against fabricating data if the tool fails, instructing the agent to report the error instead. However, it does not explicitly state when NOT to use this tool versus alternatives like 'get_network_element' or 'list_fttx_infrastructure'. The upward-trace behavior implies it's for hierarchical navigation, but no direct exclusions or alternative comparisons are provided.

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

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

No annotations are provided, so the description carries the full burden. It discloses the tool's behavior (getting detail or log) but lacks information on behavioral traits such as authentication requirements, rate limits, potential side effects, or error handling beyond the warning. The warning about not fabricating data adds some transparency but overall is minimal.

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 plus a clear warning. Every part is essential: the main action, the optional alternate mode, and the critical usage constraint. 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 the tool has 2 well-documented parameters with 100% schema coverage and no output schema, the description is adequate for understanding what the tool does and its modes. However, it lacks completeness for the 'log' mode (e.g., date filtering, log format) and does not describe the output structure. Since there is no output schema, more context would be beneficial.

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 does not add any parameter-specific semantics beyond what the schema provides (e.g., the 'include' enum values or 'connection_id' format). Thus it meets the baseline without exceeding 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 clearly states it gets detailed information about an internet connection or its change log. The verb 'Get' and the resource 'internet connection' are specific, and the description distinguishes the two retrieval modes ('detail' vs. 'log'). It stands out from siblings like get_tv_connection or list_internet_connections which serve different purposes.

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 warns against fabricating data and instructs to report errors to the user, which is a clear when-not usage guideline. However, it does not mention when to use this tool versus sibling tools like list_internet_connections (which lists connections) or the various log tools, missing an opportunity for better 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. It implies a read-only operation ('Get detailed information'), and includes a valuable warning about not fabricating data on failure. However, it does not disclose other behavioral traits such as required permissions, rate limits, or whether the operation is safe to call repeatedly. The warning adds some transparency but is not comprehensive.

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

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

The description is a single sentence with a clear purpose, followed by a warning in a new line. It is front-loaded and efficient. The warning, while useful, could be considered extraneous to the core purpose, but it does not significantly bloat the text. Almost every word earns its place, though the warning could potentially be moved to a separate field.

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

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

The tool has no output schema, so the description should explain what the return value contains. It mentions items, consolidated data, or PDF print link, but does not describe the overall structure (e.g., JSON object with invoice fields, line items, etc.). The warning about error handling is a positive addition. For a simple 2-parameter tool, this is adequate but leaves the agent guessing about the return format.

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

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

Schema coverage is 100%: both parameters have descriptions in the schema. The description mentions 'items, consolidated data, or PDF print link' which aligns with the 'include' enum values, but adds no new information beyond what the schema already provides (e.g., 'print_link' is already described as a PDF URL hosted on AWS valid for 30 days). Baseline 3 is appropriate.

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

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

The description clearly states the tool retrieves detailed information about a specific invoice, including items, consolidated data, or PDF print link. It uses a specific verb ('get') and resource ('invoice'), and naturally distinguishes from sibling tools like 'list_invoices' (which lists invoices without details) and 'get_client' (different resource).

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

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

The description implies the tool is used when you have an invoice_id and need detailed information, but it does not explicitly contrast with alternatives like 'list_invoices' for listing or 'search_clients' for filtering. There is no guidance on when not to use it or prerequisites, though the warning about not fabricating data provides indirect error-handling 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. It adds a key behavioral trait: the tool may fail, and the agent must report errors honestly. However, it does not disclose other traits like idempotency, rate limits, or whether it is read-only (reasonable given the purpose).

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

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

Two sentences, front-loaded with the main purpose, followed by a critical usage warning. Every sentence earns its place with no wasted words.

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

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

The description covers the input and a behavioral warning, but does not explain the return value structure or what 'details' are included (no output schema). For a retrieval tool, this leaves some uncertainty about the information provided.

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

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

Schema coverage is 100%, with both parameters having minimal descriptions ('Element ID', 'Type of element'). The description adds the list of valid types and a warning, but does not deepen parameter meaning (e.g., format of ID, case sensitivity). Baseline 3 is appropriate as the schema already describes 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 clearly states the tool's function: 'Get details of a specific element by type and ID', and enumerates all supported element types (node, subnode, VLAN, etc.). This distinguishes it from sibling tools like get_client or get_invoice, which operate on different 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 includes a strong behavioral instruction about not fabricating data on failure, but does not explicitly state when to use this tool versus alternatives (e.g., search_clients or get_network_status). The usage context is implied by the element types, but no direct comparison or exclusion is 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 full burden for behavioral disclosure. It only mentions a failure handling guideline but does not disclose whether the tool is read-only, destructive, requires authentication, has latency, or returns historical vs real-time data. The failure instruction is a guideline, not a 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?

The description is extremely concise with two sentences, the first clearly stating purpose and the second a critical guideline. No irrelevant information is included.

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

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

Given the complexity (simple tool with only two optional parameters, no output schema, no annotations), the description adequately covers the tool's purpose and a key usage warning. However, it does not explain return values or behavior when no filters are applied, which is a minor gap for completeness.

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

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

Schema description coverage is 100%, so baseline is 3. The description mentions the optional date range filter, which aligns with the two parameters. However, it does not add semantic meaning beyond what the schema already provides (e.g., date format, default behavior without filter).

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 gets network status with an optional filter by outage date range. It distinguishes itself from sibling tools like get_network_element or list_internet_connections by focusing on network status rather than specific elements or connection lists.

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

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

The description provides clear guidance on when to use it (getting network status) and explicitly warns against fabricating data if the tool fails, which is a usage constraint. However, it does not differentiate when to use this vs alternatives like get_network_element or other network-related tools.

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

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

No annotations are provided, so the description carries the full burden. It explicitly warns against fabricating data and instructs to report errors, which is a critical behavioral disclosure. It also mentions that the tool can return 'live line data from the Imowi mobile platform', implying potential real-time data freshness. However, it does not describe limits, error conditions, or performance implications beyond the warning.

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

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

The description is two sentences with minimal filler. The first sentence states the purpose and the second contains an important safety warning. The warning is front-loaded enough, though the phrase '(includes SSMovil mobile)' could be integrated more cleanly.

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 2 parameters, 1 enum, full schema coverage, and no output schema, the description is mostly complete. It covers the tool's purpose, the important 'do not fabricate' rule, and the tool's scope across telephony and Imowi. The only minor gap is the lack of explicit guidance on selecting between detail and imowi modes beyond the enum description, but the context is sufficient for a broad agent.

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 each parameter adequately. The description adds context about 'live line data from Imowi' that enriches the include enum, but does not explain default behaviors beyond what the enum description already covers. Thus, a baseline 3 is appropriate.

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

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

The description clearly identifies the tool as retrieving detailed information about a phone/telephony connection and mentions the SSMovil mobile and Imowi platforms. It distinguishes from list_phone_connections (listing vs. getting one) and provides domain-specific context, though it doesn't explicitly name a sibling alternative.

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

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

The description implies usage when specific phone connection details are needed, especially from the Imowi platform fruity live data. It does not explicitly state when to use this tool versus alternatives like get_subscription or get_tv_connection, but the 'Get detailed information' phrase provides clear context and the include enum offers usage choices.

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

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

With no annotations, the description must carry the behavioral disclosure burden. It includes a strong instruction to never fabricate data on failure, which is a valuable transparency note about error handling. However, it says nothing about whether the operation is read-only, what permissions are needed, or what the response contains on success. The warning partially compensates for the lack of 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 concise: one sentence stating the purpose followed by a clear, important warning. There is no redundant fluff, and the warning is front-loaded enough to catch attention. It could be slightly more structured, but it is appropriately sized for a simple tool.

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

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

For a single-parameter tool with no output schema, the description covers the basic purpose and includes a relevant behavioral warning. However, it does not mention what the tool returns (though 'detailed information' implies a response), nor does it specify any prerequisites beyond the required parameter. Given the low complexity, this is adequate but not comprehensive.

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 the single parameter subscription_id as a string 'Subscription ID' with 100% coverage. The description adds no additional meaning or context about the parameter—no format, example, or caveats. Since the schema already fully documents the parameter, the baseline of 3 is appropriate.

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

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

The description states a clear verb ('Get') and a specific resource ('subscription service'), making the tool's purpose obvious. It implies a single subscription rather than a list, which distinguishes it from list_subscriptions, but does not explicitly name alternatives. The warning about not fabricating data is additional context but does not affect purpose clarity.

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 its siblings. The description does not mention that this should be used when a specific subscription_id is known, nor does it contrast with list_subscriptions or list_subscription_catalog. The agent is left to infer usage from the parameter schema alone.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It warns about failure handling, which is useful, but it does not disclose side effects (likely none), authentication requirements, rate limits, or what happens on invalid supplier_id. It also does not describe the response structure since output schema is absent.

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

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

The description is short and to the point. The warning about data fabrication is front-loaded after the main purpose, but the warning is not overly long. Every sentence earns its place: the first states the purpose, the second provides a critical usage safety note.

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 retrieval tool with only 2 parameters and full schema coverage, the description covers the basic purpose and a key behavioral safety rule. However, with no output schema and no annotations, it could benefit from clarifying what 'detailed information' includes (e.g., available relations) and how the tool behaves on errors (e.g., returns empty or throws). It is adequate but not exhaustive.

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

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

Schema description coverage is 100%: both parameters (relaciones and supplier_id) are described in the schema. The description does not add additional insight beyond the schema; the warning about not fabricating data applies to the tool's overall behavior, not parameter usage specifically. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states the tool's verb ('Get') and resource ('detailed information about a specific supplier'), which distinguishes it from sibling tools like list_suppliers that list suppliers. It is concise and specific, though it does not name a sibling alternative explicitly.

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

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

There is no guidance on when to use this tool versus alternatives like list_suppliers or get_supplier_invoice. The description implies it is for fetching supplier details, but does not specify when to prefer it over listing or other related tools. The warning about not fabricating data is helpful for error handling but not about 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?

No annotations are present, so the description is responsible for behavioral guidance. It provides a clear operational rule: 'NEVER fabricate data if this tool fails — report the error to the user instead', and 'Get' signals a read operation. It does not address auth, rate limits, or return format, but the anti-fabrication instruction is material and helpful.

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 one terse sentence plus a warning, with no filler. The primary purpose is front-loaded, and the warning is a separate useful instruction.

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-resource getter with two fully documented parameters and no nested objects, the description is largely sufficient. It could have pointed to list_supplier_invoices for ID discovery or described the response shape, but the schema and warning cover the core calling requirements.

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

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

The input schema already fully documents both fields, including the invoice_id as 'Supplier invoice ID' and the include enum with descriptions. Coverage is 100%, so the description adds no parameter-level meaning; baseline 3 applies.

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

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

The description states a clear verb-resource pair, 'Get a specific supplier invoice', and explicitly covers the tax-lines variant via 'or its tax lines.' 'Specific' separates it from list_supplier_invoices, and 'supplier' separates it from get_invoice.

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 wording implies this is the tool for retrieving a single supplier invoice by ID rather than listing them, but it does not explicitly name list_supplier_invoices or state when to prefer listing. There are no exclusions or alternative routing, so the agent is left to infer the list-vs-get split.

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

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

With no annotations, the description carries the full burden. It does include a cautionary note about never fabricating data and reporting errors, which is valuable behavioral guidance. However, it does not disclose potential failure modes, permissions, or other side effects beyond this warning, lacking comprehensive 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 two sentences with zero wasted words. It front-loads the core purpose ('Get detailed information about a support ticket'), then lists optional components, and ends with an important safety warning. 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 complexity of the tool with multiple optional components and a relations parameter, the description covers the main functionality and includes a critical error-handling note. It does not explicitly describe return format, but as a 'get' tool it is implied. The absence of an output schema is partially offset by the description's clarity, though more detail on behavior (e.g., error responses) would improve completeness.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds slight clarity by listing the optional components (photos, log, checkin/checkout, etc.) that map to the 'include' parameter, but it does not provide deeper semantics beyond what the schema already describes. It adds marginal value but not substantial.

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

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

The description clearly states the verb 'Get' and the resource 'detailed information about a support ticket', with optional component details. It distinguishes from sibling tools like list_tickets by focusing on a single ticket with rich options, making its purpose unambiguous.

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

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

The description implies this tool is for retrieving detailed ticket info but does not explicitly state when to use it over alternatives like list_tickets or other get_* tools. No exclusions or alternative routing are provided, leaving usage somewhat implicit.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It adds a useful failure-handling directive: 'NEVER fabricate data if this tool fails — report the error to the user instead.' However, it does not disclose side effects, authentication needs, return format, or detailed failure behavior beyond this warning.

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

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

The description is two sentences with no wasted words. The main purpose is stated first, followed by a concise, high-value warning about not fabricating data on failure.

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, read-style tool with only two parameters and a complete schema, this description is mostly adequate. It covers both retrieval modes and the key failure behavior, though it does not describe what fields 'detailed information' includes or enumerate edge cases.

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

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

Schema description coverage is 100%; the schema already documents connection_id and include with the detail/dgo enum. The description's mention of 'DirecTV Go account data' maps to the existing enum and adds no new parameter semantics beyond the schema.

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

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

The description states a specific verb and resource: 'Get detailed information about a specific TV connection, or its DirecTV Go account data.' It clearly identifies the tool's purpose and distinguishes the detail vs dgo modes. It does not explicitly mention sibling tools, but 'specific' and 'detailed' imply a contrast with list_tv_connections.

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

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

The description implies usage for a single known TV connection via the required connection_id and the word 'specific,' but it does not explicitly say when to use this tool versus alternatives like list_tv_connections. There are no stated exclusions or alternative tool names.

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

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

With no annotations, the description carries the behavioral burden. The 'NEVER fabricate data if this tool fails' warning is a meaningful guardrail that goes beyond the tool's name, but the description still omits explicit read-only status, output shape, pagination, and include_deleted default 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 two short sentences with no fluff. The purpose is front-loaded and the warning sentence is concise, actionable, and non-redundant.

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

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

For a simple single-resource list tool, the schema fully documents all parameters and the description adds a useful safety directive. A brief note about the return shape would improve completeness, but the absence does not critically harm 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%, with the resource enum and include_deleted semantics fully documented. The description adds no additional parameter-level detail (just 'and more'), so the baseline of 3 is appropriate.

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

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

The description opens with a specific verb and resource ('List auxiliary/reference data') and gives concrete examples (localities, branches, users, warehouses, payment methods) that distinguish it from subscription, ticket, and invoice siblings. It falls short of 5 because 'and more' is vague and the full scope is only recoverable from the schema enum.

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

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

There is no guidance on when to choose this tool versus sibling tools like list_tickets, list_subscriptions, or get_client. The anti-fabrication warning concerns error handling, not selection criteria, so when-to-use reasoning is left entirely to inference.

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

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

With no annotations, the description carries full burden. It discloses that the tool returns 'database record snapshots before modifications' with timestamps and users, and includes a caution against hallucinating data. However, it omits details such as pagination limits, ordering, rate limits, or authentication requirements. The transparency is adequate but not comprehensive.

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

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

The description is very concise with two purposeful sentences and a warning. It front-loads the core purpose and return value. The structure is efficient with no filler. Could be slightly improved with structured bullets, but it earns a 4 for its lean design.

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 and 4 optional parameters, the description covers the return content (snapshots with timestamps and users) and the scope ('across all clients'). However, it lacks any mention of pagination behavior (e.g., max pages, default ordering) or how date filters affect results. For a log-list tool, this leaves some gaps in completeness.

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

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

Schema description coverage is 100%, so the input schema already documents all 4 parameters (page, logDesde, logHasta, per_page). The description adds no additional meaning or context for the parameters beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description uses a specific verb 'List' and clearly identifies the resource as 'change history logs across all clients.' It distinguishes from sibling log tools (e.g., list_tickets_log, list_internet_connections_log) by specifying the scope is client-related. The return value (snapshots before modifications with timestamps and users) is explicitly stated.

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

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

No guidance is provided on when to use this tool versus alternatives such as get_client or list_tickets_log. There is no mention of prerequisites, when not to use it, or comparisons to sibling tools. The only behavioral instruction is a warning about not fabricating data, which concerns failure handling rather than usage context.

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

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

With no annotations, the description carries full burden. It only provides a warning about error reporting, but lacks disclosure on pagination behavior, authentication requirements, rate limits, or output format. The basic action (list with filters) is stated but deeper behavioral traits are absent.

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

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

Two efficient sentences: one for purpose, one for behavioral warning. No unnecessary words; the warning earns its place by preventing data fabrication. Front-loaded with the core 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 6 parameters and no output schema, the description only mentions date and user filters. It omits pagination defaults (page, per_page), the 'relaciones' parameter for expanding relations, and any explanation of return value structure. The warning is helpful but the description is incomplete for a filtering endpoint with multiple options.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds that filters are by date and user, which the schema already documents (e.g., 'Filter by user', 'Created from date'). No additional semantic value beyond the schema.

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

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

Description clearly states the verb 'List', the resource 'payment collections', and the filtering scope by date and user. This distinguishes it from sibling tools like get_collection (single) and other list tools. The schema parameters align with this purpose.

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

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

No explicit guidance on when to use this tool versus alternatives such as get_collection or search_clients. The warning about not fabricating data addresses error behavior but does not help the agent choose this tool over similar ones.

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 burden. It implies read-only behavior via 'Query' and adds a valuable anti-fabrication warning on failure. However, it does not disclose pagination behavior, error response shapes, or other operational 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?

Three sentences with no filler: purpose first, then usage, then a critical warning. The hierarchy is compactly expressed and the warning is front-loaded enough to be noticed.

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 6-parameter tool with no output schema, the description plus schema covers resource selection, hierarchy drilling, text search, and failure handling. It lacks explicit output/error shape details, but the schema fills the parameter-level 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 schema already documents all parameters. The description adds a concise hierarchy summary and selection guidance, but it largely restates what the schema already provides rather than adding 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 queries FTTx fiber infrastructure and enumerates the resource types (backbones, PONs, NAP boxes, ports, seals). It is specific about the verb and resource, but it does not explicitly distinguish itself from sibling tools like list_fttx_trace.

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

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

The description gives concrete usage guidance: use resource_type to select, parent_id to drill down the hierarchy, and q for text search. It provides clear context but does not mention when not to use this tool or name alternatives.

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

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

With no annotations, the description carries the full burden. It usefully warns that technology codes may differ from documentation and should be checked against existing records, and it instructs the agent to report errors rather than fabricate data. However, it does not disclose pagination behavior, response format, or other operational traits beyond the failure warning.

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

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

The description is compact and front-loaded, with the purpose in the first sentence and no filler. The warning and technology caveat are each purposeful and add real value for correct tool use.

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 11 parameters, no annotations, and no output schema, the description leaves some gaps: it does not describe the return format/fields, pagination behavior, or how this listing relates to sibling log/detail tools. The parameter caveat is helpful, but overall context for a complex list tool is not fully complete.

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

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

All 11 parameters already have schema descriptions, so the baseline is met. The description adds meaningful, non-obvious semantics for the tecnologia parameter: it maps to conexion_tipo, notes that documented codes differ from instance-specific codes, and advises checking existing records. This goes beyond the schema.

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

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

The description states a specific action and resource: 'List internet service connections with filters.' This clearly distinguishes it from sibling tools like list_phone_connections, list_tv_connections, and get_internet_connection. The scope is immediately understandable.

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

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

The description implies when to use this tool—when listing internet connections—and gives a filter-specific caveat, but it does not explicitly state when not to use it or name alternatives such as list_internet_connections_log for historical data. Usage context is present but exclusion guidance is absent.

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 includes a warning about never fabricating data and to report errors, which adds behavioral transparency. However, it doesn't disclose what the tool does if no logs exist, whether it respects permissions, or how it handles large date ranges.

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 to the point, with a front-loaded purpose. The only extra sentence is a warning which adds value. 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 the tool has no output schema and no annotations, the description does not fully cover what the response looks like (e.g., array of logs, metadata). It also omits the default page size and whether pagination is required. Adequate but incomplete.

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

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

Schema description coverage is 100%, so the schema fully documents parameters. The description adds the context of date filters but no extra semantic detail beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool lists change history logs across all internet connections with date filters. The verb 'list' and resource 'internet connections log' are specific, though it doesn't distinguish itself from sibling tools like list_tickets_log.

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 mentions date filters, implying when to use. However, there is no guidance on when not to use this tool versus alternatives, nor any prerequisites or context like required permissions or pagination behavior.

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 adds the warning 'NEVER fabricate data if this tool fails — report the error to the user instead,' which is meaningful behavioral context about failure handling. However, it does not disclose authentication needs, rate limits, or whether the operation is read-only, leaving gaps in 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 three concise sentences, front-loaded with purpose, followed by type definitions and a critical warning. No excessive detail 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?

The description covers purpose, filtering dimensions, type semantics, and a failure behavior warning. It does not explain the output structure (no output schema) or pagination behavior explicitly, which leaves some uncertainty for a tool with seven parameters, though the schema covers those details.

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

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

Schema coverage is 100%, giving a baseline of 3. The description adds value by grouping the type codes into invoices, credit notes, and debit notes, which is semantic information not present in the schema's flat list. This grouping helps agents choose appropriate type values.

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

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

The description uses the specific verb 'List' with the resource 'invoices' and lists filter dimensions (date, type, point of sale). It distinguishes from sibling tools like get_invoice by implying plural listing rather than singular retrieval, and the type code breakdown clarifies the scope.

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

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

The description does not mention when to use this tool versus alternatives such as get_invoice or other list_* tools. It provides no explicit exclusions or alternative suggestions, so an agent receives no guidance for tool selection beyond the tool name.

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

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

Since no annotations are provided, the description bears full responsibility for behavioral disclosure. It warns about data fabrication with a 'NEVER' directive and the '⚠️' icon, which is critical for an AI agent. It also implies the tool is read-only (list) and may fail, but does not disclose rate limits, authentication needs, or pagination behavior beyond the schema's default 50 per page. Still, the fraud warning is a strong transparency element.

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 relatively short (3 sentences) and front-loads the main purpose. The warning about data fabrication is important but could be integrated more tightly. There is no clutter or redundancy. It earns points for being succinct while still covering purpose and a strong behavioral note.

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 8 parameters, no output schema, and no annotations, the description covers the core purpose, key filters, and a critical behavioral warning. It does not describe return format, error scenarios beyond the fabrication warning, or how pagination works beyond per_page default. For a list tool with good schema documentation and no output schema, this is reasonably complete but could include more on response structure.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds context by mentioning filterable dimensions (client, date, cut-off status) and the mobile identification hint, but does not explain each of the 8 parameters beyond what the schema already provides. The schema itself is detailed (e.g., enum values, date format hints), so the description's added semantic value is modest.

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 identifies the resource as 'phone/telephony service connections' with an explicit mention of 'SSMovil mobile'. It distinguishes itself from sibling tools like 'list_internet_connections' and 'get_phone_connection' by specifying the scope includes mobile connections and by listing available filters.

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

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

The description provides explicit usage context by listing filterable fields (client, date, cut-off status) and explaining how to identify mobile/SSMovil connections via 'telefonia_plan_movil=Y'. It also includes a strong warning against fabricating data when the tool fails. However, it doesn't explicitly state when NOT to use this tool versus alternatives like 'get_phone_connection' or 'list_internet_connections_log', which would elevate it to a 5.

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

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

No annotations were provided, so the description carries the full burden. It discloses that the tool returns a list and accepts optional filters, and importantly warns the agent not to fabricate data if the tool fails, which is a critical behavioral trait. It could mention pagination or response format but is generally 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 two sentences and 20 words. It front-loads the core purpose and then adds the critical caveat about not fabricating data. Every sentence earns its place, and there is no wasted text.

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

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

Given that there is no output schema and 3 parameters with 100% schema coverage, the description is reasonably complete. It explains the tool's purpose and key filters, but could optionally mention the expected return format or default behavior (e.g., whether non-deleted, non-discontinued plans are returned by default). However, the enum defaults are clear from 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 baseline is 3. The description adds value by explaining that the 'borrado' and 'discontinuo' parameters filter for deleted and discontinued plans respectively, which reinforces and clarifies the enum options already documented in the schema. The 'q' parameter for text search is implied by the schema, but the description does not provide additional detail beyond the schema.

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

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

The description clearly states the verb 'list' and the resource 'internet plans', and specifies optional filters for deleted or discontinued plans. This distinguishes it from sibling tools which focus on clients, invoices, connections, tickets, and network infrastructure.

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

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

The description does not explicitly state when to use this tool versus alternatives like list_internet_connections or search_clients. However, it includes a warning against fabricating data on failure, which provides operational guidance but not usage context.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It adds a useful failure-handling instruction ('NEVER fabricate data... report the error'), but it does not describe return format, pagination, filtering behavior, or other side effects. The warning provides some transparency but not comprehensive behavioral context.

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

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

The description is one concise sentence followed by a relevant warning. It front-loads the action and resource scope, and every sentence earns its place. There is no unnecessary verbosity.

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

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

The schema covers parameters well, and the description adds a failure-handling instruction, but there is no output schema and no guidance on how results are returned or when to prefer this over sibling tools. For a simple list operation, 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?

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds no additional parameter-level meaning beyond restating the resource types, which are already captured in the resource enum. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('List') and resource ('subscription catalog'), and enumerates the exact resource types: plans, categories, or subcategories. It is clear about what the tool does, though it does not explicitly differentiate itself from siblings like list_plans or list_subscriptions.

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

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

There is no guidance on when to use this tool versus alternatives such as list_plans or list_subscriptions. The warning about not fabricating data is operational advice, not usage selection guidance, so the agent is left to infer the appropriate context.

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

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

With no annotations, the description carries the burden. It implies a read-only operation via 'List' and adds a valuable behavioral rule about never fabricating data on failure. However, it does not disclose pagination behavior, default fields returned, or relation expansion semantics beyond what the schema already exposes.

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

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

Two short sentences with no fluff. The core action and filters come first, followed by an important safety warning. Every word earns its place.

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

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

The description tells the agent what the tool lists and how to filter, and it warns against fabrication. Yet with no output schema and no annotations, it omits the result shape, pagination details, and handling of empty results, leaving meaningful gaps for a 10-parameter tool.

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

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

The schema covers 100% of parameters with descriptions, so a baseline of 3 applies. The description merely restates some key filters (client, plan, subcategory, date, active status) in human terms and adds no meaning beyond the schema's own parameter 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 states a specific verb ('List'), a clear resource ('subscription services'), and gives a concrete example (SS Seguridad alarm monitoring). The filter list further narrows scope)Skip This is distinct from siblings like get_subscription or list_subscription_catalog because it names the exact resource type.

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 lists available filters but gives no guidance on when to choose this tool over siblings such as get_subscription or list_subscription_catalog. There is no explicit 'use when...' or 'use alternative when...' information.

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 burden of behavioral disclosure. It adds a valuable warning about never fabricating data if the tool fails and instructs reporting errors, which is useful. However, it does not describe return format, pagination behavior, auth requirements, or confirm that the operation is read-only.

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 wasted words: the first front-loads the action and resource, and the second adds a critical integrity warning. Both sentences earn their place.

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

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

The schema covers all parameters and defaults, and the warning covers error-handling behavior, but with no output schema and no annotations, the description leaves response format and safety profile unstated. It is adequate but has clear gaps for a list tool with eight 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 documents all eight parameters. The description adds only a high-level mention of filters by date, point of sale, voided, and deleted status, which is helpful but does not meaningfully extend the schema's parameter 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 states a specific action ('List') and a specific resource ('supplier invoices'), further clarified in Spanish. This clearly distinguishes it from sibling tools like list_invoices and get_supplier_invoice by resource type and operation granularity.

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

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

The description implies the tool is for supplier invoice listing with filters, but it does not explicitly explain when to prefer this over list_invoices or when to use get_supplier_invoice for a single record. No exclusions or alternative routing are provided, so the agent must infer usage from the name and resource.

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, but it only implies a read-only list operation and adds a failure-handling warning. It does not disclose pagination, return shape, default deleted-status behavior, sorting, or auth/rate-limit context. The warning is an agent directive rather than a 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?

The description is two short sentences with the core purpose front-loaded. The 'NEVER fabricate data' warning is somewhat outside the typical scope of a tool description but is relevant and not verbose.

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

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

Without an output schema or annotations, the description should clarify what the list returns and how filters and relations behave; it does not. It also omits 'relaciones' and any default behaviors, so an agent may not fully understand the tool's options despite 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 baseline is 3. The description maps q, loc, iva, and borrado to 'text, locality, VAT type, and deleted status' but adds no syntax, defaults, or relation-expansion details beyond the schema. It omits 'relaciones', though the schema documents it.

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

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

The description clearly states a specific verb ('List') and resource ('suppliers/proveedores'), and it names the main filter dimensions (text, locality, VAT type, deleted status). It is unambiguous, though it does not explicitly distinguish this tool from siblings like get_supplier or list_supplier_invoices.

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

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

The description implies the tool is for filtered supplier listing, but it does not state when to choose it over the sibling tools or mention exclusions or prerequisites. Usage guidance is inferred from the verb and resource rather than explicitly provided.

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

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

No annotations are provided, so the description bears full responsibility. It discloses the tool's listing behavior and includes a caution about error reporting, which hints at potential failure modes. However, it omits behavioral details such as pagination limits, rate limits, or auth requirements, making the transparency adequate but incomplete.

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 zero waste: the first sentence states purpose and filtering options, the second adds a critical behavioral instruction. 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?

Given 7 parameters, no output schema, and no annotations, the description is too sparse. It does not explain return format, pagination behavior, the 'relaciones' parameter, or how results are ordered. The warning is useful but insufficient to make the tool fully understandable without external knowledge.

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 each parameter having a description. The tool description summarizes filters by date, category, and status, which aligns with schema properties but adds no new meaning beyond what is already in the schema. Baseline 3 is appropriate.

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

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

The description clearly states the verb 'List' and resource 'support tickets' along with filtering dimensions. It distinguishes from siblings like 'get_ticket' (singular) and 'list_tickets_log' (log), but does not explicitly contrast them, so it earns a 4 rather than 5.

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

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

The description provides a warning about not fabricating data on failure, but offers no guidance on when to use this tool versus alternatives (e.g., get_ticket for a single ticket, list_tickets_log for history). There is no context on prerequisites or optimal scenarios.

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

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

With no annotations, the description carries the full burden. It discloses the return content (movement/change history with timestamps and users) and adds a notable behavioral instruction about not fabricating data on failure. However, it omits pagination behavior, sorting, or any limitation details, leaving gaps an agent may need to infer. The fabrication warning adds value beyond the basic 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 zero fluff. The first sentence states the purpose and return content, front-loaded for quick scanning. The second sentence is a succinct but important warning about error handling. Both earn their place, making it highly efficient.

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 list with optional pagination and date filters; the description explains the essence (returns history with timestamps and users) but does not mention pagination defaults, response structure, or error behavior beyond the fabrication warning. Without an output schema, an agent might be uncertain about the exact shape of the result, but the core purpose is covered adequately for a simple 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 description coverage is 100%, with each parameter (page, logDesde, logHasta, per_page) already documented in the schema. The description does not add extra parameter meaning or usage hints, so it remains at the baseline 3. No compensation needed since the schema is complete.

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

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

The description clearly states it lists ticket activity logs across all tickets, distinguishing from siblings like list_tickets (which lists tickets themselves) and other resource logs (clients, internet connections). It also specifies the return content: movement/change history with timestamps and users, making the purpose explicit and non-confusable.

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

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

The context is clear from the name and description—this is for ticket logs, not alternatives explicitly mentioned. It does not provide when-not-to-use or alternative routing, but the purpose is obvious enough that an agent would select this for ticket log queries. Lacks explicit exclusions, but the scope is unambiguous.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It warns against data fabrication, which is a helpful behavioral constraint. However, it doesn't disclose whether the tool is read-only or destructive, what the response format looks like (e.g., paginated object or raw list), or rate limits. The warning adds value but leaves significant gaps.

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

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

The description is extremely concise at two sentences with no wasted words. It front-loads the core purpose and crucial behavioral warning. 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 8 parameters, no output schema, and no annotations, the description is somewhat minimal. It names the filter dimensions and adds a critical usage warning, but it doesn't describe the return type or pagination behavior. For a tool of this complexity, a bit more context (e.g., 'returns paginated results with connection details') would improve completeness.

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

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

Schema description coverage is 100%, so the baseline is 3. The description provides a high-level summary of filter categories (client, date, status) which loosely groups the parameters, but it adds no additional semantics beyond what the schema already documents (e.g., date formats, enum meanings, or the 'relaciones' parameter). It doesn't enhance the schema's information.

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

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

The description clearly states the tool lists TV service connections and identifies the three filter dimensions (client, date, status). It distinguishes itself from siblings like list_internet_connections and list_phone_connections by focusing specifically on TV connections. A score of 5 is not given because it doesn't explicitly state the scope (e.g., all connections for a client) or differentiate from the related get_tv_connection 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?

The description provides a strong usage caution (never fabricate data, report errors), which guides agent behavior on failure. However, it gives no guidance on when to use this tool vs. alternatives like get_tv_connection (which likely returns a single connection), nor any prerequisites or context about pagination defaults.

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

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

With no annotations, the description carries the behavioral burden. It discloses that failures should not be papered over and errors must be reported, which is a meaningful trait. However, it does not clarify read-only status, pagination behavior, or other operational details for a non-annotated 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 short and front-loaded with the core purpose, and the critical failure-handling warning earns its place. The phrase 'and more' is slightly vague but does not significantly bloat the text.

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

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

For an 11-parameter tool with no annotations and no output schema, the description is minimally adequate: it identifies the operation and a key behavioral rule. It lacks sibling differentiation, response-format context, and guidance on pagination or filtering trade-offs, which an agent would benefit from given the tool's complexity.

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

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

Schema description coverage is 100%, so the schema fully documents all 11 parameters. The description's mention of 'text search, date range, tax status' loosely maps to q, altaDesde/altaHasta, and contribuyente, but adds no new semantic information 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 ('Search and list') and resource ('ISPKeeper clients') with a clear emphasis on filters. It is unambiguous about what the tool does, though it does not explicitly distinguish itself from siblings like get_client or list_clients_log.

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

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

The description implies use when the agent needs to search or list clients with filtering, but offers no explicit when/when-not guidance or mention of alternatives. The warning about not fabricating data is behavioral, not usage direction.

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