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

With no annotations, the description carries the full behavioral burden. It mentions the 5000 limit but omits side effects (e.g., duplication handling, idempotency, error behavior, whether the list must pre-exist). This is a mutation tool with no disclosure of consequences.

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

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

A single, front-loaded sentence that captures purpose and a key constraint. No wasted words, easy to parse.

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

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

Given no annotations or output schema, the description is functional but thin. It covers the core action and limit but lacks guidance on prerequisites, failure modes, or what the response contains. An agent would have to infer behavioral 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% and the description's 'contacts[] with phone_number each' simply mirrors the schema. The only addition is the 5000 limit, which the schema already states in the contacts property description. No extra meaning is added.

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

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

States a specific verb and resource: 'Add contacts to a contact list'. Clearly distinguishes from siblings like create_contact or create_contact_list. The limit 'up to 5000 per call' adds a precise scope.

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

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

The description implies the tool is for populating an existing list but does not explicitly say when to use it over alternatives like create_contact or update_contact_list. No when-not-to-use conditions or alternative references are given.

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

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

No annotations exist, so description carries the full burden. It discloses the sync/async behavior and job_uuid for async, but omits side effects like cost, irreversibility, or that it actually sends messages (though 'send' implies this). Adequate but not rich.

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

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

Two sentences, zero waste. Action, required fields, either/or condition, and sync/async thresholds are all front-loaded. Every word earns its place.

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

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

For a 6-param tool with no output schema, it covers the essentials: endpoint, required fields, either/or constraint, and async behavior. It doesn't explain sync output format or error conditions, but the core calling logic is fully described.

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

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

Schema coverage is 100%, so baseline is 3. The description adds a critical constraint not in the schema: the either/or requirement of to[] or list_uuid, clarifying that from+text alone is insufficient. This is valuable 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?

States a specific verb+resource (bulk-send SMS to many recipients) and includes the HTTP endpoint. Clearly distinguishes from single-send sibling tools like send_sms and schedule_sms by the word 'bulk'.

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

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

Gives explicit usage conditions: requires from+text and either to[] or list_uuid, plus sync/async thresholds (≤500 vs 501–50k). Does not explicitly contrast with send_sms for single sends, but the threshold logic provides clear 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 must carry the full burden of behavioral disclosure. It implies a read-only operation but does not explicitly state safety, authentication requirements, or the response format. The description adds little beyond what the name and schema already imply.

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

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

The description is a single concise sentence that is front-loaded with the primary action and includes the optional scope. There is no filler or redundant information.

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

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

For a simple check tool with two parameters and no output schema, the description covers the purpose and optional scope but omits the response format or any behavioral details such as whether it checks global opt-out by default. Without annotations, more context on the return value would be helpful.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds context that list_uuid is an optional scope, which clarifies its purpose beyond the schema's 'Optional opt-out list UUID' by indicating it scopes the check. This adds meaningful value.

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 ('Check') and the resource ('whether a phone number is currently opted out / suppressed'), and mentions the optional list_uuid scope. This distinguishes it from sibling tools that manage opt-out lists or entries rather than check status.

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

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

No guidance is provided on when to use this tool versus alternatives such as list_opt_out_entries or create_opt_out_entry. The description implies usage but does not specify exclusions or recommend this tool over others for checking a single number.

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, but it only states that this is a create operation and lists required/optional fields. It does not disclose side effects, idempotency, duplicate handling, response behavior, or any postconditions an agent might need to know for a mutating tool.

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

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

A single front-loaded sentence with zero filler. It leads with the verb and resource, then covers requirements and optional parameters economically. 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?

Adequate for a simple 4-parameter tool with fully documented schema fields, but with no annotations and no output schema, the description omits return-value behavior and any postconditions. An agent invoking a create operation would benefit from knowing what the tool returns, making this minimally complete but not thorough.

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 marginal value by summarizing which parameter is required and which are optional, but this largely duplicates the schema's 'required' array and property 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 and resource — 'Create an SMS Center contact' — which is clear and unambiguous. The 'SMS Center' qualifier helps differentiate it from generic contact operations, though it doesn't explicitly name or contrast any sibling tool, so it falls short of a full 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 gives no guidance on when to use this tool versus alternatives like add_contacts_to_list or update_contact. It only restates parameter requirements ('Requires phone_number; optional...'), which is schema-level information rather than usage context, and provides no exclusions or decision rules.

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 disclosing behavior, but it only says 'Create...' and lists fields. It does not mention returned data, whether creation is idempotent, default values, or any permissions/effects beyond the obvious mutation.

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

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

Two short sentences with the core purpose front-loaded. No filler or redundant restatement of schema details.

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

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

The tool is simple and the schema fully covers parameters, but with no output schema or annotations the description leaves behavioral context (response, defaults, side effects) and sibling differentiation unaddressed. It is minimally viable but not complete.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description names the fields but adds no additional meaning beyond the schema entries.

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

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

The description states a specific action and resource: 'Create an SMS contact list.' It distinguishes this from sibling create_opt_out_list and create_contact by naming the contact-list 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?

No guidance is given for when to use this tool versus alternatives such as create_opt_out_list, add_contacts_to_list, or create_contact. The purpose sentence implies a create action but does not provide context, prerequisites, or exclusions.

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

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

With no annotations provided, the description must disclose behavioral traits. It implies a mutation (creating an opt-out entry) but does not state side effects, idempotency, whether existing entries are checked, or reversibility. It only mentions 'Requires phone' as a constraint.

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, front-loaded with the purpose and a key constraint. There is no wasted wording; every word contributes to understanding the core function.

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?

As a mutation tool with no annotations and no output schema, the description is too minimal. It lacks details about prerequisites (e.g., list must exist), phone format, success/error behavior, or consequences, leaving significant gaps for an 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 coverage is 100%, so each parameter is already described. The description adds only 'Requires phone', which reiterates a required field without adding new meaning. No extra context about uuid or notes is provided, so the baseline of 3 applies.

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

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

The description clearly states the verb 'suppress' and the resource 'recipient on an opt-out list', distinguishing it from sibling tools like create_opt_out_list (creates lists) and check_opt_out (checks status). It is specific and actionable.

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 offers no guidance on when to use this tool versus alternatives like list_opt_out_entries or check_opt_out. It does not mention exclusions or contexts that favor other 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 of behavioral disclosure. It merely states that it creates a list, which implies mutation, but does not mention any side effects, required permissions, idempotency, return behavior, or failure modes. The description offers no additional behavioral context beyond the obvious fact of creation.

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, front-loaded with the primary purpose, and includes a useful caveat about documentation quality. There is no fluff or redundancy; every word contributes. It is appropriately concise for a create operation.

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

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

With no output schema and no annotations, the description must cover return values, prerequisites, and error scenarios. It does none of these. For a create tool, an agent would benefit from knowing whether it returns the created object, if it requires existing account context, or how it relates to opt-out entries. The description is incomplete for an agent to invoke it confidently, especially given the 5 optional parameters and no required fields.

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

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

The schema provides descriptions for all 5 parameters (100% coverage), so the baseline is 3. The description adds marginal value by noting that 'name/slug' are common and 'default/active' are optional flags, which roughly aligns with the schema. However, it does not add meaningful semantic detail beyond what the schema already documents, and it slightly under-weights the 'description' parameter.

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 ('Create') and resource ('SMS opt-out list'), which distinguishes it from sibling tools like list_opt_out_lists (listing) and create_opt_out_entry (creating entries within a list). The purpose is specific and unambiguous, and the caveat about OpenAPI documentation does not obscure the core 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?

There is no guidance on when to use this tool versus alternatives such as create_opt_out_entry or add_contacts_to_list. No explicit exclusions or conditions are provided. The description only states what it does, leaving the agent to infer usage context, which is insufficient given the presence of closely related sibling 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 full responsibility for behavioral disclosure. It only says 'Create' and repeats required parameters; it does not mention side effects, permission requirements, cost implications, or what kind of response the agent can expect.

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

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

The description is extremely concise: two short sentences with no filler. The core action is front-loaded, and the required-field note is directly relevant.

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

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

For a tool with 9 parameters, no annotations, and no output schema, the description is too thin. It does not explain what happens upon successful creation, what the response contains, or any operational caveats, leaving the agent without important execution 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 every parameter. The description adds no additional semantic value beyond restating that password and caller_id_number are required, which is also already in the schema's required list.

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

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

The description names a specific action ('Create') and a specific resource ('SIP trunk'), which clearly distinguishes it from sibling tools like update_sip_trunk, delete_sip_trunk, and list_sip_trunks. It also names the two required fields, adding useful precision.

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

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

Usage is implied by the verb 'Create' — an agent can infer it is for creating a new SIP trunk rather than updating or deleting one. However, there is no explicit guidance on when to choose this over update_sip_trunk or any prerequisites beyond the required parameters.

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 states 'Delete an SMS Center contact' without mentioning whether deletion is permanent, whether it cascades to contact lists, what happens if the contact does not exist, or any authorization requirements. For a destructive operation, this is a significant gap.

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

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

The description is a single sentence with no redundant words. It is front-loaded with the action and resource, making it easy to scan. There is no unnecessary elaboration, which is commendable 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?

Given the lack of annotations and output schema, the description is insufficiently complete. It does not explain the result of the operation, error handling, idempotency, or any side effects. For a mutation tool, this leaves the agent without critical context needed to use it safely and effectively.

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

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

The schema description coverage is 100%, as the single parameter contact_id has a description ('Contact id'). The tool description adds no additional meaning beyond the schema, so the baseline score of 3 is appropriate. The agent can rely on the schema for parameter 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 states the verb 'Delete' and the resource 'SMS Center contact', which clearly indicates the action and target. It distinguishes from sibling tools like delete_contact_list or delete_did by specifying the contact resource, though it adds little beyond the name itself.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, scenarios where deletion might be unsafe, or differences from related tools such as delete_contact_list. The agent must infer usage solely from the tool name and schema.

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 discloses a key non-obvious side effect: historical SMS activity is preserved. This is valuable transparency beyond the obvious destructive action. It does not mention authorization or reversibility, but for a simple delete operation, this is sufficient.

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

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

One concise sentence with an efficient parenthetical. The primary action and resource are front-loaded, and the clarification is directly relevant. No redundant words.

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

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

For a tool with one required parameter, no output schema, and no nested objects, the description covers everything an agent needs: it names the resource, the action, and a critical caveat about historical data. Nothing essential is missing.

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

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

Schema coverage is 100%: the single parameter uuid is already documented as 'Contact list UUID'. The description adds no further meaning about the parameter (e.g., format or source). Baseline of 3 applies because the schema fully covers the parameter semantics.

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

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

The description uses a specific verb ('Delete') and resource ('SMS contact list'), clearly distinguishing it from sibling delete_contact (which deletes individual contacts). The parenthetical clarifies scope, ensuring an agent understands this tool removes the list itself, not its historical activity.

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

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

The description gives clear context on what the tool does and even notes what it does NOT do, but it does not explicitly state when to prefer this over alternatives like delete_contact or delete_did. The 'does not delete historical SMS activity' clause is a scoping hint, not an explicit usage directive. Slightly below the threshold for explicit guidance.

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

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

No annotations exist, so the description must carry the full behavioral burden. It only says 'Delete / release', implying a destructive operation, but does not disclose whether it is permanent, what side effects occur on associated resources, or whether special permissions are needed.

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

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

A single sentence with no wasted words; the action and object are immediately clear. However, brevity sacrifices essential behavioral context.

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

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

Given it is a mutation with no annotations or output schema, the description is under-specified. It fails to mention expected return behavior, reversibility, or failure conditions, which an agent would need for correct invocation.

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

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

The input schema describes did_number as 'DID number' with 100% coverage, so the description does not need to add parameter detail. The tool description adds nothing beyond the schema, and the baseline of 3 applies.

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

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

The description states a clear action ('Delete / release') on a specific resource ('a DID') and scopes it to 'from the account', distinguishing it from read/update/purchase sibling tools. Though it doesn't explicitly name alternatives, the verb is unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives like update_did or list_dids. There are no stated prerequisites, consequences, or exclusions, leaving the agent without context on appropriate conditions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the deletion action but does not mention irreversibility, cascading effects on related resources, or any required permissions. For a destructive operation, this is a significant gap.

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

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

The description is a single concise sentence that is front-loaded with the action and resource. It wastes no words, though it could add a brief note on deletion consequences without becoming 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?

For a destructive tool with no annotations and no output schema, the description is too thin. It does not explain what happens after deletion, whether the action is reversible, or how it relates to the broader SIP trunk lifecycle. An agent would need to infer these 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 description coverage is 100%, so the schema already documents trunk_id as a SIP trunk UUID. The description adds no additional meaning beyond restating the parameter name, but the schema is sufficient, so baseline 3 is appropriate.

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

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

The description states a clear verb and resource: 'Delete a SIP trunk by trunk_id.' It is specific enough to distinguish from siblings like create_sip_trunk and update_sip_trunk, though it does not explicitly name them.

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, nor any context about prerequisites or consequences. The description simply states the action without situating it among sibling 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 of behavioral disclosure. 'Get' implies a read-only operation, but the description does not explicitly state that it has no side effects, what account is accessed, or whether authentication is required. It does hint at the response fields, but otherwise offers minimal behavioral context.

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

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

The description is a single sentence with no filler, and the core action is front-loaded: 'Get account balance'. Every part of the sentence carries meaning, either identifying the operation or hinting at the returned values. This is appropriately concise for a tool with no parameters.

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

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

For a zero-parameter, no-output-schema tool with no annotations, the description is mostly complete: it states the resource and suggests the returned fields. It does not explicitly mention that the balance belongs to the current authenticated account or define the format of 'balance', but the tool's simplicity makes these gaps minor. A richer description could clarify the response structure, but none is strictly necessary for basic invocation.

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

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

The tool has zero parameters discriminative schema confirms no inputs are required, so parameter-level description is unnecessary. The baseline for zero-parameter tools is 4, and the description does not need to explain parameter semantics. The parenthetical likely describes output fields, not inputs, and any ambiguity is mitigated by the empty 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 names the operation ('Get') and the resource ('account balance'), with a parenthetical hint about the response shape: 'account_code, balance'. It is distinguishable from the sibling tools, which concern messages, contacts, DIDs, and SMS rather than account balance. However, the parenthetical is not explicitly labeled as the return format, leaving slight ambiguity about whether account_code is an input or an output.

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

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

The intended usage is implied: call this tool when you need the account balance. There is no explicit guidance about when to prefer this over alternatives, nor any mention of exclusions or prerequisites. Since no sibling tool covers balances, the absence of explicit routing is not severely harmful, but it is still left to inference.

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

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

With no annotations, the description must carry the behavioral burden. It conveys that the operation is asynchronous and returns progress, which is useful, but it does not disclose whether the call is safe/read-only, what happens for unknown job UUIDs, or whether progress data expires. These gaps are significant for a tool with no structured safety hints.

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

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

The description is a single short sentence with no filler, and the key point is front-loaded. The typo 'admit' makes the phrasing awkward but does not undermine conciseness.

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

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

There is no output schema and no annotations, so the description should explain what 'progress' means in practical terms, such as response fields or statuses. The description only names the concept without specifying how progress is represented or how to handle errors, leaving agents under-informed for reliable invocation.

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

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

Schema coverage is 100%, and the schema already describes job_uuid as 'Bulk-send job UUID'. The description only restates the parameter name without adding format, origin, or examples. The baseline of 3 applies because the schema fully documents the parameter.

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 that the tool retrieves the progress of an async bulk-send job by job_uuid, which is a specific verb+resource combination. It is distinguishable from sibling tools like bulk_send_sms and get_message. The odd word 'admit' introduces slight ambiguity, preventing a perfect score.

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. It is implicitly a follow-up polling call after bulk_send_sms, but the description never states that relationship or provides exclusions. The usage context 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?

No annotations are provided, so the description must carry the burden. It says 'Read' which implies a read-only operation, but it doesn't disclose pagination behavior (though parameters include cursor and limit) or any other side effects. The description adds minimal behavioral context beyond the schema, but 'Read' is at least a clear verb.

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

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

The description is a single, concise sentence that is front-loaded with the primary action and key identifiers. No wasted words; it is efficient and to the point.

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

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

Given the tool's simplicity (read a conversation) and full param coverage, the description is adequate. However, without an output schema or behavioral notes (e.g., what constitutes a conversation), an agent might wonder about the response format. Since no output schema exists, the description could have been more explicit about return values, but it's not a major gap for a simple read.

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 documents all parameters. The description doesn't add additional meaning beyond what's in the schema; it only mentions 'DID' and 'counterparty' as identifiers. Given full coverage, a baseline of 3 is appropriate, but it could have enhanced by noting that these form a composite key.

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 reads a single conversation thread identified by a DID and counterparty, distinguishing it from list_conversations which lists multiple conversations. However, it doesn't explicitly name the sibling for contrast, but the verb and resource are specific.

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 a specific conversation is needed, but it does not explicitly state when to use list_conversations instead. Since siblings include list_conversations, the lack of explicit routing is a minor gap, but the context is clear enough for an agent to infer.

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 says 'Get details' implying a read operation, but doesn't disclose what details are returned, whether the DID must be owned by the account, or any error behavior (e.g., not found). For a read tool this is a moderate gap.

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

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

One short sentence, front-loaded with the verb and resource. No wasted words.

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

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

For a single-parameter read tool with no output schema, the description is minimally adequate. However, it doesn't clarify what 'details' includes or how it differs from list_dids, which an agent might need to choose correctly among 40+ siblings.

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

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

Schema description coverage is 100% and the only parameter 'did_number' is described as 'DID number'. The description adds no extra meaning beyond the schema, but the schema is sufficient for a single simple parameter. Baseline 3 applies.

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

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

The description states a specific verb ('Get') and resource ('details for one DID / phone number'), which clearly identifies the operation. It distinguishes from siblings like list_dids (which lists all DIDs) and update_did/delete_did (which modify), though it doesn't explicitly name them.

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: use this when you need details for a single DID, versus list_dids for all DIDs. However, it doesn't explicitly state when to prefer this over list_dids or list_sms_dids, nor does it mention any exclusions or prerequisites.

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 does not state whether the operation is read-only, any side effects, or what the response contains beyond 'detail.' No error or edge-case behavior is mentioned.

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

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

The description is a single, efficient sentence that gets straight to the point with no wasted words. It is appropriately concise for a simple get operation.

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

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

For a simple one-parameter get with no annotations or output schema, the description is minimal but does state the resource and key. However, it lacks any mention of response structure, error handling, or prerequisites, so it 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?

Schema coverage is 100% so the schema documents the uuid parameter. The description adds no additional semantic information beyond the schema's own description, so the baseline 3 applies.

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

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

The description clearly states the action (get) and resource (SMS message detail) and identifies the lookup key (UUID). It distinguishes from list_messages by implying a single message retrieval, though it does not explicitly name alternatives.

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 list_messages or get_conversation. The description does not mention any context or exclusions, leaving the agent to infer usage.

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. 'Live' and 'snapshot' imply a real-time, read-only point-in-time view, but the description says nothing about freshness guarantees, rate limits, latency, or whether the call is safe/side-effect free.

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

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

A single sentence with no filler; the core subject ('live SMS operational snapshot') is front-loaded, and the billing exclusion is a purposeful clarification. Every word contributes.

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

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

For a zero-parameter read tool, the description conveys the basic purpose and distinguishes it from billing, and no output schema exists to fill in return details. However, it does not describe the actual returned fields/metrics or contrast with the two other get_sms_stats_* siblings, leaving some ambiguity.

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

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

The tool has zero parameters and an empty schema, so there are no parameter semantics for the description to add. The 'queues / in-flight' wording adds useful context about what data the no-parameter call returns.

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 identifies the resource as a live SMS operational snapshot covering queues and in-flight messages, and explicitly excludes billing reports. It is clear, but it does not name sibling stats tools (get_sms_stats_summary, get_sms_stats_timeseries) or spell out how they differ beyond 'live snapshot.'

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

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

It gives one useful exclusion ('not a billing report') and implies use when operational queue/in-flight status is needed. It does not provide explicit when-to-use versus the other get_sms_stats_* siblings or mention any preconditions.

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

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

No annotations are present, so the description carries the full behavioral burden. It states the tool returns a summary, but it does not disclose what metrics are included, the default window when from/to are omitted, or the response shape.

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

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

The description is short and front-loaded with the core purpose. The 'Optional from/to (RFC 3339)' clause is somewhat redundant with the schema, but it does not add meaningful bloat.

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

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

There is no output schema and no annotations, so the description must explain what the agent will get and how to call it correctly. It fails to describe the default reporting window behavior, the contents of the summary, or how this differs from the sibling stats endpoints.

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 from/to already documented as inclusive/exclusive RFC 3339 values. The description only repeats 'Optional from/to (RFC 3339)' 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 identifies a concrete resource ('Account SMS usage summary') and scopes it to a 'reporting window', which helps distinguish it from sibling stats tools. However, it lacks an explicit verb and relies on the tool name for the 'get' action.

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

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

No guidance is given about when to use this tool versus siblings like get_sms_stats_live or get_sms_stats_timeseries. The reporting-window phrasing only implies a use case; there is no explicit when-to-use or when-not-to-use.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose what the response contains, whether the operation is read-only (though implied by 'usage stats'), or how buckets aggregate data. The schema's inclusive/exclusive details are already in the schema, so the description adds no behavioral context beyond it.

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

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

A single, front-loaded sentence with no filler. It efficiently states the resource and the optional parameters. 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 the lack of an output schema and the presence of closely related sibling tools (get_sms_stats_live, get_sms_stats_summary), the description is incomplete. It neither explains the response format nor distinguishes the use case from siblings. The agent must infer when a timeseries is more appropriate than live or summary, which is a significant gap for a stats tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description merely repeats the bucket enum values (hour|day|month) already in the schema, without adding new meaning about valid ranges, defaults, or interactions. It confirms the optional nature but adds little 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?

States a specific verb and resource: 'SMS usage timeseries buckets.' This is clear and not a tautology. However, it does not explicitly differentiate from sibling tools get_sms_stats_live and get_sms_stats_summary, though the name 'timeseries' hints at the distinction.

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

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

No guidance on when to use this tool versus get_sms_stats_live or get_sms_stats_summary. The description only covers parameters, not the selection context. An agent would have to infer from the name alone, lacking explicit when-to-use or when-not-to-use 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It conveys a read-only listing operation through the word 'List', but omits expected return shape, pagination or result limits, pricing/availability details, and authentication requirements.

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

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

Two concise sentences state the purpose first and then enumerate the filters. There is no filler or duplication; every word contributes operational value.

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

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

For a low-complexity list endpoint with all parameters documented and no required arguments, the description provides enough to invoke it correctly, including default country and available filters. It does not describe the output payload, but the simple 'list' semantics and full schema coverage make the call largely self-contained.

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 four parameters. The description adds the helpful framing that these are filters and mentions the AU default, but it does not clarify ambiguous values like number_type, keeping it at the schema-covered baseline.

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

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

The description clearly states a specific action ('List') and resource ('available DIDs for purchase'), and it lists the filters that narrow the search. It does not explicitly distinguish this from siblings like list_dids, though 'available for purchase' strongly implies 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 purpose phrase implicitly signals use when searching for purchasable numbers, and the filters give operational context. However, there is no explicit guidance about when to choose this tool over alternatives such as list_dids or purchase_did, so usage must be inferred.

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 for behavioral disclosure. It does indicate the operation is a read/list operation (not destructive), and that it is scoped by a state/region, which is useful. However, it does not mention that the result may be filtered by number availability, whether it returns a simple array or paginated results, or any prerequisites. The behavior is minimally transparent but not rich.

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

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

The description is a single sentence with no fluff, and it front-loads the purpose ('List cities with available numbers') and the scope ('for a state / region'). It 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?

Given the tool is a straightforward list operation with only one required parameter, the description is fairly complete. However, with no annotations, no output schema, and an ambiguous relationship to sibling tools like 'list_available_numbers', it could provide more context about what the response contains or when to choose this over more specific listing tools. Overall, it is adequate but not fully complete.

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

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

The schema covers all parameters (100% coverage) with a clear description for 'state' (State or region code with examples). The tool description itself does not add further parameter semantics, but since the schema is complete, a baseline 3 is appropriate. The description's phrase 'for a state / region' does reinforce the parameter's meaning, but no additional format details are given.

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 ('cities with available numbers') and adds context about the scope ('for a state / region'). It is likely distinct from the broadly similar 'list_available_numbers' and 'list_destinations', though it does not explicitly name those siblings, so it earns a 4 rather than a 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 implies the primary use case (finding cities where numbers can be purchased) by mentioning 'available numbers', but it does not explicitly explain when to use this versus 'list_available_numbers', 'list_destinations', or other sibling tools. The usage guidance is implied from the context rather than directly stated, so a 3 is appropriate.

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 disclose behavioral traits on its own. It clearly indicates a read-only listing operation and adds useful context that the lists are reusable SMS bulk/schedule audiences. It does not disclose pagination behavior, default filters, response format, or whether inactive lists appear by default, but for a simple list operation the core behavior is sufficiently transparent.

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

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

The description is a single, well-structured sentence with no filler or redundant information. The action and differentiating context are front-loaded, making it easy for an agent to scan and understand quickly.

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

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

For a read-only list tool with no required parameters and fully documented optional parameters, the description provides enough context to select and invoke the tool correctly. Minor gaps include the lack of explicit sibling alternatives and no statement about return format, but these are not critical given the minimalist nature of the operation and the complete schema coverage.

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

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

The input schema has 100% description coverage for all four optional parameters, so the baseline is 3. The tool description adds no additional parameter-level meaning beyond the 'bulk/schedule audiences' context, leaving limit, offset, search, and active_only semantics entirely to the schema.

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

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

The description uses the specific verb 'List' and clearly identifies the resource as 'reusable SMS contact lists,' further scoping them as 'bulk/schedule audiences.' This distinguishes the tool from sibling list tools such as list_contacts or list_opt_out_lists by emphasizing the reusable, bulk/schedule nature of these 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 parenthetical '(bulk/schedule audiences)' implies this tool is for retrieving saved SMS audience lists used in bulk or scheduled sends, which gives some usage context. However, it does not explicitly state when to prefer alternative sibling tools, such as list_contacts for individual contacts or list_opt_out_lists for opt-out lists, so the agent must infer the boundary.

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 states it 'lists' contacts, implying a read-only operation, but does not explicitly mention any side effects, default ordering, pagination behavior beyond what the parameters suggest, or response format. The description adds minimal behavioral context beyond what is obvious from the name and parameters.

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

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

The description is a single, focused sentence that front-loads the primary purpose ('List SMS Center address-book contacts') followed by a concise mention of optional parameters. There is zero waste, and it is appropriately structured for quick agent comprehension.

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

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

For a simple list tool with three well-documented parameters and no output schema, the description is largely complete. It explains what the tool does and mentions the optional filters/pagination. It does not explicitly describe the return format, but that is not required given the absence of an output schema and the straightforward nature of a list operation. It could benefit from a note about default behavior or sorting, but nothing critical is missing.

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

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

Schema description coverage is 100% – each parameter (limit, offset, search) already has a description in the schema. The description merely repeats 'Optional search, limit, offset' without adding new meaning or clarifying syntax, defaults, or interactions. Since the schema does the heavy lifting, the description adds little value beyond the baseline.

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

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

The description clearly states the verb 'List' and the resource 'SMS Center address-book contacts', making the purpose unambiguous. It also mentions the optional parameters (search, limit, offset), and the resource 'contacts' distinguishes it from sibling tools like list_contact_lists or list_messages.

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

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

The description implies when to use it (when you need to list contacts) but does not explicitly mention when not to use it or point to alternatives. There is no exclusion or comparison to siblings, but the resource is clear enough that an agent would understand the basic context. It lacks explicit guidance on choosing this over related list tools, but it is not misleading.

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?

Annotations are not provided, so the description carries the burden for behavioral context. It discloses that the tool lists threads and lists optional filtering and pagination parameters, but it doesn't mention any side effects (e.g., no mutation) or output format. The description is neutral and does not contradict anything, but lacks depth.

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

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

The description is a single, short sentence that states the main purpose and lists optional parameters. It is front-loaded with the core action and resource. It could be slightly improved by separating the parameter list into a second sentence, but overall it is efficient and to the point.

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

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

The tool is moderate in complexity with 4 parameters and no output schema. The description does not explain return value details (e.g., the structure of conversations) or pagination semantics beyond naming the cursor parameter. Given the low complexity and that the schema covers parameters, the description is adequate but has gaps in behavioral context and 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 description coverage is 100%, so each parameter (did, limit, cursor, unread_only) is described. The description merely names the optional parameters without adding detail that the schema doesn't already provide. Thus, the description adds no significant semantic value beyond the schema.

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

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

The description clearly states the verb ('List'), the resource ('conversation threads'), and the scope ('for an SMS DID'). It distinguishes from sibling tools like list_messages (which likely lists individual messages) and list_sms_dids (which lists DIDs), but doesn't explicitly name alternatives.

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

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

The phrase 'for an SMS DID' and the optional parameters hint at when to use it, but there is no guidance on when not to use it or what distinguishes it from similar list tools. It implies context but does not explicitly discuss alternatives or exclusions.

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

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

No annotations are present, so the description carries the full burden. It implies a read-only listing operation but does not explicitly state that it has no side effects or describe the return format. For a simple list tool, the implication may suffice, but explicit behavioral disclosure is lacking.

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

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

A single sentence that is direct and front-loaded. No filler or redundant phrasing.

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

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

The tool is simple with no parameters, but there is no output schema. The description does not explain what a 'routing destination' is or what fields are returned in the list. An agent may need more context to interpret the response, so completeness is moderate.

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

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

The tool has zero parameters, and the schema is empty with 100% coverage. Per the rubric, baseline is 4, and the description need not add parameter 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?

States a specific verb (list), resource (routing destinations), and context (when configuring a DID). It is clearly distinct from sibling tools like list_dids because it targets destinations, not DIDs themselves.

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

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

Provides the context of when this tool is relevant ('when configuring a DID') but does not explicitly mention alternatives or exclusion criteria. The agent must infer that this is the tool for routing destination options, though there are no competing destination 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 behavioral burden. It communicates a read-only list operation and an eligibility qualifier, but it does not mention pagination, ordering, response shape, or whether any hidden filtering applies.

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

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

The description is a single front-loaded sentence with no filler words. Every phrase contributes to the meaning, and it is appropriately sized for a tool with no inputs.

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

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

For a zero-parameter list endpoint, the description is largely sufficient: it names the resource and the use case. However, since there is no output schema, it leaves the exact meaning of 'address' and any pagination behavior unstated, so a small amount of additional detail would make it fully complete.

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

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

The input schema has zero parameters, so there is no parameter documentation burden. The description still adds useful context by clarifying that the returned addresses are those usable for a DID purchase, which is the baseline expected for a no-parameter tool.

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

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

The description uses a specific verb ('List') and a specific resource ('addresses usable when purchasing a DID'), making the tool's scope clear. It is distinguishable from sibling tools like list_dids and purchase_did, though it does not explicitly name alternative tools.

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

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

The phrase 'when purchasing a DID' gives an agent a clear decision context for when to call this tool. It does not state exclusions or direct the agent to alternatives, but the intended use case is obvious enough for a simple list endpoint.

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 the full burden. The verb 'List' implies a read-only operation, which is helpful, but there is no disclosure of behavior like pagination, sorting, response format, or authentication requirements. It adds minimal behavioral context beyond the action itself.

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

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

The description is a single concise sentence that front-loads the core purpose and immediately lists filters. No wasted words; it is efficient and easy to parse.

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

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

For a simple list tool with all optional parameters and no output schema, the description is adequate but not fully complete. It could clarify the distinction from list_available_numbers (owned vs. available) and mention response behavior (e.g., pagination), but for a straightforward read operation, it covers the essentials.

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 each parameter. The description merely lists the same parameter names ('did_number, country, state, city, number_type') without adding additional meaning, context, or examples, keeping it at the baseline.

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

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

The description clearly states the action ('List') and the resource ('account phone numbers / DIDs'), making the purpose unambiguous. It distinguishes itself from siblings like get_did (specific DID), update_did, and list_available_numbers (available for purchase) by explicitly scoping to account-owned numbers.

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 list_available_numbers or get_did. The word 'account' implies owned numbers, but there is no direct statement of exclusions or suggested alternatives, leaving the agent to infer 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?

There are no annotations, so the description carries the full disclosure burden. Aside from implying a read-only listing, it does not disclose pagination behavior, default ordering, response shape, or any constraints beyond the parameter names already visible in 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?

One short sentence with the core action front-loaded. It is efficient and readable, though the trailing parameter list adds only modest value over the schema.

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

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

With no output schema and no annotations, the description should mention what a successful response contains and any pagination behavior. It does not. For a tool with seven parameters and ambiguous filters, this is 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 coverage is 100% for all seven parameters, so the schema does the heavy lifting. The description merely repeats the optional filter names and adds no clarification for ambiguous fields such as from/to being either time or sender/recipient.

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 resource ('SMS messages') scoped to a DID. This clearly separates it from siblings such as get_message, list_sms_dids, and list_conversations.

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

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

It implies use when a caller needs SMS messages for a DID, but it does not explicitly name alternatives or state when not to use it. With siblings like get_message and list_conversations nearby, explicit routing would improve the guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states 'List entries'—implying a read operation without detailing side effects, return format, pagination behavior, or ordering. It does not mention that the operation is read-only or what the response structure contains, which is a significant gap for an agent invoking the tool.

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

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

The description is a single concise sentence that front-loads the core action and lists the optional parameters. It avoids verbosity, but the terseness sacrifices critical contextual information. Still, it is appropriately sized for the information it conveys, so a score of 4 is reasonable for conciseness.

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

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

Given the tool has 5 parameters, 1 required, and no output schema, the description is incomplete. It does not explain what the response will contain (e.g., list of entries with fields), how pagination works beyond limit/offset, or how the status and phone filters interact. An agent lacks enough context to fully understand the tool's behavior and expected output, making completeness insufficient.

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 each parameter has a basic description (e.g., 'Page size', 'Phone search'). The tool description adds only 'Optional status, phone, limit, offset', which repeats the optionality already implied by the schema. Since the schema does the heavy lifting, the description provides minimal additional semantic value, aligning with the baseline of 3.

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

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

The description clearly states the verb 'List' and the resource 'entries on an opt-out list', which distinguishes it from sibling tools like list_opt_out_lists (which lists the lists themselves) and check_opt_out (which likely checks a single entry). However, it does not explicitly differentiate from other list tools, so it misses full sibling differentiation.

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. There is no mention of scenarios such as 'use this to retrieve all entries for a given list' or when to prefer check_opt_out or create_opt_out_entry. The description only states the action and optional parameters, leaving the agent to infer usage context.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It only says 'List', which implies a read operation, but it does not mention pagination, ordering, or any side effects. For a zero-parameter list tool, this is minimal disclosure and does not go beyond what the name already suggests.

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

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

The description is a single, efficient sentence with no redundancy. It states exactly what the tool does in as few words as possible, which is ideal for conciseness and front-loading.

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, parameterless list operation with no output schema, the description is functionally sufficient but sparse. It does not describe the return format, any default behavior, or potential limitations. While an agent can call it without parameters, the lack of any return description or usage hints makes it only minimally 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?

There are no parameters, so the schema covers everything (100% coverage). The baseline for zero-parameter tools is 4, and the description adds nothing that conflicts or needs elaboration. It is a trivial case where no parameter semantics are required.

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

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

The description clearly states the verb 'List' and the resource 'SMS opt-out / suppression lists', distinguishing it from sibling list_opt_out_entries which lists individual entries rather than the lists themselves. This is specific and 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 no guidance on when to use this tool versus alternatives like create_opt_out_list or list_opt_out_entries. No exclusions, prerequisites, or contextual triggers are mentioned, leaving the agent to infer usage solely from the 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?

No annotations are provided, so the description carries the full burden. It implies a read-only operation ('List') and adds context about the records' purpose, but it does not explicitly state read-only behavior, possible side effects, or return format. For a simple 0-param list tool, this is adequate but not fully transparent.

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

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

A single sentence with no unnecessary words. The action and object are front-loaded, making the description 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?

Given the low complexity (0 params, no output schema), the description is complete enough. It explains what the tool returns (person/owner records) and the use case, so an agent can invoke it correctly without additional information.

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

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

The tool has 0 parameters and the schema is empty (schema coverage 100%). Because there are no parameters to document, the baseline for 0 params is 4, and the description does not need to add parameter details.

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

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

The description states a specific verb ('List') and resource ('person/owner records') with a clear context ('usable when purchasing a DID'). This distinguishes it from sibling tools like list_dids and list_contacts, so an agent can identify it correctly without opening the schema.

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

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

The description gives clear context for when to use the tool ('when purchasing a DID'), but it does not explicitly mention alternatives or when not to use it. This meets the 'clear context, no exclusions' criterion for a 4.

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 communicates a read-only listing operation and optional filtering, which is useful, but it omits details such as return format, pagination, filter matching behavior, and authentication scope.

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

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

Two short sentences with no filler. The main action is front-loaded, and the optional filters are stated compactly and clearly.

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

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

This is a simple list tool with fully documented parameters, so the missing output schema is not a major issue. However, with no annotations, the description is thin on behavioral context such as what is returned when no filters are supplied, result limits, or how to use it relative to other list tools.

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

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

Schema coverage is 100%, and each parameter already has a clear description ('Filter by trunk UUID', 'Filter by SIP username'). The description only restates the parameter names and optionality already encoded in the schema, adding no new semantic detail.

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

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

The description uses a specific verb ('List') and a specific resource ('SIP trunks'), and names the available filters. This clearly distinguishes it from the sibling create/update/delete_sip_trunk tools and from other list tools targeting different resources.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The verb 'List' implies retrieval, but the description does not state when this listing tool is preferred, how filters should be combined, or what happens when no filters 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?

There are no annotations, so the description must carry the behavioral burden. It only notes that data comes from 'SMS Center stats', but it does not disclose whether the operation is read-only, whether results are paginated, what fields are returned, or how the overview is structured.

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 verb-first structure and no filler. The phrase 'DID overview from SMS Center stats' is slightly awkward, but it remains efficient and front-loaded.

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

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

Given no output schema and no annotations, the description needs to explain what the returned overview includes)Skip this. It does not mention pagination, output fields, or how this differs from list_dids in concrete terms, leaving the agent without enough context for a complete call.

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

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

The tool takes zero parameters and the schema documents this completely, so the description has no parameter meanings to add. The baseline of 4 for a no-parameter tool applies.

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

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

The description uses a specific verb ('List') and resource ('SMS-capable DID overview'), and the qualifier 'SMS-capable' helps distinguish it from the sibling list_dids tool. It is clear enough for an agent to know what the tool returns, though 'overview' is somewhat imprecise.

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

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

No guidance is given on when to use this tool versus alternatives. The closest sibling, list_dids, is never mentioned, and the description only implies that this variant is for SMS-capable DIDs, leaving the decision to inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention response format, pagination, ordering, what 'verified' entails, or any limits. For a listing operation with no output schema and no annotations, this is a notable gap in what the agent can expect back.

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

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

A single, front-loaded sentence with zero filler words. It is appropriately sized for a parameterless tool, though it is arguably slightly under-specified given the absence of any behavioral or return-value context.

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

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

Given the tool's low complexity (no params, no annotations), the description is mostly adequate: it names the resource and scope. However, with no output schema, the return format is entirely unspecified, and the meaning of 'verified' is not explained, leaving moderate gaps for a tool an agent would call blind.

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

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

The tool has zero parameters, so there is nothing for the description to clarify. Per the baseline rule for 0-param tools, a 4 is appropriate; the empty schema already confirms no arguments are needed.

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 specific resource ('verified caller IDs'), clarifies the acronym (CLI), and scopes it to 'the account.' No sibling tool lists caller IDs, so it is cleanly distinguished from the other list/create/update/delete tools in the set. The parenthetical clarification adds precision.

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

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

No explicit when-to-use or when-not-to-use guidance, and no alternative tools are named. However, as a parameterless read-only listing operation, its intended usage is strongly implied by the name and description. It falls into the 'implied usage' category rather than providing explicit exclusions or comparisons.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It says 'purchase' but does not explain important traits such as whether the purchase is irreversible, whether it incurs billing, whether availability is re-checked, or what happens on success or failure. For a financial mutating operation, this is a significant gap.

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

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

The description is one short sentence with a clear action verb and a list of required parameters. It is efficiently structured and easy to parse, though the parameter list duplicates schema information.

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

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

With no annotations, no output schema, and multiple interdependent parameters, this description is too thin. It does not state what the response will be, what a successful purchase returns, how to handle conflicts, or how this fits into the broader DID workflow.

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. The description only repeats the required parameter names without adding meaning beyond the schema. This meets the baseline but adds no extra value.

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

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

States a specific verb and resource: 'Purchase an available DID.' This clearly identifies the operation and differentiates it from list/get/update/delete sibling tools by implying an acquisition action. However, it does not explicitly name a sibling, so it stops short of full differentiation.

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

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

No guidance is given about when to use this tool versus alternatives like list_available_numbers, get_did, update_did, or delete_did. It does not mention prerequisites such as first listing available numbers or owners/addresses, nor does it state when not to use it.

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

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

With no annotations, the description must carry the behavioral burden. It discloses the required parameters and the 500-recipient cap, but does not mention the return value, whether scheduling is asynchronous, idempotency behavior, or error handling. For a mutation tool, this is a moderate gap but not misleading.

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

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

Two sentences with no fluff. The first sentence states the purpose and endpoint, and the second states the requirements and limit. Information is front-loaded and every word earns its place.

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

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

The description covers the essential calling contract but omits the response format (e.g., scheduled message ID) and any post-scheduling behavior. Given the tool has no output schema, mentioning the return value would be valuable. It also does not clarify whether the call is synchronous or asynchronous, which is relevant for scheduling.

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 all 7 parameters, but the description adds critical semantics: the either/or requirement for to and list_uuid, and the recipient cap. These are not fully captured by the schema's structure, which lists them as separate optional properties. The description meaningfully clarifies invocation constraints.

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

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

The description clearly states the verb 'Schedule' and the resource 'SMS', and explicitly mentions single or bulk modes. The API endpoint reinforces the action. While it does not name sibling tools, the term 'schedule' and the requirement for a future send_at time distinguish it from immediate-send tools like send_sms.

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 scheduling future messages, but it does not explicitly state when to use it versus immediate-send siblings like send_sms or bulk_send_sms. There is no explicit exclusion or alternative guidance, leaving the agent to infer the context from the send_at parameter.

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 states the action and endpoint but omits critical behavioral aspects: authentication requirements, costs, delivery guarantees, failure handling, or reversibility. For a mutation tool that sends a message, this is a significant gap.

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

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

Two sentences with zero waste. The essential action is front-loaded, and the required/optional parameters are listed compactly. This is appropriately sized for the tool's simplicity.

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

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

For a simple send action, the description covers the core invocation details. However, with no output schema and no annotations, it lacks information on expected responses, error conditions, or side effects like billing. This is acceptable for a straightforward operation but not fully comprehensive for a mutation tool.

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

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

Schema description coverage is 100%, so all parameters are already documented with descriptions. The description merely restates which parameters are required and optional, adding no extra semantic insight (e.g., constraints on 'text' length or sender format). Baseline 3 applies because the schema handles parameter documentation.

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 ('Send one SMS immediately') and identifies the exact resource (POST /api/v2/sms/send). It distinguishes itself from siblings like bulk_send_sms and schedule_sms by specifying 'one' and 'immediately', 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 word 'immediately' implies use for instant sends, distinguishing it from scheduled or bulk operations. However, it does not explicitly mention when not to use it or point to alternatives (e.g., 'use bulk_send_sms for multiple messages'), leaving some inference to the agent.

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

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

With no annotations, the description must carry the behavioral transparency burden, but it only reveals that the operation is a 'replace'. It does not disclose whether omitted fields are cleared, whether the operation is irreversible, what permissions are needed, or what the response contains. This is minimal for a mutation tool.

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

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

The description is a single, front-loaded sentence with no filler. It conveys the core operation and key attribute immediately, making it easy to scan.

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

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

For a mutation tool with no annotations and no output schema, the description is too sparse. It does not clarify replacement semantics for missing optional fields, error behavior, or any call prerequisites, so an agent may not be able to invoke it correctly without additional assumptions.

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 five parameters and their types. The description adds only the emphasis that the contact is located by contact_id, which is already in the schema. Baseline 3 is appropriate because the schema does the heavy lifting.

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 ('Update (replace)'), a resource ('SMS Center contact'), and the key identifier ('by contact_id'). This clearly distinguishes it from sibling tools like create_contact, delete_contact, and update_contact_list without requiring schema inspection.

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

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

The phrase 'Update (replace) an SMS Center contact' implies the tool is for modifying an existing contact, but there is no explicit statement about when to use it versus alternatives like create_contact or delete_contact. No when-not-to-use or prerequisite guidance is provided.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It does disclose the mutation scope and the important boundary that members are unaffected. However, it does not mention permissions, side effects, reversibility, or what the response contains, leaving notable gaps for a write operation.

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

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

The description is a single front-loaded sentence: it names the verb and resource, lists the affected fields, and ends with a clarifying exclusion. There is no wasted wording, and the most important scoping information is presented immediately.

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 four-parameter metadata update with full schema descriptions and no output schema, the description covers the core behavior and an important boundary. It is slightly incomplete only in that it does not explain preconditions or side effects, but the schema and boundary note are sufficient for correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds semantic value by grouping name, description, and active as 'metadata' and explicitly clarifying that member data is out of scope, which helps the agent interpret the parameters beyond their raw schema labels.

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 ('Update') and resource ('SMS contact list') and scopes the work to metadata fields: name, description, active. It also explicitly states 'Does not change members,' which clearly distinguishes this tool from membership-changing tools like add_contacts_to_list.

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

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

The description clearly frames the tool as the metadata-update operation and includes an explicit when-not: 'Does not change members.' It does not name the alternative sibling tool for member changes, so it stops just short of fully explicit routing guidance.

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

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

No annotations are present, so the description carries the full burden for behavioral disclosure. It states that the tool updates configuration, implying a mutation, but does not disclose whether the update is partial or full replacement, which existing fields are overwritten, whether there are side effects, or if any permissions are required. This is a significant gap for a state-changing tool with 10 parameters.

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

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

The description is a single, front-loaded sentence that conveys the core purpose efficiently. The parenthetical list of fields is helpful without unnecessary verbosity, though the trailing 'etc.' is slightly vague.

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

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

With 10 parameters, no annotations, and no output schema, the description is too minimal to complete the picture. It does not explain update semantics (e.g., whether omitted fields are left unchanged, whether the update is atomic), nor does it warn about potential invalid value combinations. An agent would need to consult additional documentation or make assumptions.

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 all parameters are already documented with descriptions. The tool description mentions 'description, primary/backup route and destination' which maps to several parameters, but adds no extra semantics beyond the schema. The baseline of 3 applies.

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

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

The description clearly states the verb 'Update' and the resource 'DID configuration', and lists specific fields (description, primary/backup route and destination). This makes the tool's purpose clear and distinct from siblings like get_did, delete_did, and purchase_did, though it does not explicitly name or contrast with those alternatives.

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

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

No guidance is provided about when to use this tool versus siblings. The description does not state prerequisites, such as the DID needing to exist, nor does it mention when to use get_did or delete_did instead. An agent is left to infer from the schema.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Update,' which implies mutation but omits critical details: whether this is a full or partial update, whether unsupplied fields are reset, permission requirements, existence checks, or side effects. For a mutation tool with zero annotation coverage, this is a significant transparency gap.

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

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

The description is a single sentence, front-loaded with the action ('Update') and the resource ('SIP trunk'). It is concise and free of fluff. However, it is so sparse that it sacrifices useful context, though that is penalized more in other dimensions.

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

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

For a mutation tool with 10 parameters, no annotations, and no output schema, the description is incomplete. It does not clarify update semantics (partial vs. full), required fields beyond trunk_id, error handling, or any special behaviors for fields like password or enabled. An agent needs more context to call this tool correctly.

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

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

Schema description coverage is 100% (all 10 parameters have descriptions), so the baseline is 3. The description itself adds minimal semantic value beyond the schema: it only reinforces that trunk_id is the lookup key, which the schema already states as 'SIP trunk UUID.' It does not explain update behavior for the optional fields, such as whether they are partial updates.

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: 'Update a SIP trunk by trunk_id.' This clearly identifies the operation and the target resource. However, it does not explicitly contrast with sibling tools like create_sip_trunk or delete_sip_trunk, leaving some differentiation to inference from the name and schema.

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

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

The description offers no guidance on when to use this tool versus alternatives. It does not mention prerequisites, the relationship to create_sip_trunk/list_sip_trunks/delete_sip_trunk, or any conditions under which an update is appropriate. An agent is left without routing information.

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