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

Annotations already declare a non-read-only, non-destructive, non-idempotent, open-world mutation, so the safety profile is covered. The description adds nothing beyond restating the action and the HTTP endpoint: it doesn't say what activation actually changes on the number, whether it is reversible, whether it consumes licensing/billing, or what state the number must be in beforehand — meaningful gaps for a state-changing operation.

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

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

Two short clauses, front-loaded with the action, with zero wasted words. However, the brevity crosses into under-specification: the parenthetical endpoint is the only extra content and contributes little to an agent deciding how to call it.

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 mutating, non-idempotent tool with no output schema, the description should explain effects, preconditions, and expected result. Instead it offers only the verb and the REST path, leaving the agent able to identify the action but not to predict its consequences or confirm success.

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

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

Schema description coverage is 100% — both the `id` path parameter and the `response_format` enum are documented in the schema — so the baseline of 3 applies. The description contributes no additional meaning about what `id` refers to (number ID vs. phone number) or any format hint.

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 gives a specific verb+resource ("Activate a number") that an agent can map directly to the tool name and, via the endpoint path, to the numbers/{id} sub-resource. It does not, however, distinguish this from the sibling placetel_deactivate_number or placetel_activate_number_profile, so the agent must infer which of the three activation-style tools applies.

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 versus placetel_deactivate_number or placetel_activate_number_profile, and no prerequisites or preconditions (e.g., whether the number must be provisioned or unassigned) are stated. The agent gets a purpose but no routing logic.

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 already disclose that this is a non-read-only, idempotent, non-destructive operation with open-world effects. The description adds only the HTTP verb and path, not what activation changes, whether it switches out another active profile, permission requirements, 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 two short sentences with the purpose front-loaded and no wasted prose. It is appropriately sized for a simple endpoint, though the endpoint parenthetical is the only extra detail.

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 mutation with annotations and complete schema coverage, the description covers the basic purpose. However, it leaves key semantic gaps: what activation does and what the required body `id` refers to, which matters for correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds the endpoint path showing number_id as a path parameter, but does not clarify that the required body field `id` is the profile identifier or explain its role.

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: activating a number profile, with the endpoint path. It is clear enough to understand the operation, but it does not explicitly differentiate this tool from nearby siblings such as placetel_activate_number, placetel_deactivate_number, or placetel_create_number_profile.

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 only restates the tool's purpose and gives no guidance on when to use it versus alternatives or prerequisites. There is no mention of when not to use it, whether a profile must already exist, or how it relates to activate_number/deactivate_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?

Annotations already declare readOnlyHint=false, idempotentHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered structurally. The description adds nothing beyond that — no note on what registering a subscription triggers externally (openWorld), whether duplicates are replaced (idempotency semantics), or any auth/scope 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 clauses, front-loaded and waste-free, which is structurally fine. The problem is under-specification rather than verbosity, so it doesn't lose points for length but gains nothing from the brevity either.

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 9-parameter mutation tool with no output schema and opaque field names, the definition is far too thin: it explains neither what gets created, nor the side effects, nor what is returned. The structured annotations partially cover the safety profile, which keeps this above the minimum.

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?

Nominal schema coverage is 100%, but every field description is filler ("Body field url (required)", "Body field hungup"), leaving domain-critical parameters like service, numbers, incoming/outgoing, and accepted unexplained. The description does nothing to compensate, so the baseline-3 allowance for high coverage is not earned here.

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?

"Add a subscription" restates the tool name and title verbatim, so the only added information is the HTTP endpoint "(PUT /subscriptions)". It never says what a subscription is in this API (webhook/event subscription?) or what adding one accomplishes, and it doesn't differentiate from placetel_list_subscriptions or placetel_delete_subscription.

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 when-to-use guidance, no prerequisites, and no mention of the sibling list/delete subscription tools. The agent must infer applicability entirely from the name and the PUT endpoint hint.

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 already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, but the description adds almost no behavioral context beyond the endpoint path. For a mutation tool, it does not clarify whether assigning a package replaces an existing license, what permissions are required, or what side effects occur.

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 short and front-loaded, with no filler. However, its brevity borders on under-specification for a mutation tool with six 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?

The tool mutates a user's Webex license and has no output schema, yet the description omits permissions, replacement semantics, and expected response behavior. Given the mutation context and optional parameters like extension, location_id, and phone_number, more context is needed.

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 documents all six parameters including the package enum. The description adds no meaning beyond the operation itself and the endpoint path, which is acceptable when the schema is fully documented.

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 ('Assign Webex license to user') and includes the underlying POST endpoint, making the operation identifiable. It does not explicitly distinguish this from sibling tools like placetel_update_webex_user_license or placetel_get_webex_user_license, but the verb 'assign' is clear enough.

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 placetel_update_webex_user_license or placetel_get_webex_user_license. No prerequisites, exclusions, or alternative-selection conditions 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?

Annotations already declare the operation is a non-read-only, idempotent, non-destructive, open-world mutation. The description adds nothing beyond that profile: it does not say whether existing fax settings are replaced by the PUT, what happens to unlisted fields, or what permissions are required. It essentially restates the title.

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, action front-loaded with the endpoint path as secondary detail. Nothing is wasted, though the path adds little decision value for an agent.

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 9 parameters, 3 required, no output schema, and a mutation of telephony settings, the description should explain at minimum what faxpin and faxheader represent and the effect of the call. Those required-but-opaque parameters are left entirely undocumented, so an agent cannot call this reliably without guessing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mentions number_or_id via the endpoint path but adds no meaning for faxpin, faxheader, faxsettings, or faxwhitelist beyond the schema's placeholder 'Body field X' labels, so it does not compensate for the schema's semantic thinness.

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: configuring a number as a fax number, plus the underlying endpoint. It is distinguishable from the read sibling (get_webex_number_fax_settings) and delete sibling, but it never names them, so the differentiation is inferred rather than stated.

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

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

There is no guidance on when to use this versus get_webex_number_fax_settings or remove_webex_number_fax_settings, nor any prerequisites (e.g. number must be a Webex-enabled number). The agent must infer selection purely from the verb.

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 already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false and openWorldHint=true, so the description adds nothing new beyond echoing the POST endpoint. It does not disclose whether an account/queue must exist first, whether duplicates are rejected, or what the call returns for the new agent.

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 fragments with zero padding, and the verb is front-loaded. However, the brevity is under-specification rather than economy — the parenthetical endpoint is the only added 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 non-idempotent write tool with 8 parameters, 4 of them required, and no output schema, the description should at minimum state the resulting object and any prerequisites. It provides neither, leaving the agent to infer everything from an endpoint path.

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 technically 100%, but the per-parameter text is pure boilerplate ('Body field name.', 'Body field extension_sip.'), so no real semantics are conveyed anywhere. The description does not explain the required name/extension_type/extension_sip/extension_pstn relationship, the Superviser/Agent enum intent, or the response_format switch.

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 essentially restates the title ('Create an agent') and appends the raw endpoint path (POST /call_center_agents). The endpoint hints at the Call Center Agents resource family, but the text never says what an 'agent' is here or how it differs from the many other create tools in the sibling list (create_user, create_sip_user, create_contact).

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 when-to-use guidance at all. Nothing distinguishes this from placetel_list_call_center_agents, placetel_update_call_center_agent, or the other user/SIP-user creation tools, and no preconditions are stated.

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 already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false and openWorldHint=true, so the description does not need to restate safety. It adds nothing beyond that, though: no note on whether re-creating the same name errors or duplicates (non-idempotent is only implied by annotations), no side effects on existing routing/agents. The endpoint reference is the only value-add.

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 zero padding and the endpoint front-loaded. Efficiency here comes at the cost of substance rather than through well-chosen compression — it is under-specified rather than crisp.

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?

A non-idempotent create tool with 16 parameters (only 'name' required), no output schema, and many interdependent prompt/ringing settings needs far more than one sentence: which fields are practically required for a working queue, interaction rules, and error behavior are all absent.

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?

Coverage is nominally 100%, but the schema descriptions are pure placeholders ('Body field priority.', 'Body field ringing_time.'), so the schema explains nothing about 15 optional business fields such as num_loops, max_iterations, or prompt_id. The description offers no compensating explanation of defaults, units, or relationships between prompt fields.

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 ('Create a queue') and the underlying endpoint (POST /call_center_queues), which disambiguates that this is the call-center queue resource rather than a generic queue. However, it does no explicit sibling differentiation from placetel_list_call_center_queues or placetel_update_call_center_queue, and the phrase is essentially the tool title restated.

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 versus the list/update queue siblings, no prerequisites or permissions noted, and no mention of what state the account must be in. The agent must infer everything from the tool name.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false and openWorldHint=true, so safety and repeat-behavior are covered. The description adds that all fields are optional and that the created object is returned, but says nothing about duplicate handling, required identifiers (e.g. whether a contact without a name is meaningful), or side effects like address-book sync.

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

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

Three short sentences with the purpose front-loaded and no filler. It is efficient, though the brevity is partly under-specification rather than discipline.

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 22-parameter creation tool with no output schema and near-zero schema descriptions, this definition is far too thin — it clarifies neither the field semantics nor the creation semantics (duplicates, defaults, minimum content).

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?

With 22 parameters at 5% schema description coverage, the description must carry the parameter burden, yet it only says fields are optional. Non-obvious fields such as 'color', 'speeddial', 'blocked', 'tags', and the enum 'response_format' are never explained, so an agent must guess at semantics and formats.

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

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

States a specific verb and resource ('Create a new contact') and names the return ('the created contact object'), which separates it from placetel_update_contact and placetel_get_contact. It does not explicitly route against siblings like update_contact, but the verb makes the intent 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 when-to-use guidance, no prerequisites, no mention of when to prefer placetel_update_contact or placetel_get_contact instead. The only guidance is a field-level note ('any subset of contact fields'), not a 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=true, so the safety profile is covered. The description adds nothing beyond "(POST /faxes)": it does not say whether the fax is dispatched immediately, whether a file must be uploaded/base64-encoded, what account/permission is required, or whether retries could send duplicate faxes (important given idempotentHint=false).

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 fragments with no filler and the purpose front-loaded. Size is appropriate; the parenthetical endpoint is near-zero value for an agent but not enough bloat to penalize further.

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 an outward-facing, non-idempotent mutation with 6 parameters and no output schema, so the description carries real burden. It omits what is returned (fax id/status), any send semantics, file encoding expectations, and error cases — an agent could construct the call but not predict its effects.

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 is nominally the source of truth and the baseline is 3. However, the schema descriptions are pure tautologies ("Body field file (required)") and the tool description offers no compensating detail such as accepted file formats or the meaning of `header`, so it does not improve on structured data.

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 pairs a specific verb and resource ("Create outbound fax") and the tool name/sibling set (list_faxes, get_fax, delete_fax) makes the create role unmistakable. It stops short of naming a sibling or stating scope (e.g. vs. send_sms or initiate_call), so it is clear but not fully differentiated.

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

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

There is no guidance on when to choose this over neighbors like placetel_send_sms, placetel_list_faxes, or placetel_initiate_call, and no prerequisites or exclusions. The only content is the HTTP verb/path, which does not help an agent decide.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false and openWorldHint=true, so the safety profile is covered. The description adds nothing beyond that – no mention that this is a non-idempotent write, no required-permission or naming/uniqueness constraints, and no note on what happens if a duplicate name is submitted.

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 fragments, no waste, verb front-loaded – but the brevity reflects under-specification rather than efficiency. The parenthetical endpoint is the only non-redundant element and it is not the most useful thing that could occupy that space.

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?

A 5-parameter mutation tool with no output schema and an unexplained enum needs more than this. An agent cannot learn from the description whether name must be unique, whether member_ids can be empty, or how the three group types differ – gaps the generic schema text does not fill either.

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 even with no parameter content in the description. However the schema descriptions are pure boilerplate ('Body field name (required).'), and the description does nothing to explain the meaningful parts – particularly what ring_all/monitoring/hunt actually mean for group behavior or what member_ids controls.

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 verb+resource ('Create a group') does identify the operation and separates it from get/update/delete/list_group siblings, but it is a verbatim restatement of the title with zero added specificity. It never says what a group is in this API or what creating one entails, so the agent learns nothing it didn't already get from the name.

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 when-to-use, no prerequisites, no reference to alternatives such as placetel_create_call_center_queue or the other group tools. The only extra token is the raw endpoint, which gives no selection 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false and openWorldHint=true, so the mutating/non-destructive profile is covered. The description adds only the endpoint path; it says nothing about duplicate-name behavior, permission requirements, or what happens to an existing profile on the same number — meaningful gaps for a create operation flagged as non-idempotent.

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?

It is a single short sentence plus an endpoint parenthetical, so nothing is buried or bloated. The parenthetical API path is of marginal value to an agent and edges toward filler, keeping it out of the top band.

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 create/mutation tool with no output schema, the definition should at least say what a profile represents, what a successful creation returns or enables, and any preconditions. None of that is present, leaving the agent to rely entirely on the schema and annotations.

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 name, number_id, and the response_format enum; the description supplies no additional parameter meaning. Per the baseline rule for fully covered schemas, a 3 is the appropriate ceiling.

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 verb+resource ("creates a new profile for a number") is identifiable, but it is a near-verbatim restatement of the title and adds no elaboration on what a number profile actually contains or how it differs from siblings like placetel_activate_number_profile or placetel_delete_number_profile. An agent must infer the concept of a 'profile' from the sibling 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?

There is no guidance on when to use this versus placetel_list_number_profiles, placetel_activate_number_profile, or placetel_activate_number, and no stated prerequisites (e.g., whether the number must exist or be activated first). The only contextual cue is the raw POST path, which the agent must decode itself.

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 already declare this is a non-readonly, open-world, non-idempotent, non-destructive write operation. The description only repeats that it's a POST to /prompts, adding nothing about side effects, whether duplicate names overwrite, or what a 'prompt' represents in this system. No contradiction, but no value added.

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?

Extremely short, so nothing is bloated, but the second clause '(POST /prompts)' just restates the HTTP verb already implied by the annotations and the tool name. It is appropriately sized but not information-dense.

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

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

For a 6-parameter mutation tool with a required voice enum and no output schema, the description should explain what a prompt is, how voice/text/file relate, and what is returned. None of this is present, leaving significant gaps.

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

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

Schema description coverage is 100%, so the baseline is 3. However the description contributes nothing about the meaning of name, voice, file, text, or description fields, and adds no clarification for the large voice enum beyond what the schema already lists.

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 is 'Create a prompt. (POST /prompts)' — it restates the tool name and title verbatim without adding any scope, target resource detail, or distinguishing behavior from siblings like placetel_update_prompt or placetel_list_prompts. There is no information an agent couldn't get from the name alone.

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 versus placetel_update_prompt, placetel_list_prompts, or placetel_get_prompt. It does not state prerequisites (e.g. required voice/name) or what happens when a prompt with the same name exists.

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 already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, so the safety profile is known. The description adds nothing beyond the raw endpoint (POST /provisionings) — no mention of required permissions, whether a duplicate MAC fails or overwrites, or side effects on associated numbers/lines. It does not contradict the annotations.

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

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

Two short sentences with no bloat, and the verb leads. However the second sentence merely echoes the HTTP route, and the terseness comes at the cost of any useful content rather than from tight editing.

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 write tool creating a device provisioning record with 11 parameters, the description says nothing about what gets created, whether MACs must be unique, or how the new provisioning relates to lines/webuser_id. With no output schema, the agent also has no picture of what is returned.

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 11 parameters are documented in the schema (albeit generically, e.g. "Body field mac (required)"). The description contributes no additional meaning about what mac, phone_model, codec, encryption, or lines actually control. 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?

"Creates a phone provisionings" states a verb and resource, but only restates the tool name and title with no elaboration on what a provisioning actually is. It is barely distinguishable from siblings beyond the create/get/list/update/delete prefix pattern, and the grammar is broken.

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 indication of when to use this versus placetel_update_provisioning or placetel_reconfigure_provisioning, and no prerequisites or preconditions stated. The agent must infer usage entirely from the name and sibling list.

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

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

The annotations already define it as a mutable operation (destructiveHint: false, readOnlyHint: false). The description adds technical context by including the HTTP method and resource path (POST /routings), which is marginally helpful execution detail.

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 brief and direct. It uses the minimum necessary text to identify the action and the resource, scoring highly for its efficiency.

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

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

Despite the complex 13-parameter input schema, the description provides no context on what a successful creation looks like (e.g., does it return the new ID, or just a status code). Given no output schema, this is a significant omission 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?

Since the schema coverage is 100%, the schema itself provides all structural meaning for the 13 parameters. The description adds minimal semantic value beyond repeating the core function.

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 action (Create) and the resource (routing object). However, it is highly generic and does not specify the scope or type of routing object being created, making it difficult to differentiate from other creation methods.

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 definition offers no guidance on when to use this tool compared to alternatives, such as `placetel_create_routing_plan`. It does not describe any prerequisites or conditions for successful execution.

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

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

The description is a tautology ('Create a routing plan') and adds no unique behavioral information. While annotations indicate it is a write operation and not inherently destructive, the description fails to clarify side effects, potential failures, or the nature of the resulting resource.

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 definition is concise, but the inclusion of the HTTP method and path, '(POST /routing_plans)', adds structural noise that is already strongly implied by the tool's verb and name.

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

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

Since no output schema is present, the description should ideally hint at the expected return (e.g., 'Returns the created routing plan object or a success ID'). The current description provides no information about the successful outcome of the creation process.

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 100% coverage for all 5 parameters. Therefore, the baseline score of 3 applies, as the description adds no semantic value beyond what is already documented in the input 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 tool clearly states its purpose (Create a routing plan), which is good. However, the description lacks specificity regarding what a 'routing plan' actually entails or what resource it manages, providing little context beyond the title itself.

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

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

The description offers absolutely no guidance on when to use this tool versus alternatives. Since there are multiple routing plan manipulation tools (list, get, update), the agent is forced to rely solely on the sibling tool list to understand the operational 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?

Annotations already declare readOnlyHint=false, idempotentHint=false and destructiveHint=false, so the safety profile is covered structurally. The description adds nothing about what the call creates, whether required fields must reference existing resources, or what permissions are needed — notable gaps for a 16-field create 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?

It is short and front-loaded, so it is not verbose in the penalized sense. However the parenthetical endpoint adds almost no decision value, and brevity here reflects under-specification rather than disciplined concision.

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 16-parameter, non-idempotent create operation with no output schema, the description should explain what a sip user is, what required vs. optional fields accomplish, and what gets returned. None of that is present, leaving the agent dependent entirely on schema field names.

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 16 fields (including the two required ones and the three enums) are documented structurally; baseline 3 applies. The description contributes no additional meaning about field interactions, defaults, or which optional fields are commonly 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?

"Create a sip user" restates the tool name and title verbatim; the only added content is the HTTP path (POST /sip_users). It does not distinguish this from siblings like placetel_update_sip_user or placetel_create_user, so an agent learns nothing beyond what the name already said.

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 when-to-use guidance, no mention of prerequisites (e.g., needing a routing plan or webuser_id first), and no routing to alternatives such as placetel_create_user or placetel_create_provisioning. The agent must infer all selection logic 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?

Annotations already declare this is a non-read-only, non-idempotent, non-destructive write with open-world effects, so the bar is lower — but the description adds nothing beyond the route string. It does not say whether creating a duplicate code fails or overwrites, whether the change is live immediately, or what permissions the caller needs. Nothing contradicts the annotations.

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

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

It is brief and the operation name is front-loaded, so there is no padding to trim. However, brevity here comes from under-specification rather than discipline — only the endpoint path is appended, and the whole definition is two fragments.

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 7-parameter create operation with two enums, conditional fields (`number` for `set_forward`/`set_out_number`, `group_id` for `login_group`) and no output schema, the description leaves the agent guessing at field interdependencies and return value. Annotations cover the safety profile but not the semantics the agent needs to construct a valid 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?

Schema description coverage is 100%, so every parameter including the `action` enum and `response_format` is already documented in the schema; per the high-coverage baseline this floors at 3. The description contributes no additional meaning, such as how `number`, `group_id`, and `description` relate to specific `action` values.

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

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

"Create short code" restates the tool title and name almost verbatim, with no elaboration on what a short code is or how it binds to the SIP user identified by `id`. The parenthetical HTTP route hints at the resource nesting, but an agent still cannot tell what the operation actually produces or why a short code differs from a routing entry.

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 when-to-use guidance, no prerequisites (e.g. that a SIP user must already exist), and no reference to the sibling `placetel_list_sip_user_short_codes` or `placetel_delete_sip_user_short_code`. The agent gets no signal about when this creation tool is the right choice versus configuring forwardings via `placetel_update_sip_user` or routings.

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 already disclose the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=true), so the description only needs to add context. Beyond restating the HTTP endpoint (POST /users), it says nothing about required permissions, side effects such as DID assignment, or what happens when provisioning fields like phone_mac are supplied.

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?

It is short and front-loaded, which is good, but at this length the brevity is under-specification rather than economy. The endpoint notation adds little to a reader who already has the tool name.

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

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

For a 10-parameter mutation tool with no output schema, the description omits what a created subuser looks like in the response, which fields are required or mutually exclusive, and any input constraints. Given the complexity of the schema, this is materially incomplete.

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

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

Schema description coverage is nominally 100%, so baseline is 3, but the schema text is pure boilerplate ("Body field did.") that conveys no meaning. The description makes no attempt to explain the 10 parameters, so the agent gets no real semantic guidance for fields like did, assign_did, callerid, or sip_user_type.

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 new subuser"), so the basic operation is inferable. However, it does not distinguish this from sibling creation tools such as placetel_create_sip_user or placetel_create_webex_user, and the term "subuser" is left unexplained relative to the plain "users" resource in the endpoint.

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

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

There is no guidance on when to use this tool versus the many other creation tools (sip_user, webex_user, contact, group). No prerequisites, no exclusions, and no indication of what account or role context is needed to create a subuser.

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 already declare a mutating, non-idempotent, non-destructive, open-world operation, so the safety profile is covered. The description adds nothing beyond the HTTP endpoint: no note on required permissions, side effects (e.g., automatic licensing or number provisioning), duplicate-email behavior, or what a retry would do given idempotentHint=false.

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 zero filler and the core action front-loaded. Nothing is wasted, though the brevity reflects under-specification rather than disciplined editing.

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

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

For an 8-parameter mutation tool with no output schema, the description omits what the response looks like (e.g., created user ID), what the optional package/location/phone fields do, and any post-creation steps. Annotations cover only the safety profile, leaving real behavioral gaps.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description says nothing about parameters. The schema labels are thin ('Body field package.'), so the description could have clarified the meaning of the 'package' enum values or how phone_number/extension interact, but it does not.

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 restates the tool name and title almost verbatim ('Create a Webex user'), adding only the underlying endpoint (POST /webex/users). It offers no differentiation from closely related siblings such as placetel_create_user, placetel_list_webex_users, or placetel_assign_webex_user_license, so an agent cannot tell which creation path applies.

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 statement of when this tool should be used instead of placetel_create_user or the license-assignment tools, and no prerequisites (e.g., whether a license or package must exist first) are mentioned. Usage is only inferable from the verb 'Create'.

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 already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false and openWorldHint=true, so the safety profile is covered. The description adds only the HTTP method/path, which doesn't tell the agent anything about side effects, error conditions, or what the created workspace returns — effectively nothing beyond structured fields.

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

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

It is extremely short and front-loaded, with the verb and resource in the first sentence. The endpoint parenthetical is mildly useful for debugging but is the only supplementary content, so it's efficient but nearly contentless.

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 7-parameter creation tool with no output schema, the description says nothing about what constitutes a valid request, what gets provisioned, or what is returned. The annotations cover the mutation profile, but the description itself leaves the agent with too little to call this confidently.

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 documents all 7 parameters and their enums. The description contributes no additional meaning about fields such as calling, supported_devices, or location_id, 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 gives a specific verb+resource ("Create a Webex workspace") plus the underlying HTTP endpoint, which is unambiguous. It doesn't explicitly distinguish itself from siblings like placetel_list_webex_workspaces or placetel_get_webex_workspace, though the verb makes the distinction obvious.

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

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

There is no guidance on when to use this vs. alternatives, no mention of prerequisites such as an existing location_id or supported_devices, and no exclusions. The agent must infer usage entirely 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?

Annotations already declare readOnlyHint=false, idempotentHint=false and destructiveHint=false, so the safety profile is partly covered. The description adds nothing beyond the HTTP path — no note on what state the call enters, whether it fails when the call is already answered, or what the mac/line context means operationally.

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?

It is extremely short and front-loaded, but the brevity comes from under-specification rather than efficiency — the only substantive content is the endpoint path. There is no wasted text, yet nothing informative is conveyed either.

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 non-idempotent, open-world mutation requiring three parameters with no output schema to explain the result. For a CTI call-control action whose success/failure semantics matter to an agent mid-call, the description should state the effect and the failure conditions; it does neither.

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 mac, line, call_id and response_format are all documented in the schema; the description adds no extra meaning. Per the rubric, a baseline of 3 applies when the schema does the heavy lifting and the description contributes nothing further.

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 is 'Answer' plus the raw endpoint POST /cti/{mac}/answer — a restatement of the tool name rather than an explanation. It never says what is being answered (an incoming call), nor which resource is affected, so an agent must infer the meaning from the sibling CTI tools (decline, hangup, hold).

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 when-to-use guidance, no prerequisites, and no comparison to the many adjacent CTI tools such as placetel_cti_decline or placetel_cti_pick_call_center_call. The agent has to guess that this accepts a ringing call rather than picking a queued call.

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 already disclose write/non-idempotent/open-world behavior, so the safety profile is covered, but the description adds nothing beyond the endpoint. It doesn't say what happens to the caller on the far end after the transfer (e.g., whether the transferring leg is dropped), which is the key behavioral fact for a blind transfer.

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?

It is short, but the single sentence is pure restatement of the title and URL; there is no additional content to front-load. Brevity here is under-specification rather than economy.

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 4-required-parameter telephony mutation with no output schema and many closelooking CTI siblings, the description leaves the agent without the operational context needed to choose and call it correctly.

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

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

Schema description coverage is 100%, so all five parameters are documented in the schema and the baseline of 3 applies. The description itself contributes no meaning about mac, line, call_id, or number beyond what the schema states.

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

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

The description is 'Blind transfer' plus the HTTP route, which merely restates the tool name and title. No verb nuance or scope is added, and it doesn't distinguish this from the sibling CTI tools placetel_cti_start_transfer and placetel_cti_complete_transfer, which are precisely the attended-transfer counterpart.

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 statement of when to use a blind transfer versus an attended transfer (start/complete transfer), nor any precondition such as an active call being required. The agent must infer all routing between sibling tools from their names alone.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=true, so the safety profile is covered. The description adds only the raw HTTP path, not what completing a conference actually does — whether it disconnects all participants, releases the line, or can be repeated. With annotations doing the heavy lifting, this is a minimal contribution.

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 fragments with no padding and the verb is front-loaded, but the brevity comes at the cost of specification rather than from efficiency. The parenthetical endpoint is the only extra signal.

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?

A CTI state-changing operation with three required parameters and no output schema needs more than a name echo: the meaning of the conference completion, the role of mac/line/call_id, and the expected outcome are all missing. The HTTP path alone does not close that gap.

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

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

Schema description coverage is 100%, so mac, line, call_id, and response_format are all documented in the schema, and the description adds nothing further. Baseline 3 applies when the schema carries parameter semantics entirely.

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?

"Complete conference" restates the tool name and title verbatim, adding no elaboration of what completing entails. It doesn't distinguish this from nearby siblings such as placetel_cti_start_conference or placetel_cti_complete_transfer, so an agent must guess which lifecycle step this is.

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 when-to-use guidance, no prerequisites, and no reference to alternatives. The agent is given no basis for choosing this over start_conference, hangup, or complete_transfer.

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 already declare readOnlyHint=false, idempotentHint=false, destructiveHint=false and openWorldHint=true, so the mutation profile is covered structurally. The description contributes nothing beyond the endpoint path — it does not say what state the call ends in, whether it can fail if no transfer is pending, or what happens to the other party.

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 very short sentences that are front-loaded but largely wasted: one repeats the tool name and the other is a raw route. Brevity here comes from under-specification rather than from efficient communication.

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 state-changing CTI action in a crowded family of siblings, the definition omits the flow context (that it finalizes a transfer initiated elsewhere), prerequisites, and any failure conditions. There is no output schema to lean on, so the description should carry more weight than it does.

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 mac, line, call_id and response_format are already documented in the schema; a baseline of 3 applies. The description adds no meaning about how line or call_id relate to the transfer being completed.

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 restates the title verbatim ('Complete transfer') and adds only an HTTP route. It gives no indication of what completing a transfer actually does to the call, and it does not distinguish this from the many sibling CTI actions such as placetel_cti_start_transfer or placetel_cti_blind_transfer.

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 when-to-use guidance, no prerequisite (e.g. a transfer must first be started), and no mention of any alternative sibling tool. An agent cannot infer from the text when this action is appropriate versus start/blind transfer or complete_conference.

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 already declare the mutation profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=true). The description adds only the HTTP endpoint and does not explain the effect on the call, permissions, or state changes beyond what annotations 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?

It is very short, but the issue is under-specification rather than useful concision; the single word plus endpoint does not provide an appropriately sized definition.

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 call-control mutation with multiple CTI siblings and no output schema, the description omits what declining does, expected state, and how it differs from adjacent tools. Schema and annotations give some structure, but the domain context is inadequate.

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 documents all four parameters including the required mac, line, and call_id. The description adds no parameter meaning beyond the schema, so 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 only says "Decline" plus the endpoint, restating the tool name/title. It does not identify the object being declined (e.g., an incoming/ringing call) or distinguish it from sibling actions like answer or hangup.

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 rather than placetel_cti_answer, placetel_cti_hangup, or other call-control tools, nor any prerequisite 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?

Annotations already declare readOnlyHint=false, idempotentHint=false and openWorldHint=true, so the mutating/non-repeatable nature is covered structurally. The description adds nothing beyond that — no note that this places a real call, that it requires the device identified by mac to be registered, or what happens on repeat invocation.

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?

It is short and front-loaded, but the brevity is under-specification rather than economy: the only second sentence is a raw endpoint path that gives an agent little actionable information. Nothing is verbose, yet nothing extra earns its place either.

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 non-idempotent, open-world telephony action with three required parameters and no output schema, the description leaves critical gaps: what a successful dial produces, what errors occur (invalid mac, busy line), and how it relates to the rest of the CTI tool family. This is insufficient context to invoke it confidently.

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 four parameters (mac, line, number, response_format) are documented in the schema itself. The description adds no meaning beyond it — e.g. what 'line' selects on the device — 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 is essentially a restatement of the name/title ('Dial') plus the raw HTTP path. It never says what dialing means here — placing an outbound call from a specific device — nor distinguishes it from siblings like placetel_cti_dial_digit or placetel_initiate_call. An agent must infer the resource and the effect.

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 when-to-use guidance at all, and the sibling set contains several plausibly-confusable operations (placetel_cti_dial_digit, placetel_initiate_call, placetel_cti_answer). Nothing states the precondition that an active CTI session/device context is required before dialing.

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 already declare readOnlyHint=false, idempotentHint=false, openWorldHint=true, so the write/non-idempotent profile is covered. The description adds nothing beyond the endpoint path — no statement about the active call requirement, whether the call_id must reference a live call, or what happens if the call is gone.

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?

It is short, but only because it says almost nothing; the one added sentence is a raw HTTP route that an agent calling an MCP tool rarely needs. This is under-specification rather than disciplined concision.

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?

A CTI mutation with four required parameters and no output schema needs to explain the live-call precondition and the effect of dialing a digit; none of that is present. The annotations cover only the generic write profile, leaving the operational context missing.

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

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

Schema coverage is 100%, so all five parameters (including the response_format enum) are already documented in the schema. The description contributes nothing extra, which lands at the baseline of 3 for fully-covered schemas.

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 restates the tool name and title verbatim ("Dial digit") and appends only the raw HTTP route. It does not clarify what a 'digit' means in this CTI context or how it differs from the near-identical sibling placetel_cti_send_dtmf_digits.

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 when-to-use guidance at all. With siblings like placetel_cti_dial, placetel_cti_send_dtmf_digits, placetel_cti_start_transfer, and placetel_cti_answer in the same CTI family, the agent gets no signal about which one to pick for which in-call action.

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 already declare readOnly=false, destructive=false, idempotent=false and openWorld=true, so the description carries a reduced burden, but it adds nothing beyond the endpoint path. It does not disclose that this terminates an active call, whether it is safe to retry, or what happens if the call is already gone; no contradiction with the annotations, just no added value.

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?

It is extremely short and front-loads the verb, so nothing is padded. However, the only second sentence is the HTTP route, which is marginally useful to an agent and displaces information that would actually help (scope, effect, preconditions).

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 state-changing telephony operation with three required identifiers and no output schema, the description should explain which call is ended and what the caller observes afterward. It supplies none of that, leaving the agent to infer behavior entirely from parameter names and annotations.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters, which sets the baseline at 3. The description contributes no extra meaning about mac/line/call_id beyond the schema's placeholder text, so it neither helps nor harms.

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 is the tool name/title repeated verbatim ('Hangup') plus the raw HTTP route. It does not say what is being hung up (a CTI call on a specific MAC/line) or how it differs from adjacent CTI siblings such as placetel_cti_decline or placetel_cti_complete_transfer, which an agent could easily confuse with ending a call.

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 when-to-use, when-not-to-use, or prerequisite guidance. Nothing tells the agent that a call must already be established, that the mac/line/call_id must refer to the active CTI device, or why one would pick hangup over decline/complete_transfer.

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 already indicate this is a non-read-only, non-idempotent, non-destructive operation, but the description adds no behavioral context. It does not explain what happens to the call, whether hold is reversible, or any prerequisites such as an active call.

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 short, but this is under-specification rather than useful conciseness. The endpoint path is the only extra detail, and it does not help an agent understand the action.

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

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

For a CTI action requiring mac, line, and call_id, the description does not provide enough context to invoke it confidently. The annotations and complete schema help, but the description itself is almost entirely absent.

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 itself documents all four parameters. The description adds no parameter meaning beyond the schema, which is the baseline expectation when schema coverage is complete.

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

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

The description only restates the tool name/title as 'Hold' and adds the raw endpoint path. It does not explain that this places an active call on hold or distinguish it from related CTI actions like resume or hangup.

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, when not to use it, or how it relates to alternatives such as placetel_cti_resume, placetel_cti_hangup, or placetel_cti_answer.

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 already declare readOnlyHint=false, idempotentHint=false, destructiveHint=false and openWorldHint=true, so the description carries a lower bar — yet it adds nothing about what state change occurs, what happens if no call is held, or whether the action is scoped to a live CTI session. The only extra information is the POST path, which is developer-facing rather than agent-facing.

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?

It is two tokens long with zero waste, so it is not verbose, but the only content is a redundant verb and a REST path. Brevity here reflects under-specification rather than disciplined editing.

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 non-idempotent, open-world CTI mutation with three required parameters and no output schema, the description omits everything an agent needs to act safely: what is resumed, required call state, and error behavior. Annotations cover only part of the safety profile.

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 mac, line, call_id and response_format; baseline 3 applies. The description adds no meaning beyond the schema — for example, whether line and call_id must match an active call.

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 is essentially the tool name restated ('Resume') plus an HTTP path fragment. It never says what is being resumed — a held call, a paused line, a recording, or a queue — so an agent cannot distinguish this from siblings like placetel_cti_hold or placetel_cti_answer without guessing.

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 when-to-use, when-not-to-use, or alternative is named. The most relevant sibling (placetel_cti_hold) is never referenced, and there is no statement of preconditions such as an existing held call on the given line.

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 already declare the safety profile (readOnlyHint=false, idempotentHint=false, openWorldHint=true, destructiveHint=false), so the description should add what they cannot: the description instead just repeats the HTTP method and path. It says nothing about auth requirements, what happens on an invalid MAC or inactive call, or what the response contains.

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 fragments with zero filler and the action front-loaded, so nothing is wasted. But it is under-specified rather than appropriately sized for a CTI mutation tool, which limits the value of the brevity.

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 for a stateful CTI action the description omits whether a call must be in progress, how digits are interpreted, and what a successful response looks like. Given the operation's complexity, the definition leaves meaningful gaps.

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

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

Schema coverage is 100%, so mac, digits, and response_format are all documented in the schema itself, which sets the baseline at 3. The description adds no syntax detail (e.g., allowed DTMF characters, length) but does not need to for basic invocation.

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 ("Send DTMF Digits") plus the underlying HTTP path, which is more than a bare tautology. However, it gives no scope details and does nothing to distinguish it from the closely named sibling placetel_cti_dial_digit, leaving an agent to guess which digit-sending endpoint applies.

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 versus placetel_cti_dial_digit, on whether a call must already be active, or on any preconditions. The name only weakly implies context (sending tones mid-call), so the agent gets essentially no routing help.

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 already declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, and destructiveHint=false, so the safety profile is covered. The description adds nothing about live-call state requirements, whether an existing conference is replaced, or failure modes—real gaps for an operation that mutates an in-progress call.

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 fragments and no filler, so there is nothing to trim. Brevity here reflects under-specification rather than disciplined editing, but the structure is front-loaded and contains no noise.

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 a call-state-mutating CTI action, the description should at minimum describe the live-call precondition and the resulting conference state. It supplies neither, leaving the agent with only the name, endpoint, and schema to work from.

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 mac, line, call_id, and response_format are each documented in the schema; baseline 3 applies. The description contributes no extra meaning—it does not explain that mac identifies the device, line the extension, or call_id the active call to be conferenced.

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 body 'Start conference' is a verbatim restatement of the tool title, and the only other content is an HTTP route (POST /cti/{mac}/start_conference). It gives no indication of what a conference start does at the CTI layer—who is conferenced, on which call—nor how it differs from placetel_cti_complete_conference or placetel_cti_start_transfer.

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 when-to-use guidance: no statement that an active call is required, no mention of prerequisites such as a valid call_id, and no pointer to the sibling that completes or tears down the conference. The agent must infer the whole workflow from the tool name.

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

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

Annotations already state readOnlyHint=false, idempotentHint=false, openWorldHint=true, destructiveHint=false, so the safety profile is known. The description adds nothing beyond that — no mention of side effects on the live call, required call state, or what happens to the existing call leg.

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?

It is short, but the brevity comes from omitting information rather than from efficiency: the only content beyond the name is an endpoint path, which is of little use to an agent choosing and invoking the tool.

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

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

For a stateful call-control action with no output schema and several closely related siblings, the description should explain the transfer sequence and effect. It provides none of that, leaving the agent to guess the 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 every parameter (mac, line, call_id, response_format) is documented in the schema; the baseline of 3 applies. The description contributes no additional semantic detail about what 'line' identifies or the meaning of call_id.

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

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

The description restates the tool name ('Start transfer') and appends only the raw HTTP endpoint '(POST /cti/{mac}/start_transfer)'. It does not explain what a 'transfer' means in this CTI context (e.g., starts a consultation/attended transfer of an active call to another line), so it barely exceeds tautology.

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 versus the very similar siblings placetel_cti_blind_transfer and placetel_cti_complete_transfer, nor any prerequisite (e.g., an active call_id). The agent must infer the two-step attended-transfer workflow on its own.

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 already declare destructiveHint=true and idempotentHint=true, so the description's 'Destructive' label adds no new behavioral insight. It does not explain what deactivation actually does to the number, whether it is reversible, what permissions are required, or what the response contains. The endpoint path is the only additional detail beyond structured fields.

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

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

The definition is short and front-loads the action, then adds the HTTP route and a safety label. It is efficient, though the 'Destructive' sentence largely duplicates annotation data and could have carried more useful context instead.

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 mutation on a phone number, the description is too thin: it does not state the operational effect of deactivation, any caveats, or what the caller receives. Annotations cover the safety profile and the schema documents parameters, but the description leaves important behavioral understanding 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%, so both the required 'id' and optional 'response_format' are already documented by the schema. The description adds no parameter-level meaning such as what the id refers to or how output format affects the response, so 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 and resource ('Deactivate a number') and includes the underlying HTTP endpoint, making the action concrete. It is distinguishable in practice from the sibling 'placetel_activate_number', although the description does not explicitly name that sibling.

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, no prerequisites, and no mention of reactivation or the related activate_number tool. The only implied usage comes from the tool name itself.

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 already declare destructiveHint=true, idempotentHint=true, readOnlyHint=false and openWorldHint=true, so "Destructive" merely echoes structured data and adds no value. The description does not say what is actually removed (call record, recording, CDR), whether the action is reversible, or what an error looks like for a bad id.

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

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

Three short fragments with the action front-loaded and no wasted prose. The parenthetical endpoint and trailing fragment are slightly telegraphic rather than well-structured sentences, but nothing is padded.

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

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

For a two-parameter delete whose schema and annotations are complete, the definition is minimally sufficient to invoke correctly. It is still missing the practical context an agent needs for a destructive call-log operation: what is permanently lost and whether the id must be resolved first.

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

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

Schema description coverage is 100%, so both the id path parameter and the response_format enum are already documented in the schema. The description adds no extra meaning about the id (e.g. that it comes from placetel_list_calls), 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?

States a specific verb and resource ("Delete a call") plus the underlying endpoint DELETE /calls/{id}, which cleanly separates it from placetel_get_call and placetel_list_calls. It stops short of explicitly naming those siblings, so a 5 isn't warranted.

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 delete a call versus retrieving or archiving it, no prerequisites (permissions, ownership), and no mention of consequences such as losing associated recordings or call detail records. The only hint, "Destructive", is a one-word warning rather than usable 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?

The description states it is 'Destructive and irreversible,' which is largely redundant with the existing `destructiveHint: true` annotation. It does not disclose any further behavioral constraints like idempotency effects, rate limits, or required permissions not already defined in the structured metadata.

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

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

The description is highly concise and efficient. Every sentence is essential, clearly defining the operation and its high-risk nature without unnecessary fluff.

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

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

Given that the input is a single ID, the description adequately conveys the core logic and safety profile. It lacks detail on potential error states or specific success responses, but provides all critical information for a simple deletion operation.

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

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

With 100% schema coverage, the schema already fully defines the 'id' parameter. The description merely reinforces the fact that deletion relies on an ID, providing no additional semantic depth beyond what is provided in the schema and annotations. Baseline score for high coverage 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 tool name, title, and description clearly state the action (Delete) and the resource (contact). It explicitly mentions the method of operation ('by id'), distinguishing it from other potentially similar resource managers.

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?

While it clearly defines what the tool does, it offers no guidance on when to use it versus similar tools, such as `placetel_delete_user` or `placetel_delete_group`. The usage context is implied rather than explicitly stated.

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 already declare destructiveHint=true, idempotentHint=true, and readOnlyHint=false, so 'Destructive.' merely repeats structured data. Nothing is added about what is actually removed (fax record vs. stored document), whether the deletion is reversible, or what permissions are required for a mutation with openWorldHint=true.

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

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

Three short fragments, front-loaded with the action and endpoint; no wasted prose. 'Destructive.' is redundant against the annotations, keeping it from a 5.

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

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

For a two-parameter delete with full schema coverage, complete annotations, and no output schema, the description covers the essentials. It falls short on sourcing the id and on consequences of the destructive call, which an agent would want before invoking it.

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

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

Schema coverage is 100%, so both parameters (id and response_format) are already documented in the schema. The description adds no meaning about the id's origin or the format toggle, so 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?

States a specific verb+resource ('Delete a fax') plus the underlying endpoint (DELETE /faxes/{id}), which cleanly separates it from placetel_list_faxes, placetel_create_fax, and placetel_get_fax. It doesn't name siblings explicitly, but the operation 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 on when to use this versus alternatives, no prerequisites, no note that the fax id must come from placetel_list_faxes or placetel_get_fax first. The only hint is the word 'Destructive', which signals caution but not selection criteria.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true and openWorldHint=true, so 'Destructive.' adds nothing beyond structured data. The description does not say what deletion removes (members, assignments, routing references), whether it is reversible, or what error occurs for a nonexistent or in-use group.

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

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

Three short fragments, front-loaded with the action and resource; nothing superfluous. It is arguably under-written rather than padded, but the sizing itself is 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?

A simple two-parameter delete with no output schema and full annotation coverage, so the basics are present. However, for a destructive operation the description never explains the consequences of removal (side effects on group membership or dependent configuration) or failure modes, which an agent needs before invoking it.

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

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

Schema description coverage is 100% and both parameters (id, response_format) are documented there. The description only echoes the {id} path parameter from the endpoint string, adding no new meaning, so 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?

States a specific verb+resource ('Delete a group') and includes the underlying endpoint (DELETE /groups/{id}), which unambiguously separates it from placetel_get_group, placetel_update_group, placetel_list_groups and the many other delete_* siblings. It is not explicitly differentiated in prose, but the name and verb leave no ambiguity.

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

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

No indication of when to prefer this over alternatives (e.g. update_group to modify instead of remove), no prerequisites, and no mention of what must happen to group members first. The only guidance is the bare word 'Destructive.'

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

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

The annotations already declare destructiveHint=true, idempotentHint=true, and openWorldHint=true, so the description's single word 'Destructive' adds no new information. It does not say what is destroyed, whether it can be undone, or what happens to the number's routing/configuration afterwards — the meaningful gaps for a destructive 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, front-loaded sentences with no filler. Brevity is appropriate, though it borders on under-specification for a destructive 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 destructive, irreversible-looking delete with no output schema and only coarse annotations, the description omits prerequisites, side effects, and confirmation of what is removed. An agent has to guess at the blast radius before invoking it.

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

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

Schema coverage is 100%, so the parameters are documented; the path template does clarify the roles of number_id (the number) versus id (the profile). Beyond that the description adds nothing to the schemas' minimal 'Path parameter id' text.

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 ('Delete') and resource ('a profile for a number'), and the included REST path (DELETE /numbers/{number_id}/profiles/{id}) makes the object unambiguous against siblings like placetel_delete_provisioning or placetel_delete_routing_plan. It does not explicitly contrast with related siblings such as placetel_deactivate_number, but the resource is clear enough to select it.

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 versus alternatives (deactivate a profile, update a profile, or delete the number itself). The agent must infer that this permanently removes a per-number profile.

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

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

The annotations already declare destructiveHint=true, idempotentHint=true, openWorldHint=true, and readOnlyHint=false. The description only repeats "Destructive" and the endpoint, adding no context about what is removed, whether deletion is permanent, or any auth requirements.

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

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

The description is extremely concise and front-loaded: it states the action, endpoint, and destructive nature in three short fragments. Every element earns its place.

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

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

For a simple delete operation with rich annotations and full schema coverage, the description is largely complete. It could mention permanence or response behavior, but the annotations and schema carry most of the needed 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 id and response_format parameters are already documented in the schema. The description adds no parameter meaning beyond the endpoint path, which is the baseline expectation when the schema is complete.

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

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

The description states a specific verb and resource: "Delete a prompt," and includes the endpoint path. It is clear what the tool does, but it does not explicitly differentiate itself from sibling prompt tools such as get_prompt or update_prompt.

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, nor any prerequisites or warnings beyond the word "Destructive." An agent must infer usage from the name and annotations alone.

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

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

The annotations already declare destructiveHint=true, idempotentHint=true, and openWorldHint=true, so the description's 'Destructive' adds nothing beyond structured data. It gives no extra behavior context such as irreversibility of the effect on the device, permission requirements, or error behavior for a missing id.

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

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

Three short fragments, front-loaded with the action and endpoint; minimal waste. The trailing 'Destructive' is redundant with annotations but costs only one word.

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

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

For a simple single-id delete with no output schema and full annotation coverage, the essentials are present. However, nothing is said about consequences (e.g., the device losing its configuration) or idempotent re-delete behavior, leaving a modest gap.

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

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

Schema coverage is 100% and both parameters (id and response_format) are documented in the schema, so the description adds nothing about the required id. Baseline 3 applies when the schema carries full 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?

States a specific verb+resource (delete a provisioning) and includes the underlying endpoint DELETE /provisionings/{id}, so an agent can tell exactly which object is affected and distinguish it from placetel_get_provisioning or placetel_update_provisioning. The phrasing 'a phone provisionings' is grammatically rough but not ambiguous.

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 versus siblings such as placetel_update_provisioning or placetel_delete_provisioning_custom_configuration, and no prerequisites or warnings beyond the one-word 'Destructive'. Usage is only inferable from the name and verb.

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

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

The annotations already declare destructiveHint=true, idempotentHint=true, and readOnlyHint=false. The description merely repeats 'Destructive' and adds no context about permissions, permanence, side effects, or error behavior beyond what the annotations and schema already provide.

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 action and endpoint. The trailing 'Destructive' is redundant with annotations, but otherwise there is no wasted text.

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

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

For a simple destructive delete tool with full schema coverage and annotations covering safety and idempotency, the description provides enough to call the tool correctly. It could add more behavioral context, but nothing essential is missing given the structured data.

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, including that id and custom_configuration_id are path parameters. The description adds the endpoint template but does not add meaning beyond the schema.

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

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

The description states a specific verb and resource: deleting a phone provisioning custom configuration key, with the exact REST path. It is clear enough to distinguish from sibling operations like upserting or listing custom configurations, though it does not explicitly name 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?

The description provides no when-to-use guidance, prerequisites, or alternatives. It only implies that the tool is used to remove a key, without clarifying when deletion is preferable to other operations or what conditions must hold.

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 already declare destructiveHint=true, idempotentHint=true and openWorldHint=true, so the description's 'Destructive' adds nothing new. The only extra detail is the REST path, with no information on permanence, whether the deletion can be undone, or what is actually removed.

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

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

Three short fragments with the action and warning front-loaded. 'Destructive' duplicates an annotation and the REST path is mechanical, so it is efficient but not maximally earned.

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

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

For a simple single-parameter delete with full schema coverage and annotations covering the safety profile, the definition is minimally viable. It still leaves out any note about scope (which recording belongs to which call) or irreversibility, which matters for a destructive operation.

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

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

With 100% schema description coverage, both the integer id and the response_format enum are fully documented in the schema. The description adds no parameter-specific meaning, 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?

States a specific verb and resource ('Delete a recording') that cleanly separates it from list_recordings and get_recording. It is clear but offers no explicit differentiation from sibling delete operations like delete_fax or delete_call, so it stops short of 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?

There is no indication of when to choose this tool over alternatives, no prerequisite or permission guidance, and no warning about consequences beyond the one-word 'Destructive'. The agent must infer usage entirely from the tool name.

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

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

The description merely restates the critical hint provided in the annotations ('Destructive'). It does not add any unique behavioral context, such as specific failure modes, permissions required, or side effects beyond the deletion itself, which a mutation tool should detail.

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 definition is maximally concise, delivering the core action, resource, and impact (destructive) in a single, highly readable sentence that is front-loaded with the most critical 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?

Given the 100% schema coverage and strong annotations, the description is sufficient for identifying the tool. However, its brevity prevents it from providing a complete picture of the process or required operational context for the 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 the structure is well-defined. The description mentions 'number_or_id,' which is already explicit in the schema, thus providing only baseline value without adding deeper semantic meaning to the parameter's function.

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 ('Delete') and the resource ('routing object'). It further enhances clarity by including the specific HTTP method and endpoint structure (DELETE /routings/{number_or_id}), which distinguishes it from general routing tools.

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

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

The description provides almost no guidance on when or why this tool should be used. While it labels the action as 'Destructive,' it fails to explain operational context or when it is necessary compared to other potential routing management 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?

Annotations already declare destructiveHint=true, idempotentHint=true, readOnlyHint=false and openWorldHint=true, so "Destructive." merely restates structured data. It adds nothing an agent could not already read: no statement about what happens to routings attached to the plan, whether deletion is reversible, whether the plan must be empty first, or how a missing id behaves.

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

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

Three short fragments, front-loaded with the action, with no filler prose. The one weak spot is that the trailing "Destructive." duplicates the annotation rather than earning its place with new 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 destructive, open-world mutation with no output schema, an agent still lacks critical context: side effects on dependent routings, permission requirements, and failure behavior. The annotations cover the safety profile but the description leaves the operational picture thin.

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

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

Schema description coverage is 100%, so both the required id path parameter and the response_format enum are already documented in the schema. The description adds no semantics beyond that, which is the expected baseline 3 when the schema does the work.

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 ("Delete a routing plan") and even names the underlying endpoint DELETE /routing_plans/{id}, which makes the object of deletion unambiguous among siblings like placetel_delete_routing or placetel_delete_routing_plan only by name. It stops short of explicitly contrasting with sibling delete tools, so 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 gives no when-to-use or when-not-to-use guidance and never mentions alternatives such as placetel_update_routing_plan (to modify instead of remove) or placetel_delete_routing (for a child routing rather than the plan itself). "Destructive" is a warning label, not usage guidance.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true and openWorldHint=true, and the description's single word "Destructive" merely restates that rather than adding context. The endpoint path is mildly useful disclosure, but nothing is said about irreversibility, side effects on dependent objects (short codes, routing targets) or failure behavior when the id is unknown.

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?

Front-loaded verb+resource with the endpoint in parentheses and the risk note last; there is no filler. It is arguably over-terse for a destructive operation, but nothing is wasted.

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 mutation with no output schema, the definition leaves important gaps: what a successful response looks like, what happens to dependent entities, and whether the operation is recoverable. The annotations carry the safety profile, but the description should still warn about consequences of an irreversible delete.

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 id and response_format parameters are already documented, including the enum for output format. The description adds no syntax, format or constraint detail beyond the schema, which is the expected baseline here.

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 ("Delete a sip user") and adds the underlying endpoint DELETE /sip_users/{id}, so the agent knows exactly which object is removed and that it targets the sip_users collection rather than generic users. It does not explicitly contrast with sibling placetel_delete_user, but the name and path make the distinction inferable.

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 versus alternatives such as placetel_delete_user, or when deletion is inappropriate (e.g., deactivate instead). No prerequisites, no preconditions (does the sip user need to exist, must related short codes be removed first).

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 already declare destructiveHint=true and idempotentHint=true, so the trailing 'Destructive.' merely repeats structured data rather than adding context. The description adds only the HTTP endpoint, and says nothing about irreversibility, required scope, or error behavior for a non-existent code.

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?

Extremely short and front-loaded with the action first. The redundant 'Destructive.' is minor waste but nothing hinders 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 destructive mutation, annotations carry the safety profile and the schema is fully described, so the basics are covered. It still lacks confirmation of side effects or failure conditions an agent might need before invoking.

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 id, code_id, and response_format. The description adds no semantics beyond the schema, which is the expected 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?

States a specific verb and resource ('Delete short code') and the HTTP path scopes it to a short code under a SIP user, distinguishing it from the sibling list/create short code tools. However, it does not explicitly name the sibling 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?

There is no guidance on when to use this versus placetel_list_sip_user_short_codes or placetel_create_sip_user_short_code, and no prerequisites (e.g., the short code must exist, needed permissions) are stated.

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 already declare destructiveHint=true and idempotentHint=true, so the trailing 'Destructive.' merely restates structured data. The description adds nothing new: not whether the deletion is permanent, whether it takes effect immediately, whether the subscription can be recreated with the same target, or what happens on a missing id.

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

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

Three short fragments, front-loaded with the action; nothing bloated. The parenthetical endpoint is mildly useful for API-literate agents, though 'Destructive.' is a redundant word already covered by annotations.

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-required-param delete with no output schema, this covers the mechanics. However, it never explains what a 'subscription' is in this API (webhook/event subscription) or what state the caller is left in after deletion, which matters for a destructive mutation.

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

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

Schema description coverage is 100% for both parameters, so the baseline is 3. The description does not clarify what 'id' identifies (webhook subscription vs. another subscription type) or whether response_format affects the delete confirmation, adding no meaning 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?

Specific verb + resource ("Delete a subscription") plus the underlying REST endpoint (DELETE /subscriptions/{id}), which makes it trivially distinguishable from placetel_add_subscription and placetel_list_subscriptions. It stops short of explicitly naming those siblings, so not 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?

No statement of when to use this versus list/add subscription, no prerequisites (e.g. whether the subscription must be paused first), and no warning about irreversibility beyond the single word 'Destructive.' The agent must infer all 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?

Annotations already declare destructiveHint=false→destructiveHint=true, idempotentHint=true and openWorldHint=true, so the description's single word "Destructive" merely restates the annotation. It does add the DELETE /users/{id} routing detail, but discloses nothing about what happens to the user's numbers, devices, or voicemail, or whether the deletion can be undone.

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

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

Three short fragments, front-loaded with the action and no filler. Slightly penalized because the trailing "Destructive." duplicates the annotation rather than adding information the agent did not already have.

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 destructive mutation with no output schema, and the description says nothing about side effects, cascading effects on related resources, or recoverability. For an irreversible operation in a large sibling set, that is a substantial omission.

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

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

Schema description coverage is 100%, so both parameters are documented in structured fields and the baseline of 3 applies. The description only echoes the path template {id} and adds no disambiguation about which identifier namespace the id belongs to, which matters given the many delete_* siblings.

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?

A specific verb plus resource ("Delete a subuser") with the underlying REST endpoint noted. It is clear what is being removed, though the description never explains how a 'subuser' differs from the sip_user, webex_user, or group deletion siblings present in the tool 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 gives no condition for when to use this instead of placetel_delete_sip_user, placetel_delete_webex_user, or an alternative like deactivating the account. There is also no prerequisite or warning about confirming intent before an irreversible removal.

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 already declare destructiveHint=true, idempotentHint=true, and openWorldHint=true, so restating "Destructive" adds no information. The description does not say whether deletion is permanent or reversible, what happens to the user's licenses, numbers, or Webex workspace membership, or whether an error is returned for unknown ids.

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

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

Three short fragments, purpose front-loaded, endpoint and risk flag trailing. Zero filler.

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

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

For a destructive mutation with no output schema, the essentials (what tool does, that it is destructive) are present, but the agent gets no information on side effects, failure modes, or the id's origin. Adequate but with clear gaps.

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

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

Schema coverage is 100%, so both parameters are documented in the schema and the baseline is 3. The description adds nothing about the id parameter, leaving ambiguity about whether it is the Webex user id or the PlacETel user id, and says nothing about response_format choice.

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 ("Delete a Webex user") and pins the underlying endpoint DELETE /webex/users/{id}, which distinguishes it from the sibling placetel_delete_user and placetel_delete_sip_user. No explicit sibling differentiation in prose, but the resource noun does the work.

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 versus the other delete tools (user, sip user, contact) and no preconditions such as required permissions or what must be cleaned up first (licenses, numbers). The lone signal is the adjective "Destructive."

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 already declare destructiveHint=true, idempotentHint=true and openWorldHint=true, and the description's 'Destructive' merely restates them. The endpoint path adds modest context (this is a DELETE on a Teams user), but it says nothing about whether the underlying SIP user is deleted or merely unlinked, or whether the action is reversible.

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

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

Three short fragments, front-loaded with the action and immediately followed by the route and safety note. No wasted text, though terseness edges into under-specification.

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?

Annotations cover the destructive/idempotent profile and the schema covers both parameters, so the essentials are present. Still, for a destructive mutation with no output schema, the description omits what state change actually occurs (unlink integration vs delete the SIP user) and what the response confirms.

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 schema documents both sip_user_id and response_format with an enum, so the baseline of 3 applies. The description's endpoint path shows sip_user_id is a path parameter but adds nothing about its semantics or the format parameter's effect.

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 verb 'disconnect' plus the endpoint path (DELETE /microsoft_teams/users/{sip_user_id}) identifies the resource as a Microsoft Teams user in Placitel's integration, which is clearer than the bare title. However, 'Disconnect user' alone is vague and it never distinguishes itself from siblings like placetel_import_microsoft_teams_user, placetel_sync_microsoft_teams_user, or placetel_delete_webex_user.

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 statement of when to use this tool versus the sibling import/sync/list Microsoft Teams tools, nor any prerequisites or exclusions. The agent must infer that 'disconnect' removes a Teams user's integration from context alone.

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

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

The 'Read-only' tag merely restates readOnlyHint=true and adds nothing beyond the annotations, which already declare readOnly, idempotent, openWorld, and non-destructive. No added context about what the status object contains, whether an unconfigured integration returns an error or empty result, or any auth/scope requirement.

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 fragments, front-loaded and waste-free. The endpoint parenthetical is marginally useful for traceability but is not agent-relevant; nothing is bloated.

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-required-param read with full annotation coverage, the safety profile is clear. But there is no output schema, so the description is the only place an agent could learn what the 'status' response conveys — and it says nothing about that.

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?

Only one optional parameter (response_format) with an enum and 100% schema description coverage, so the schema fully documents it. The description adds no meaning beyond the schema, which is the expected baseline here.

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 the resource (AI integration status) and exposes the underlying endpoint (GET /ai/status), which implies a read. However, it largely restates the tool title verbatim and gives no indication of what 'status' covers (connected/disconnected, provider, last sync) or how it differs from sibling integration tools like placetel_get_microsoft_teams_integration.

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 statement of when to call this versus alternatives, no prerequisites, and no exclusions. With dozens of sibling getters in the namespace, the agent is left to infer selection purely 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the trailing "Read-only." adds nothing beyond structured data. The description gives no additional behavioral context such as what a call record contains, whether it requires a specific permission/scope, or what happens for a non-existent id.

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

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

Three short fragments, front-loaded with the action and immediately followed by the endpoint; nothing bloated. The only waste is the redundant "Read-only" which restates the annotations.

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 get-by-id tool with no output schema and full parameter documentation, the description is minimally sufficient to invoke correctly. It stops short of describing the returned call object or error behavior, which an agent would want for a single-resource fetch.

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 enum for response_format is fully documented in the schema, so the baseline of 3 applies. The description adds no semantics about the id format or how response_format changes behavior.

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 verb+resource combination ("Retrieve a call") plus the endpoint path (GET /calls/{id}) makes clear this fetches a single call record by identifier. It does not, however, distinguish itself from siblings like placetel_list_calls or placetel_list_call_detail_records, so an agent must infer the singular-vs-list split from the tool name alone.

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 statement of when to use this tool versus placetel_list_calls (find a call) or the CTI/call-center siblings. Usage is only implied by the singular resource name and the {id} path template.

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