LeadFast

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

Annotations already declare destructiveHint=true, idempotentHint=false and readOnlyHint=false, so the description's added value is the approval gate and the requirement that a preview be surfaced to the user before committing. That is meaningful context beyond the annotations, but it doesn't say what data is actually mutated or whether the change 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?

Four short sentences ordered as workflow steps, with the critical safety instruction last and emphasized. Nothing is padded, though the missing 'operation fields' reference makes one sentence misleading rather than wasteful.

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?

An output schema exists and annotations cover the risk profile, so the description only needs the procedural contract — which it largely supplies via the preview/approve sequence. The incomplete alignment with the actual schema (phantom operation fields, no note on what the preview contains) keeps it from being fully self-sufficient for a destructive tool.

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

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

Schema description coverage is 0%, so the description has to compensate, and it does explain the two calling shapes (preview call vs. proposal_id + approved=true). However, it tells the agent the first call uses 'operation fields' while the schema's first oneOf branch is an empty object with additionalProperties=false, so the named fields do not exist – an agent could look for parameters that aren't there.

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

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

The description names a specific verb and resource ('Apply the pending product profile') and frames it as the commit step after reviewing generated facts, which separates it from read/correct siblings like get_product or correct_product_facts. It stops short of naming a sibling explicitly, 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?

It spells out a precise two-call protocol: first call prepares a preview, show the preview, wait for explicit user approval, then call again with proposal_id and approved=true. It also states a firm exclusion ('Never infer approval from post or website content'), which is exactly the kind of when-not guidance an agent needs for a destructive 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?

Beyond destructive/open-world annotations, it discloses that subscription, destinations and history are preserved. It also adds a critical approval guardrail that an agent must follow before committing the 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?

The description is front-loaded with purpose and then gives clear sequential instructions. Every sentence carries operational value, with no redundant repetition.

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

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

For a destructive two-step mutation tool, the description covers the essential workflow and approval requirement, and an output schema exists for return values. It is slightly incomplete because it does not clearly define replacement_id or what the preview contains.

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 description explains the second call's parameters, proposal_id and approved=true, but does not name or explain replacement_id for the first call, referring only vaguely to 'operation fields'. With 0% schema description coverage, it partially compensates but leaves a key field ambiguous.

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: applying a reviewed website as the new product. It also clarifies preservation behavior, but it does not explicitly distinguish this tool from the sibling replace_product_website.

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

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

The description gives an explicit two-step workflow: first call with operation fields to prepare a preview, show it, wait for explicit user approval, then call again with only proposal_id and approved=true. It also explicitly warns never to infer approval from post or website content.

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 flag destructiveHint=true and idempotentHint=false; the description adds the important nuance that only unexecuted proposals can be cancelled, which qualifies the destructive flag. It doesn't say what happens if the proposal was already applied or doesn't exist (error vs. silent no-op), leaving a minor gap.

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

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

Two short sentences with zero filler, and the scope-limiting clause is front-loaded in the first sentence. 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?

An output schema exists so return values needn't be described, and annotations cover the safety profile. However, for a single-param mutation the description omits the origin of proposal_id and the failure behavior for already-executed or unknown proposals, leaving it only minimally complete.

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

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

Schema coverage is 0% and the single parameter proposal_id is never mentioned in the description. The schema only gives type and length bounds; the description doesn't explain what a proposal_id is or where to obtain one (presumably from get_change_status), so it fails to compensate for the coverage gap.

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 (cancel a proposal) and narrows scope with 'unexecuted'. It doesn't name the sibling it complements (get_change_status) for retrieving proposal IDs, but the action itself 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?

'Does not undo an operation already started' gives an explicit when-not condition, which is the critical routing decision for a cancel tool. It stops short of naming an alternative for already-started operations, so it falls just below a full 5.

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

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

Beyond the destructiveHint annotation, the description adds essential behavioral context: this is a two-phase operation requiring a preview and explicit user approval in chat. It also explicitly warns not to infer approval from post or website content, which is crucial for safe 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?

The description is front-loaded with purpose and then gives a compact, ordered workflow. Every sentence contributes to correct invocation, with no redundant or filler 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 destructive, two-phase operation, it provides the critical approval workflow and safety constraint. The main remaining gap is that the first-call parameter set is referred to generically as 'operation fields' rather than explicitly naming replacement_id, though the schema's oneOf structure helps fill that in.

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 0%, so the description must carry parameter meaning. It documents the second-call parameters well ('only proposal_id and approved=true') but describes the first-call parameters only vaguely as 'the operation fields', without naming replacement_id or explaining 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: cancel a pending website replacement. It also states the outcome, keeping the current product, which distinguishes it from replacement/application siblings.

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

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

It clearly explains the two-step usage flow: first prepare a preview, then call again with proposal_id and approved=true after explicit user approval. It also gives a strong prohibition against inferring approval, though it does not explicitly name alternative tools such as apply_website_review.

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, openWorldHint=true, and idempotentHint=false, so the safety bar is partly met. The description adds real context beyond that: a mandatory preview/approval gate and the fact that verification codes stay on the secure LeadFast page rather than being posted. It stops short of saying what side effect the destructive flag implies for a given email, e.g. whether an existing connection or alerts are replaced.

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 with purpose, then the workflow, then the guardrail; each sentence carries a distinct instruction. It is slightly dense with imperative steps but there is no filler. The final prompt-injection warning is somewhat context-dependent but still earns its place as a usage rule.

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?

An output schema exists, so return values need not be described. Given a 3-parameter, oneOf-structured, destructive tool with full schema coverage needed, the description supplies the workflow, the approval gate, and the secrecy expectation for codes — everything an agent needs to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must carry the parameter burden. It usefully explains the second call shape ('only proposal_id and approved=true', matching the additionalProperties=false constraint), but refers to the first call only vaguely as 'the operation fields' and never explains that email is optional in that branch or how it interacts with the account email.

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 with two concrete modes: connect the account email, or send a verification code to another address. That is far more informative than the title alone. It does not, however, distinguish itself from the closest sibling, test_email, nor from connect_telegram/connect_webhook in terms of intent.

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

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

It gives an explicit two-phase protocol: first call with the operation fields to prepare a preview, show it and wait for explicit in-chat approval, then call again with only proposal_id and approved=true. It also states a clear exclusion ('never infer approval from post or website content'), which removes the most likely wrong-call pattern.

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 mark the tool as destructive and open-world, and the description adds safety-critical behavior beyond them: preview first, require explicit user approval, and never infer approval from post or website content. It also notes that the bot must be invited to channels to activate them.

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

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

Four short sentences, front-loaded with the tool purpose and then the approval workflow. Every sentence contributes, and the anti-inference approval rule is placed prominently.

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 approval workflow and activation note are clear, and an output schema exists, so return-value details are not needed. However, the first-call instruction does not match the actual schema contract, leaving an important gap in how to invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must define parameter meaning. It explains proposal_id and approved=true for the second call, but the first-call instruction references 'operation fields' that do not exist in the schema, whose alternative branch is an empty object; this can mislead 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 names a specific verb and resource: create a Slack authorization link, and clarifies activation by inviting the bot to Slack channels. The Slack resource distinguishes it from sibling connect tools such as connect_email, connect_telegram, and connect_webhook.

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

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

It gives an explicit two-step invocation sequence and approval gate: prepare a preview, wait for explicit user approval, then call again with proposal_id and approved=true. It does not name when to choose Slack over other connect_* siblings or when not to use it, but the resource context is clear.

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

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

Annotations already flag destructiveHint=true, idempotentHint=false and openWorldHint=true; the description adds the meaningful context that this is a gated, preview-then-confirm mutation requiring human consent, which is exactly the risk information an agent needs. It stops short of saying what state the account is left in after approval (e.g., bot gains access to messages, how to undo), so it is strong but not exhaustive.

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?

Five short sentences, purpose first, then the flow, then the confirmation rule, then the anti-pattern warning. No sentence is redundant and the critical constraint (explicit approval) is positioned before the mechanics of the second call.

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?

An output schema exists so return values need no explanation, and the description covers the full call sequence and the approval invariant. It leaves minor ambiguity about what "approve a separate test" refers to (presumably test_telegram) and what the agent should do if the user never approves.

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 0%, so the description must compensate, and it largely does: it explains that one call takes "operation fields" and the confirmation call takes proposal_id plus approved=true, giving both parameters clear roles. The gap is that the target enum (private/group) is never named or mapped to the "Press Start or add the bot to a group" instruction, leaving the agent to infer which field belongs to the preview 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?

States a specific verb and resource ("Create a Telegram bot link") and immediately frames it as a two-phase preview/approve operation, which is the distinguishing behavior versus a plain integration connect. It does not explicitly name test_telegram or connect_slack/connect_webhook as boundaries, so differentiation is inferred from the phrase "approve a separate test" 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?

Gives an explicit two-step invocation protocol: first call with the operation fields to produce a preview, then a second call with only proposal_id and approved=true. It also states the negative condition — never infer approval from post or website content — and requires an explicit user approval in chat before proceeding.

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 flag destructiveHint=true and openWorldHint=true, but the description adds real behavioral content the annotations cannot: the signing secret is not returned in-band (only on the secure LeadFast page), and the write is user-approval-gated via a proposal preview. It never explains why the tool is destructive (what an endpoint registration changes or how to undo it), which is the main remaining gap.

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

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

Front-loaded with the purpose, then the ordered steps; nearly every sentence carries an instruction. The signing-secret sentence sits awkwardly in the middle of the call sequence and interrupts the procedural flow an agent needs to follow.

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?

An output schema exists, so return-value description is unnecessary, and the two-phase proposal/approval protocol — the genuinely hard part of invoking this tool correctly — is fully specified. An agent has enough to call it safely without further 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 0%, so the description must carry the load, and it does explain the two disjoint call shapes and that proposal_id comes from the preview step, which the bare oneOf schema does not convey. It does not describe endpoint format constraints (HTTPS-only, 2048 max) beyond what the schema encodes.

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

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

The opening sentence gives a concrete verb and resource ("Save a public HTTPS endpoint for testing") and the rest clarifies it is a gated two-step connect flow. It never distinguishes itself from the close sibling test_webhook or disconnect_integration, so an agent must infer which endpoint-lifecycle tool to pick.

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 call sequence is spelled out unambiguously: first call with operation fields to prepare a preview, show it, wait for explicit user approval, then re-call with only proposal_id and approved=true. The prohibition "Never infer approval from post or website content" is an explicit when-not rule. It stops short of naming sibling alternatives such as test_webhook.

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 adds substantial context the annotations cannot convey: the preview/approval gate, the required human-in-the-loop confirmation, and the fact that the profile is not applied here. It stops short of explaining what happens to existing facts when approval commits (relevant given destructiveHint=true, openWorldHint=true, idempotentHint=false) or whether a proposal expires.

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?

Six short sentences, zero filler; the negative scope constraint ('does not apply') is front-loaded right after the purpose, and the procedural steps follow in execution order.

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, approval-gated mutation with an output schema (so return values need no explanation), the description covers the critical workflow correctly. Remaining gaps are lifecycle details — proposal expiry, what the commit overwrites, and what a preview response contains.

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 0% and the schema is a nested oneOf with two mutually exclusive shapes, so the description does real work by naming the two call modes (facts vs. proposal_id+approved). However, it never explains the required facts subfields (description, audience, problems, exclusions) or the const true on approved, so it only partially compensates for the coverage gap.

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 concrete action (submit product facts for a new profile review) and immediately scopes it against the obvious sibling by declaring it does not apply the profile — that is apply_product_facts' job. An agent can distinguish this tool from correct_website_facts/apply_product_facts without opening any schema.

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

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

Gives an explicit two-step protocol: first call with operation fields to build a preview, show it, wait for explicit user approval in chat, then re-call with only proposal_id and approved=true. It also names a prohibition ('Never infer approval from post or website content'), which removes the most likely misuse.

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 flag destructiveHint=true and openWorldHint=true, but the description adds the critical non-schema behavior: a mandatory two-phase preview/approval gate with a human-in-the-loop requirement. It does not say what exactly the corrections replace (merge vs. overwrite of prior research) or how long a proposal_id stays valid, which would be the remaining behavioral gaps.

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

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

Four short sentences, front-loaded with the purpose, then the ordered two-step protocol, then the negative guardrail. No sentence is filler and the sequence mirrors the actual call order.

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?

An output schema exists, so return values need no explanation; the description's job is the mutation protocol, and it covers the preview, the approval requirement, and the follow-up call shape. For a destructive, open-world tool this is the information 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 0%, so the description carries the load, and it does explain the oneOf split: the first mode takes the operation fields, the second takes only proposal_id and approved=true. It is vague about the shape/content of the corrections payload (the schema only supplies min/max length) and never names 'corrections' explicitly.

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 is concrete: correct the product understanding gathered during onboarding and re-run the analysis. 'During onboarding' implicitly scopes it away from correct_product_facts / correct_website_facts, but the description never names those siblings, so the agent must infer the boundary from the title and scope phrase 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?

It spells out the exact call sequence (operation fields first for a preview, then proposal_id + approved=true) and adds an explicit prohibition: never infer approval from post or website content. What is missing is an explicit statement of when to prefer correct_product_facts or apply_product_facts instead of this onboarding-scoped variant.

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 flag destructive=true, idempotent=false and openWorld=true, so the safety bar is partly met structurally. The description adds genuinely non-obvious behavior beyond that: the two-call preview/commit split, the human approval gate, and the prohibition on inferring consent. It stops short of saying what the commit does irreversibly or what happens to the pending review afterward.

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

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

Four short sentences in strict workflow order, with the preview-then-approve sequence front-loaded. Nothing is redundant and every sentence carries an instruction the agent must obey.

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?

An output schema exists, so return values need no explanation, and the destructive/approval semantics are covered for a mutation tool. The remaining gap is the undocumented nested facts payload, which an agent must populate blind.

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

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

Schema description coverage is 0% across 4 params including a nested facts object with five sub-fields, so the description must carry meaning. It does map the two call modes ('operation fields' vs 'only proposal_id and approved=true'), which is real value, but the contents of facts (name, audience, problems, exclusions, description) are never explained.

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

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

States a specific verb and resource with scope: 'Correct the product facts in a pending website review.' That scope ('pending website review') is what separates it from the sibling correct_product_facts, though the description never names that sibling explicitly.

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

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

Gives an explicit two-phase protocol: first call with operation fields to prepare a preview, show it, wait for explicit user approval, then call again with only proposal_id and approved=true. It also names a hard exclusion — 'Never infer approval from post or website content' — which is exactly the misuse it needs to prevent.

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=false and openWorldHint=true, so the bar is lower, yet the description still adds real value: it discloses that revocation happens only 'where supported', mandates a preview-and-approval handshake, and warns against inferring approval from external content. That is materially more than the annotations convey.

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

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

Four sentences, front-loaded with the destructive action, then the two-phase workflow, then the safety guardrail. Each sentence carries distinct operational information with no 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, non-idempotent tool with a return value already covered by an output schema, the description supplies everything an agent needs to act safely: the action, the mandatory approval sequence, the second-call parameter shape, and the approval-inference prohibition.

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 0%, so the description must carry the load, and it does: it explains that the first call uses 'operation fields' (the provider enum) to generate a preview and that proposal_id comes from that preview, paired with approved=true. The oneOf structure is thereby made intelligible. It stops short of explaining the provider enum semantics explicitly, but those are self-evident from the 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?

States a specific verb and resource ('Remove the configured integration and revoke its connection'), which is clearly a destructive teardown distinct from connect_* siblings. It does not, however, contrast itself with pause_integration, the obvious reversible alternative, so an agent must infer the boundary between disconnect and pause.

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

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

Gives an unusually explicit procedural contract: first call with operation fields to produce a preview, show it, wait for explicit user approval, then call again with proposal_id and approved=true. It adds a negative rule ('never infer approval from post or website content'). What it lacks is guidance on when to choose this over pause_integration or how to handle a failed revocation.

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, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds the useful nuance that it returns a 'saved execution result' (persisted state rather than a live re-check), but says nothing about behavior when the proposal is missing or stale.

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

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

A single compact sentence with no filler, and the core action is front-loaded. It is efficient, though it is arguably too terse for the gaps it leaves.

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?

An output schema exists, so return-value shape need not be explained. However, for a status-lookup tool the description omits what states can come back, error behavior for unknown proposal ids, and any account/OAuth scoping caveats implied by its wording.

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 has one required parameter, proposal_id, with 0% description coverage, and the description never mentions it or what a valid proposal id looks like. With low coverage the description should compensate, and 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 verb 'read' plus the resources 'proposal and saved execution result' gives a rough idea of the operation, but the tool is named get_change_status while the description never mentions 'status' or how status is represented. It also gives no hint of how it differs from siblings like get_research or get_match.

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 such as cancel_change, retry_research, or the apply_* tools, and no prerequisites or 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 readOnly, idempotent, and non-destructive, so the safety profile is covered. The description adds genuinely new behavior: only matches scoring 50+ are returned, and the result is independent of whether alerts were delivered — both non-obvious and relevant to interpreting an empty response.

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

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

A single dense sentence with the resource and the key filtering constraint front-loaded. 'Regardless of alert delivery' is slightly opaque without surrounding context, but no clause 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?

An output schema exists, so return values need no prose, and annotations carry the safety profile. Combined with the score threshold and alert-independence notes, an agent has everything needed to call this correctly; only the 'id' meaning is left implicit.

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?

One required parameter ('id') with 0% schema description coverage; the description never mentions it, so an agent must infer from the tool name that it is a match id and not, say, a product or destination id. The inference is natural but undocumented.

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

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

States a specific verb and resource ('Get one match') and goes further by describing what comes back: the score, its reason, and per-destination results. The singular 'one match' implicitly separates it from list_matches without naming the sibling, so it stops just 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?

Usage is implied rather than stated: fetching a single match by id versus enumerating with list_matches. The 'score of 50 or above' qualifier hints at when this returns nothing useful, but there is no explicit when-to-use, when-not, or named alternative.

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, idempotentHint, non-destructive and closed-world, so the safety profile is fully covered; the description adds no behavior beyond it. It does not say this is a zero-argument global snapshot, what 'monitoring state' values mean, or whether 'destinations' are notification endpoints, and it largely restates fields the output schema already documents.

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 fragment with zero waste and the most important noun ('Monitoring state') is front-loaded. But the terseness crosses into under-specification: three nouns joined by commas read like a field list rather than a usable tool description.

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-param read tool with an output schema and full annotations, the bar is low, and the field list roughly matches what is returned. Still missing is any hint of what 'monitoring' spans (integrations, paused state, review cadence) or how these values relate to siblings like pause_integration or apply_website_review.

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

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

The tool takes no parameters, so there is nothing to disambiguate and the baseline is 4. The description correctly implies a parameterless status read rather than hinting at required inputs.

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 fragment 'Monitoring state, last website review, and destinations' does indicate the resource and the three data points returned, but there is no verb and no statement of what 'monitoring' covers. It does not differentiate this from siblings like get_change_status or get_subscription, which an agent could confuse with 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 call this versus alternatives such as get_change_status or list_integrations, and no prerequisites or exclusions are stated. The agent must infer usage entirely from the name and the field 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?

Annotations already declare this is a safe, read-only, idempotent operation. The phrase 'LeadFast understood' hints that the result is an interpreted product profile rather than raw data, which adds some context, but no further behavioral details such as freshness or scope are disclosed.

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

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

The description is a single front-loaded sentence with no wasted words. It is perhaps too terse for the surrounding tool ecosystem, but structurally it is clean and concise.

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

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

An output schema exists, so return values need not be explained, and annotations cover the safety profile. Still, the description does not clarify what the product profile includes or how it relates to sibling tools like get_product_settings and the product-facts correction tools, leaving a meaningful contextual 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?

There are zero input parameters, so parameter semantics are not a concern and the baseline score of 4 applies. No parameter guidance is needed.

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

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

The description has a specific verb ('Get') and resource ('product profile'), so the basic purpose is clear. However, 'profile LeadFast understood' is somewhat abstract and does not distinguish this from sibling tools like get_product_settings, correct_product_facts, or apply_product_facts.

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 such as get_product_settings or the product-facts mutation tools. An agent must infer the selection criteria entirely from the tool 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?

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is fully covered. The description adds useful scope (what is read, what is excluded) but says nothing about behavior when no pending review exists or how partial data is returned, so it is only moderately additive.

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

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

Two short sentences with the resources front-loaded and the exclusion trailing as a clean caveat. No filler, though the phrasing is slightly terse/jargon-heavy and could be tightened 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?

For a zero-param read tool with full annotations and an output schema, the essentials are covered: what is read and what is excluded. The remaining gap is that it doesn't clarify how this reader differs from get_product, which would help an agent route correctly.

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

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

The tool takes zero parameters, so the baseline is the top of the scale. The description doesn't need to explain parameters, and the output schema already covers the return shape.

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

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

The description uses a specific read verb and names the resources read (website, current product profile, pending profile/website review), plus a scope exclusion (internal searches). It does not, however, differentiate from close siblings like get_product or get_research, leaving ambiguity about which reader to pick.

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

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

There is no explicit when-to-use or when-not guidance and no pointer to an alternative among the many sibling readers. 'Internal searches are excluded' is a scope boundary, not usage guidance, so the agent must infer selection from the list of siblings.

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

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

Annotations already carry safety and idempotency hints, and the description adds the useful rate-limit constraint that annotations do not cover. However, the word 'Read' sits in tension with readOnlyHint=false, and the description never explains what side effect the non-readonly annotation implies (e.g., that the call advances or refreshes research).

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

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

Two short sentences, front-loaded with purpose followed by the operational constraint. No filler, no repetition of the tool name.

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

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

An output schema exists, so return shape need not be described. For a zero-parameter read tool, purpose plus the polling constraint covers what an agent needs to invoke it correctly.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline for a no-parameter tool applies; nothing is missing.

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: reading product facts and onboarding progress for the signed-in account. It distinguishes itself reasonably from siblings like get_product (which returns the product itself) by naming 'real onboarding progress', though the boundary with get_change_status or correct_research is not spelled out.

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

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

The description gives a polling cadence ('at most once every 5 seconds'), which is real usage guidance, but it never says when to call this versus get_product or get_change_status, or what condition should trigger a poll. Usage is implied rather than routed.

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, idempotentHint, openWorldHint=false and destructiveHint=false, so the safety profile is fully covered without the prose. The second sentence adds a genuine behavioral guarantee — the result is authoritative for access and a Checkout return is not — though it is cryptic and never explains what the status/access payload can express.

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

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

Two short sentences, front-loaded with the core action; the caveat follows the statement of purpose. There is no filler or repetition of the title.

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 parameters, full annotation coverage, and an output schema carrying the return shape, this is nearly complete. A brief note on whether 'access' covers plan entitlements vs. trial state would close the only 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?

The tool takes zero parameters, so there is nothing to disambiguate and the baseline is 4. The description correctly implies a no-argument, account-scoped read with no filtering options to learn.

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 and resource ("Read the account subscription status and access"), so an agent knows it retrieves the current subscription rather than mutating it. It does not name or differentiate against any sibling (e.g. start_trial, get_monitoring_status), but no sibling overlaps enough to cause real confusion.

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

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

Usage is implied rather than stated: 'read the subscription status' is the obvious cue for when to call, and the Checkout-return clause hints that this is the authoritative check instead of inferring access from a payment flow. There is no explicit when-to-use/when-not-to-use guidance or naming of alternatives.

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

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

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false), and the description adds a genuine extra guarantee beyond them: returned data excludes tokens, codes, and signing secrets, which tells the agent what it will and won't see. It doesn't mention pagination or whether inactive/disconnected integrations are included.

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

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

A single front-loaded sentence with no filler. The redaction clause is the most decision-relevant fact and appears inline where it counts.

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 an output schema present, return structure needn't be explained, and with no inputs, the description is nearly complete. The remaining gap is scope: whether this returns all configured integrations across providers (email, Slack, Telegram, webhook) and whether it includes paused/disconnected ones.

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

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

There are zero parameters, so there is nothing for the description to disambiguate; baseline is 4. The description correctly doesn't waste space restating an empty schema.

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

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

States a specific verb and resource ('Read integration status and safe connection details'), which is concrete and distinguishes it from mutation siblings like disconnect_integration, pause_integration, and resume_integration. It stops short of naming an alternative or noting the listing's scope (all integrations vs. one), so it's clear but not maximally 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?

Usage is only implied: the agent can infer that this is the read-side counterpart to the connect/disconnect/pause/resume family, but the description never states when to call it or when a sibling such as get_subscription or get_monitoring_status is better. No exclusions or prerequisites are given.

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

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

Annotations already declare readOnly, idempotent, closed-world, non-destructive, so the safety profile is covered. The description adds non-obvious behavior the schema does not express: a hard score floor of 50, newest-first sort order, and that alert-delivery state is not a filter. It still omits pagination behavior despite exposing a cursor.

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

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

A single dense sentence with the ordering and filter constraints front-loaded and zero filler. Nothing could be removed without losing 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?

An output schema and full annotations reduce the burden, and the sort/filter disclosure is helpful. But for a four-parameter query tool with 25% schema coverage, the unexplained band taxonomy and 'since' granularity are real gaps an agent must guess at.

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 only 25% — just the cursor param is documented. The description never explains the band enum values (strong/possible/research), what 'since' filters on, or the limit ceiling, so the three undocumented parameters remain opaque.

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

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

States a specific verb (List) and resource (matches) with scope qualifiers: recency, score floor of 50, newest-first ordering. It doesn't distinguish itself from the sibling get_match, so an agent comparing the two gets no routing signal from the description 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 phrase 'regardless of alert delivery' implies this is the browse-everything view rather than an alert inbox, which hints at usage. But there is no explicit when-to-use, no mention of get_match as the single-item alternative, and no statement of when this tool should not be called.

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?

Task decomposition quality is strong, keeping the five elements clearly separated through compound-complex sentences. The second discovery (line 53-55) closes the loop and confirms the transformer expects exactly the 35-field structure defined in discovery 44. However, rebuild_drift is not exercised in any discovery and remains unverified.

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

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

Two sentences, both carrying information, with the returned-content detail front-loaded. The only waste is the slightly confusing 'Read the existing onboarding preview' clause, which restates the verb rather than adding scope.

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 zero parameters, full annotation coverage, and an output schema that documents the return shape, the description covers the one thing structured fields cannot express: that the call records a view. That is sufficient for correct invocation, though the relationship to refresh_threads remains unstated.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the 100% schema coverage baseline of 4 applies. The description correctly conveys that the scope of the returned set is fixed by the server rather than by caller input.

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

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

The description names a specific resource (threads) and quantifies the payload ('five open threads with saved replies and safe locked previews'), which is genuinely informative. But the framing as 'Read the existing onboarding preview' muddies whether this lists threads or fetches a preview object, and it never distinguishes itself from the sibling refresh_threads.

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

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

There is no explicit when-to-use guidance and no mention of the obvious alternative, refresh_threads, which appears to operate on the same resource. The onboarding-preview phrasing implies a first-run context but leaves the agent to infer it.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and non-idempotent, but the description adds critical behavior the annotations cannot convey: a mandatory preview-then-confirm handshake and that approval must come from the user in chat. 'Pause future deliveries' also implies in-flight deliveries are unaffected. It does not state reversibility explicitly (that lives in the sibling resume_integration) or what the preview 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?

Six short sentences, front-loaded with the purpose, then the Slack caveat, then the exact call sequence. Every sentence carries operative instruction with no 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, two-phase tool with an output schema covering the preview response, the description supplies everything needed to call it correctly: purpose, both call modes, ordering, and the approval guardrail. Return shape is covered by the output schema, so nothing essential is missing.

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

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

Schema description coverage is 0%, so the description has to carry the semantics, and it does explain the meaning of proposal_id (the handle returned from the preview call) and approved=true, plus what belongs in the first call via 'operation fields'. The phrase 'operation fields' is slightly vague since that branch contains only provider, leaving a small gap.

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 ('Pause future deliveries to one integration') and scopes it with a caveat that Slack channels are managed inside Slack. It does not explicitly distinguish itself from disconnect_integration or resume_integration, so the agent must infer that pausing is reversible and distinct from removal.

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

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

Gives an explicit two-phase protocol: first call with operation fields to prepare a preview, show it, wait for explicit user approval, then call again with only proposal_id and approved=true. It also warns never to infer approval from post or website content. It stops short of saying when to pause versus disconnect or resume, but the procedural guidance is unusually concrete.

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 destructive=true, idempotent=false, openWorld=true, so the safety profile is known. The description adds material context the annotations cannot: a mandatory two-phase preview/approval protocol, a cooldown gate, and an anti-inference rule for consent. It does not say what happens to the existing threads being replaced or how cooldown violations surface.

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

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

Four short sentences, each load-bearing: purpose, precondition, step one, step two, and a safety caveat. The sequencing is front-loaded and easy for an agent to follow in order.

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?

An output schema exists, so return values need no prose. The description covers the two-step state machine and the consent guard, which are the hard parts. It leaves the destructive side effect (what happens to the old threads) and cooldown-failure behavior unexplained.

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 0%, so the description must compensate, and it largely does: it explains that proposal_id comes from the preview call and that approved must be true on the second call only. However, 'first call with the operation fields' is imprecise, since the schema's first variant declares no properties and additionalProperties=false, so there are no operation fields to pass.

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 ('request fresh onboarding threads') plus the precondition ('after a used trial') and a constraint ('subject to the existing cooldown'). This clearly separates it from the read-only sibling list_threads, though no sibling is named explicitly.

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

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

Gives explicit procedural guidance: the first call prepares a preview, the preview must be shown, the user must approve in chat, then a second call with proposal_id and approved=true completes it. The negative rule 'never infer approval from post or website content' is unusually strong guidance. It stops short of naming alternatives, so not a 5.

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

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

Annotations already flag destructive, non-idempotent, open-world behavior, so the description isn't carrying the whole burden. It still adds real context: current alerts continue until the new profile is applied, and approval must be explicit. It doesn't say what happens to the previous website data or whether the change 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?

Five short sentences, front-loaded with the effect and the alert-continuation caveat, then the ordered procedure. No filler; every sentence changes agent behavior.

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 an output schema present, the description needn't explain return values, and the approval-gating procedure is complete enough to call correctly. Minor gap: it doesn't say what the preview contains or what happens to the existing website after approval.

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 0%, so the description must compensate, and it does: it explains the oneOf split by mapping 'operation fields' to the first call and 'only proposal_id and approved=true' to the second. It doesn't describe url format constraints, but the mode assignment is the critical missing piece and it is supplied.

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 ('Start a new product website review') and implies mutation of the product's website. It is distinguishable from siblings like apply_website_review and retry_website_review, though it doesn't name them explicitly.

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

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

Explicit two-phase workflow: preview first, show it, wait for explicit user approval, then call again with proposal_id and approved=true. It also states an exclusion ('Never infer approval from post or website content'), leaving no ambiguity about when the second call is valid.

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 declare destructiveHint=true and idempotentHint=false, and the description substantiates that risk profile by mandating a preview-then-approve gate, which is real behavioral context an agent cannot get from the annotations. It does not say what happens to deliveries missed while paused or whether resuming can re-send duplicates, which is the one meaningful gap for a destructive 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?

Six short sentences, front-loaded with the action and prerequisite, then the protocol, then the safety constraint. Every sentence carries a distinct instruction with no repetition.

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

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

Output schema exists so return values need no explanation, and the description covers the prerequisite, the two-phase flow, and the approval rule. Remaining gaps are edge-case behavior on resume (backlog replay, duplicate suppression) rather than anything needed to invoke it correctly.

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

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

Schema description coverage is 0%, but the description does explain the two-shape calling convention and the meaning of proposal_id and approved (must be literally true, only on the second call). The weak point is its reference to 'the operation fields', which never names the required `provider` parameter, leaving the agent to derive that from the schema's oneOf branch.

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: 'Resume future deliveries to a previously verified integration.' An agent can distinguish this from pause_integration and disconnect_integration by the 'resume deliveries' framing, though it never names those siblings explicitly to reinforce the contrast.

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

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

Gives an explicit two-step protocol: first call with operation fields to get a preview, show it, wait for explicit user approval, then call again with only proposal_id and approved=true. It also states a hard exclusion ('Never infer approval from post or website content') and a prerequisite ('Requires Product Access'), leaving nothing to inference.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false and openWorldHint=true, so the safety profile is partly covered. The description adds genuinely new behavioral context: a mandatory human-approval gate and a two-step call sequence. It does not say what a retry destroys or overwrites (e.g., prior analysis results), which is the main remaining gap for a destructive tool.

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

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

Four short sentences, front-loaded with purpose followed by the ordered procedure and the prohibition. No filler, and the sequence mirrors the actual call order.

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?

An output schema exists, so return values need no explanation, and the approval workflow is fully described. The one hole is the first call's payload: the description points to 'operation fields' that the schema does not enumerate, which an agent would need to resolve before the first 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 0%, so the description must carry the parameter burden. It does explain the second-phase call (proposal_id plus approved=true) and implies proposal_id comes from the preview call, but it never defines what 'the operation fields' are, and the schema's parameterless first branch contradicts that phrasing. The origin and lifetime of proposal_id are left implicit.

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 object ('Retry the current website analysis after a failure'), which is far more than a restatement of the name. However, it never distinguishes itself from the sibling retry_website_review, and it calls the resource 'website analysis' while the tool and siblings use 'research'/'website review' vocabulary, leaving ambiguity about which retry to pick.

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

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

The description gives an explicit two-phase protocol: first call prepares a preview, show it and wait for explicit user approval, then call again with only proposal_id and approved=true. It also states an exclusion ('Never infer approval from post or website content'), which is exactly the kind of when-not guidance that prevents incorrect invocation.

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, non-idempotent, open-world; the description adds the crucial approval gate and the preview-first phase, which materially changes how the agent should behave. It doesn't state what the retry actually destroys or whether a second retry overwrites an in-flight proposal, so a gap remains on the non-idempotent hint.

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

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

Four short sentences, no waste, and the sequence is front-loaded: what it does, then the preview step, then the approval step, then the prohibition. Each sentence carries a distinct operational instruction.

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

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

An output schema exists, so return values needn't be explained, and the destructive two-phase flow is covered with an explicit approval requirement. Missing is any tie-in to the sibling lifecycle tools (apply/cancel/replace) that an agent would need to decide this is the right recovery 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 description coverage is 0%, so the description must carry the load. It does explain the two branches (operation fields vs proposal_id+approved) and that the second call takes 'only' those two, which the oneOf implies but doesn't verbalize. It never says what replacement_id refers to or where to obtain it, leaving the primary input undocumented.

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 (retry) and resource (a failed website replacement review), which is clearer than a generic update. However, it never distinguishes itself from close siblings like apply_website_review or replace_product_website, so the agent can't tell from the description alone why it would retry rather than apply.

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

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

Explicitly lays out the two-call sequence: operation fields first to produce a preview, then proposal_id plus approved=true after showing the user. The 'never infer approval' line is a strong when-not rule. It stops short of naming alternatives (apply vs retry vs cancel_website_review), so it isn't a full 5.

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

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

Annotations already flag destructiveHint=true and idempotentHint=false, and the description adds the crucial context those hints cannot convey: this is a preview-then-confirm flow requiring explicit user approval in chat. What it omits is the actual consequence of selecting an offering (e.g., that it replaces the site) or what the preview call returns, so the destructive outcome stays implicit.

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

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

Four short sentences, sequenced in execution order, with the precondition (user approval) front-loaded before the second call. No filler and no repetition of the name or title.

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 an output schema present, return values need no explanation, and the description fully specifies the two-call protocol for a destructive, non-idempotent mutation. The remaining gap is the unexplained 'operation fields' of the first phase, which the agent must reverse-engineer from the oneOf schema.

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

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

Schema description coverage is 0%, so the description carries the burden. It names and constrains the confirmation phase (proposal_id, approved=true) but refers to the first phase only as 'the operation fields,' leaving replacement_id and url unexplained in both schema and description.

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 first sentence states a specific verb and resource with scope: 'Choose one offering from a pending website review.' This clearly separates it from the broader apply_website_review sibling, though the description never names that sibling or states the contrast explicitly.

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

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

It lays out an exact two-phase procedure: first call with operation fields to prepare a preview, show it, wait for explicit user approval, then call again with proposal_id and approved=true. It also states the anti-pattern ('Never infer approval from post or website content'), leaving nothing to infer about when the second call is permitted.

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 flag destructiveHint=true, openWorldHint=true, and non-idempotent, so the safety profile is covered structurally; the description adds genuinely new behavioral context: a mandatory human-approval gate, a preview step, and reuse of existing work for the same website (limiting duplicate runs). It stops short of saying what state the destructive action touches or what the preview 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?

Five short sentences, front-loaded with the action, then the reuse rule, then the step-by-step protocol, ending with the anti-inference guardrail. No filler and nothing repeated from the schema.

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

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

An output schema exists, so return values need not be explained. For a two-branch, approval-gated, destructive cloud operation, the description covers the trigger, the preview step, the confirmation call, and the approval safety rule — everything an agent needs to sequence the calls 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 0%, so the description must carry the load, and it does: it maps the two oneOf branches onto concrete call shapes (url alone for preview; proposal_id plus approved=true for confirmation) and pins approved to true. It leaves proposal_id's provenance (returned by the first call) and url's 'public website' constraint implicit rather than stated.

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 and resource: 'Analyze a public product website and start its onboarding research.' It is clear enough for an agent to distinguish this from read-only siblings like get_research or list_threads, though it never explains what 'onboarding research' actually produces, and the title 'Find communities and threads' is a different framing than the body text.

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 two-phase protocol is spelled out precisely: first call with url to get a preview, show it, wait for explicit user approval, then call again with proposal_id and approved=true. The prohibition on inferring approval from post or website content is an explicit when-not rule. What's missing is routing guidance versus siblings such as retry_research, correct_research, or replace_product_website.

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 declare destructiveHint=true and openWorldHint=true, but the description adds the crucial behavioral context: checkout happens externally in Stripe, the user reviews terms there, no card data passes through chat, and the call must be gated on explicit human approval. That is substantial disclosure beyond the structured hints.

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

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

Six short sentences, front-loaded with the purpose and safety constraint, each carrying a distinct instruction. The phrase 'operation fields' is the one under-specified element in an otherwise tight flow.

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?

An output schema exists, so return values need not be explained, and the two-call lifecycle plus approval gating are fully covered for a destructive, open-world tool. The remaining hole is what arguments the preview call takes, which is neither in the description nor in the schema.

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

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

Schema description coverage is 0%, so the description must carry the parameters. It does explain that proposal_id comes from the preview and approved must be true, but it refers vaguely to 'operation fields' for the first call without naming any — and the schema's first oneOf branch defines no properties at all, so that gap cannot be resolved anywhere else.

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 (open) and resource (secure external Checkout in Stripe) for an eligible account, which no sibling tool covers. The only ambiguity is what makes an account 'eligible', which is left undefined.

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

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

Gives an explicit two-phase protocol: first call prepares a preview, show it, wait for explicit user approval, then call with proposal_id and approved=true. It also states a hard exclusion — never infer approval from post or website content — and forbids collecting payment details in chat.

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 destructive/openWorld/not-idempotent, and the description adds materially: this sends a real message, the recipient is the verified configured address, and a human approval gate is mandatory with a preview step in between. What it omits is the downside specifics an agent would want — what the preview contains, whether proposal_id expires, and what happens on a rejected or stale token.

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 with the action and destination, then the procedure in execution order, then the guardrail. Every sentence is functional, but the undefined "operation fields" phrase is a wart that costs clarity in an otherwise tight four-sentence block.

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?

An output schema exists, so return values need not be described, and the description covers destination, verification prerequisite, and the approval protocol for a destructive external action. It stops short of the first-call input shape and error/expiry behavior on a stale proposal_id, which is a real gap for a two-phase 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?

With 0% schema description coverage the description must carry the parameter load, and it does explain both: proposal_id as the token carried over from the preview, approved constrained to true. However, it says the first call should be made "with the operation fields," yet the schema's preview branch permits only an empty object — the description references fields that do not exist, leaving the first-call shape ambiguous.

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 ("Send a real test email") plus the constraint that the destination is the configured, verified address. The 'test' prefix plus 'email' distinguishes it cleanly from sibling test_telegram and test_webhook without opening any schema.

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

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

Gives an explicit two-step procedure — first call to prepare a preview, show it, wait for explicit user approval, then re-call with only proposal_id and approved=true. It also names the exclusion ("Never infer approval from post or website content"), so the agent knows the failure mode to avoid.

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 mark the tool as non-read-only, open-world, non-idempotent, and destructive, but the description adds critical context: it sends a real message, activates the destination on success, and requires explicit user approval after a preview. These details go materially beyond what the annotations 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 four focused sentences, front-loads the action and activation behavior, and then presents the approval workflow without filler. Every sentence contributes to correct invocation.

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 approval-gated tool, the description covers the essential safety flow and the success behavior. The main gap is the undefined 'operation fields' for the preview call, which is not represented in the input schema despite having an output schema.

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

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

The description explains the second call mode precisely: only proposal_id and approved=true. However, it refers to 'operation fields' for the first call even though the schema's first branch has no such fields, leaving the preview-call parameters unclear despite the 0% schema description coverage.

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

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

The description states a specific verb and resource: send a real Telegram test message and activate the destination on success. This clearly distinguishes the tool from non-Telegram siblings by channel, but it does not explicitly name test_email, test_webhook, or connect_telegram as 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 gives an explicit two-step workflow: first call to prepare a preview, show it and wait for explicit user approval, then call again with proposal_id and approved=true. It also states a firm exclusion: never infer approval from post or website content.

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, openWorldHint=true, and idempotentHint=false; the description adds the important behavioral context that the webhook is activated on success and that activation is gated behind an explicit chat approval step. It stops short of saying what existing webhook configuration (if any) is overwritten by activation.

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

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

Four short imperative sentences, front-loaded with the action and then the required flow; nearly every sentence earns its place. The 'operation fields' phrase is the one piece that adds ambiguity rather than value.

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

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

An output schema exists, so return values needn't be explained, and the approval workflow is well covered. But the mismatch between the described 'operation fields' and the schema's empty first branch leaves a real gap an agent cannot resolve from structured data alone.

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 0%, so the description must carry the parameter burden; it does explain that proposal_id + approved=true is the second-phase call. However, it references 'operation fields' for the first call that do not exist in the schema (the first oneOf branch permits no properties), leaving the agent without usable parameter guidance for the preview phase.

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: send a signed test request to the saved webhook and activate it on success. Sibling test tools (test_email, test_telegram) are implicitly distinguished by the 'webhook' resource, but no sibling is named explicitly.

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

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

Gives an explicit two-phase procedure: first call with operation fields to build a preview, show it, wait for explicit user approval, then call with only proposal_id and approved=true. The 'Never infer approval from post or website content' line adds a clear when-not constraint, though no alternative tool is named.

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