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

The description adds valuable behavioral detail beyond the annotations by explaining the server-side nature, the variable repeatability of the operation, and the dry_run preview behavior including the error-flagged result. This does not contradict the annotations; it reinforces and elaborates on idempotentHint=false while adding context about how preview responses are represented.

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 the core purpose and keeps the additional caveats in two follow-up sentences. All sentences carry useful information, but the third sentence is somewhat dense and mixes preview mechanics with output-schema behavior, so it is concise but not maximally streamlined.

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

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

Given the nested schema and existence of an output schema, the description is largely complete: it covers the important non-idempotency warning, the server-side action nature, and the dry_run safety mechanism. It could be more complete by explicitly contrasting with related sibling operations, but nothing critical needed to call the tool correctly is missing.

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

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

Schema description coverage is 100%, so the schema already documents all parameters including nested requestBody fields. The description mentions dry_run usage but mostly repeats what the schema already says; it adds the error-flag nuance but does not provide additional meaning for the other parameters.

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

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

The description opens with a specific verb and resource: 'Creates a Branch of the Document.' It clearly identifies what the tool does and adds the meaningful distinction that this is a server-side action rather than a plain resource creation. However, it does not differentiate itself from the sibling tool branchDocuments, so the purpose is clear but not fully distinguished from similar operations.

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 actionable guidance: it warns that the action is not guaranteed idempotent and advises setting dry_run=true to preview the exact request before making changes. This is clear context for how to use the tool safely, though it does not explicitly discuss when to choose this over alternatives such as branchDocuments or copyDocument.

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 goes well beyond the annotations. It explicitly warns that the operation is not guaranteed idempotent, that repeating it may be safe, a no-op, or rejected depending on the action, and explains the dry_run preview behavior including the error-flagged result quirk. This is rich behavioral context that annotations alone (readOnlyHint=false, idempotentHint=false) do not 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 compact and front-loaded with the core purpose, then adds the critical idempotency warning and dry-run tip. Every sentence earns its place. It loses one point because the dry_run explanation is somewhat dense and could be split for readability, but it's still efficient.

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

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

Given the tool's complexity (nested requestBody, 10 sub-parameters, no idempotency guarantee), the description covers the most critical operational concerns: the server-side action nature, idempotency risk, and the dry_run safety mechanism. The output schema exists, so return values don't need explanation. It doesn't mention prerequisites like permissions, but the dry-run guidance partially compensates.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds value by explaining the dry_run parameter's behavior in detail, but it doesn't add meaning to the requestBody fields beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description states a specific verb and resource ('Creates Branches of Documents') and distinguishes it from plain resource creation by noting it triggers a server-side action. It doesn't explicitly name sibling tools like branchDocument or copyDocument, but the phrase 'Branches of Documents' plus the server-side action warning makes the core purpose clear.

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

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

The description gives clear context for when to use the tool (when branching documents) and provides a strong practical guideline: set dry_run: true first to preview the request. It doesn't explicitly say when not to use it or name alternatives, but the dry-run tip effectively guides safe usage.

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

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

Annotations already mark readOnlyHint=false, idempotentHint=false, and destructiveHint=false. The description adds value by explaining the server-side nature and explicitly warning about non-idempotency, which is not fully captured by the annotations. It also details the dry_run preview behavior, including how results are flagged, which is useful beyond the schema. No contradiction with annotations.

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

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

The description is concise, with the core purpose stated first, followed by the effect and a practical tip. It avoids redundant wording and is well-structured, though the second sentence about preview behavior is slightly long but still clear.

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

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

The description explains the tool's effect and the dry_run mechanism, which is helpful. However, it does not clarify what 'closing' entails (e.g., status change, archiving) or what the response looks like, since there is no output schema. Given it's a mutation tool, more detail on the outcome would improve completeness, but the current level is adequate.

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

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

Schema coverage is 100%, with each parameter described in detail, including dry_run's purpose. The description reinforces the dry_run tip but does not add additional meaning beyond what the schema already provides. Baseline of 3 is appropriate since the schema handles parameter documentation.

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

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

The description clearly states 'Closes the specified Collection' with a specific verb and resource, which is unambiguous. However, it does not explicitly differentiate from sibling tools like deleteCollection or reopenCollection, relying on the name and context. The additional note about it being a server-side action adds some distinction but not a direct comparison.

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

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

The description provides context that this is a server-side action and not guaranteed idempotent, implying it should be used when a close operation is needed. However, it does not explicitly state when to use this tool versus alternatives (e.g., delete vs. close) or when not to use it. The dry_run tip gives practical usage guidance but no selection criteria.

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

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

Annotations already declare idempotentHint=false, but the description elaborates on the consequences (safe/no-op/rejected) and adds the dry_run preview behavior. This goes beyond the structured metadata without contradicting it.

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

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

The description is concise and well-structured: purpose first, then effect, then a practical tip. No filler; every sentence adds information. Slightly longer than strictly necessary but justified by the non-obvious 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?

Given the nested requestBody and output schema existence, the description covers the key caveats (non-idempotency, dry_run preview) and does not need to explain return values. It is sufficiently complete for an agent to call it correctly.

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

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

Schema description coverage is 100%, so all parameters are already documented. The description adds only the dry_run tip, which is already in the schema. No additional parameter-level semantics are provided.

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 clear verb-resource pair ('Creates a copy of the Document') and adds a critical nuance (server-side action) that distinguishes it from simple resource creation. It clearly differentiates from siblings like branchDocument or moveToDocument by focusing on 'copy' semantics.

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?

Explains the side-effect nature and non-idempotency, which is useful for deciding when to call it, but does not explicitly contrast with sibling copy/branch/move tools. No when-not guidance or alternative tool names are mentioned.

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 meaningful behavioral context beyond the annotations: it explains the server-side action, warns about non-idempotency (consistent with idempotentHint: false), and details the dry_run behavior including the error-flagged result. This is valuable context not present in annotations alone. It does not contradict annotations; it reinforces and elaborates on 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?

The description is appropriately sized, containing four sentences each serving a purpose: the core action, the idempotency caveat, the dry_run tip, and the output behavior. It is front-loaded with the main purpose and adds relevant details without fluff. It is not overly verbose and every sentence earns its place.

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

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

The description covers the essential aspects: what it does, the idempotency concern, and how to preview via dry_run. It does not explain the fields of requestBody, but the schema already provides thorough descriptions for each. The output schema exists, so return values are not needed. Prerequisites are not mentioned, but for a creation tool they may be self-evident. Overall, it is fairly complete for its complexity.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds a tip about setting dry_run: true, but this information is already present in the schema's parameter description. The description does not introduce new meaning for parameters; it merely restates what the schema already provides. No additional semantic value is added beyond the schema.

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

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

The description clearly states the primary action: 'Creates a new Project.' It goes beyond a simple resource creation by noting it triggers a server-side action, which distinguishes it from a generic create and clarifies its non-trivial nature. It is unambiguous about the resource being created and aligns with the tool name.

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

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

The description does not explicitly compare against alternative tools or state when to use this tool versus others. Usage is implied by the name and description, but there is no explicit guidance on when not to use it or which sibling to choose. The dry_run tip is a safety guideline, but it is more about how to use than when. No alternatives or exclusions are mentioned.

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 signal destructiveness and non-read-only behavior, but the description adds meaningful context: the operation is irreversible, data cannot be recovered through the API, and the dry-run preview behavior is explained. This goes beyond what the annotations alone provide, though the open-world hint is not elaborated on.

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 the core action and scope, then gives the sibling alternative, irreversibility warning, and dry-run tip. It is slightly long due to the dry-run error-flag explanation, but each sentence earns its place for a destructive tool.

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

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

For a destructive global-scope operation with no output schema, the description covers scope, irreversibility, safe preview usage, and the project-scoped alternative. It does not explain response/return details, but for a delete operation with a typed schema covering inputs, this is a minor gap.

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

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

Schema description coverage is 100%, so the parameters are already well documented. The description's dry_run tip reinforces the schema's dry_run explanation but does not add much beyond it. The nested requestBody structure is adequately described by the schema itself.

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

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

The description clearly states the tool deletes a list of Work Items from the Global context, with scope explicitly spanning every project. It also distinguishes itself from the sibling `deleteWorkItems` by noting the project-scoped alternative, so an agent can immediately tell which deletion tool to choose.

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 when-to-use rule: use this for global scope, use `deleteWorkItems` for a single project. It also recommends `dry_run: true` as a safe preview step before committing to an irreversible operation, which is concrete practical guidance.

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

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

Annotations already indicate destructive and idempotent behavior, and the description adds valuable context beyond them: the operation is irreversible and cannot be recovered through the API. It also explains the dry_run preview behavior, including how to interpret the error-flagged preview result. No contradiction with annotations exists.

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

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

The description is compact and front-loaded: the primary action, cardinality, alternative tool, and irreversible effect appear early. The dry_run tip is useful and earns its place. No sentence is redundant with the schema or annotations.

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

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

For a simple single-item delete with no output schema, the description covers the essential operational context: scope, sibling routing, irreversibility, and a dry-run safety mechanism. Together with the fully documented schema and annotations, it gives an agent everything needed 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?

The input schema has 100% parameter description coverage, including specifics like case-sensitive projectId and workItemId format. The description itself does not add parameter-level detail beyond mentioning the single-item cardinality, so the baseline of 3 applies: the schema does the heavy lifting.

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

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

The description opens with a specific verb and resource: 'Deletes the specified Work Item Approval.' It immediately distinguishes itself from deleteApprovals by stating cardinality: 'targets a single item by ID.' An agent can clearly understand what this tool does and how it differs from the batch sibling.

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

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

The description explicitly gives the when-not-to-use guidance: 'For the full collection or a batch, use deleteApprovals instead.' It also recommends a safe invocation pattern with dry_run first. This gives the agent clear decision criteria for selecting this tool over its sibling.

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

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

Beyond annotations already marking the operation destructive, the description discloses irreversibility ('data removed or overwritten... cannot be recovered') and documents the dry-run preview behavior, including the error-flagged result quirk. No contradiction with annotations.

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

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

Four sentences, each earning its place: operation, cardinality, alternative, irreversibility, and dry-run tip. The key scoping information is front-loaded before the extended tip.

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 multi-item operation with no output schema, the description plus fully covered parameters and annotations is sufficient: it warns about irreversibility, explains how to preview safely, and clarifies the odd error-flagged preview output. No critical call-time behavior is left undocumented.

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

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

Schema coverage is 100%, so the bar for added value is lower; the cardinality statement clarifies that `requestBody.data` may represent a batch or full collection, which the bare array schema does not convey. However, it does not add field-level detail beyond the schema for `id` and `type`.

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

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

The description opens with a specific verb and resource ('Deletes a list of Work Item Approvals') and explicitly distinguishes itself from the singular sibling `deleteApproval`. The cardinality note ('full collection or a batch') removes ambiguity about scope.

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

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

It tells the agent exactly when to choose this tool versus `deleteApproval` ('For a single item by ID, use deleteApproval instead'), and recommends starting with `dry_run: true`. This is explicit routing guidance, not merely implied context.

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

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

The annotations already mark the tool as destructive and not read-only, but the description goes further by stating irreversibility ('data removed or overwritten by this call cannot be recovered through the API'). It also discloses the dry-run preview behavior, including the nuance that error-flagged results may represent previews rather than real failures. This adds meaningful behavioral context beyond the structured annotations.

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

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

The description is compact and front-loaded: core action first, then cardinality, sibling routing, irreversibility, and the dry-run tip. Every sentence provides distinct, necessary information with no filler or repetition. It is appropriately sized for the tool's complexity.

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

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

For a single-item deletion tool with no output schema, the description covers everything an agent needs: what is deleted, the scope (single ID), the batch alternative, irreversibility, and safe preview guidance. It also references relevant project ID semantics indirectly through the schema, and the dry-run note addresses how to interpret unexpected results. No critical context is missing.

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

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

Schema description coverage is 100%, so all three parameters are already well documented in the schema. The tool description reinforces `dry_run`'s purpose and prepares the user for preview output, but it does not materially expand parameter semantics beyond what the schema already states. Baseline 3 is appropriate.

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

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

The description opens with a specific verb and resource ('Deletes the specified Collection'), states the cardinality ('targets a single item by ID'), and explicitly distinguishes itself from the sibling `deleteCollections` for batch/full operations. An agent can confidently select this tool over its close sibling without opening schemas.

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

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

It gives explicit when-to-use guidance via the cardinality statement and names the alternative (`deleteCollections`) for full-collection or batch deletion. It also provides a concrete safety tip to use `dry_run: true` first, and even explains how the preview result is surfaced. This is actionable usage guidance beyond a generic description.

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?

While annotations already flag destructiveHint=true, the description adds meaningful specifics: 'irreversible — data removed or overwritten by this call cannot be recovered through the API.' It also discloses the dry_run preview behavior and the error-flagged result for previews, which is not covered by annotations. No contradiction with annotations (idempotentHint and destructiveHint are compatible).

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

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

The description is compact and front-loaded: the primary action and differentiation come first, followed by irreversibility, then the dry_run tip. Every sentence adds value; there is no filler. Structure is efficient for an agent scanning for purpose and safety.

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 3-parameter tool with a nested requestBody and no output schema, the description covers essential context: what it deletes, cardinality, alternative for single items, irreversibility, and a dry_run preview mechanism. Nothing required for correct invocation is missing, and the error-flagged preview behavior is explained.

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

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

Schema description coverage is 100% — the schema already fully describes projectId, requestBody, and dry_run. The description's mention of 'full collection or a batch' and the dry_run tip adds usage context but not parameter-specific semantics beyond what the schema provides. Baseline of 3 is appropriate.

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

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

The description opens with a clear verb+resource statement: 'Deletes a list of Collections.' It immediately differentiates from the sibling `deleteCollection` by specifying cardinality ('targets the full collection or a batch') and explicitly directing single-item use to `deleteCollection`. Purpose is unmistakable.

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

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

The description explicitly states when to use this tool versus alternatives: 'For a single item by ID, use `deleteCollection` instead.' It also provides a concrete usage tip (set `dry_run: true` to preview) and explains the preview's error-flag behavior. Usage conditions and exclusions are fully specified.

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 explicitly states that the effect is 'irreversible' and that removed or overwritten data 'cannot be recovered through the API.' It also discloses dry_run preview behavior, including that typed-output previews appear as error-flagged results and the agent should read the text content regardless of that flag.

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

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

The description is three sentences with no filler. The primary action is front-loaded, followed by the irreversible warning and the actionable dry_run tip; every sentence contributes necessary information.

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

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

The description, combined with the 100%-documented schema and annotations, fully equips the agent to invoke the tool correctly. It covers the destructive nature, the safe preview workflow, and the error-flag behavior, while the schema covers all parameter semantics and required fields.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining the dry_run workflow and the error-flag nuance, enriching the meaning of the dry_run parameter. Other parameters rely on the schema, which fully documents them.

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

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

The description opens with a specific verb and resource: 'Removes the specific Relationship from the Collection.' This clearly identifies the deletion action and distinguishes it from sibling tools like postCollectionsRelationships, patchCollectionsRelationships, and getCollectionsRelationship.

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

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

The description implies when to use the tool—when a specific relationship must be removed from a collection—and provides the dry_run tip as a safety practice. However, it does not explicitly mention alternatives or exclusions, such as using patchCollectionsRelationships to modify or postCollectionsRelationships to add relationships.

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 goes well beyond the destructiveHint annotation by stating that deletion is irreversible and data cannot be recovered through the API. It also explains the dry_run preview behavior, including that the preview may be returned as an error-flagged result on typed output tools and that the text content should be read regardless. These are valuable behavioral details not present in the annotations.

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

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

The description is composed of three sentences, with the purpose front-loaded, followed by an irreversible warning and a dry_run tip. The last sentence is somewhat long but provides important context for interpreting error-flagged preview results. Overall, each sentence carries necessary value and there is no redundancy.

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

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

For a destructive delete tool with no output schema, the description covers the essential safety aspects: irreversibility, dry_run preview, and how to interpret the preview response. Together with the fully documented input schema, it provides sufficient context for an agent to invoke the tool correctly, though it does not mention any prerequisites or post-conditions beyond the warning.

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

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

With 100% schema description coverage, the schema already documents all parameters. The description adds meaningful semantics for the dry_run parameter by explaining that the preview is error-flagged and must be read from text content, which is not explicitly in the schema. It does not add semantics for other parameters, but the schema covers them adequately.

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 'Deletes a list of Document Parts,' which is a specific verb-resource pair. It clearly differentiates from sibling tools like moveDocumentParts, overwriteDocumentParts, and getDocumentParts by explicitly naming the delete action and the target resource.

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

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

The description gives clear context for when to use this tool: to delete document parts. It also includes a practical safety tip to use dry_run first for preview. However, it does not explicitly mention alternatives or exclusions, such as moveDocumentParts or overwriteDocumentParts, leaving some room for 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?

Beyond the destructiveHint annotation, the description details irreversibility, possible overwriting, and the dry_run preview behavior including the error-flagged result nuance. This is additive context that helps the agent behave safely.

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?

Every sentence adds value: primary action, cardinality/alternative, irreversibility, and the dry_run preview including output schema edge case. No fluff or redundant restating of annotations.

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

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

For a destructive single-item deletion with no output schema, the description gives the agent everything needed: what it deletes, when to use the sibling, that it is irreversible, and how to preview safely. Parameter details are fully covered by the input schema.

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

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

Schema description coverage is 100%, so the schema already explains all parameters. The description adds operational tips about dry_run but does not materially extend the meaning of the parameters beyond what the schema provides.

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

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

States a specific verb and resource: 'Deletes the specified Externally Linked Work Item.' Explicitly identifies cardinality as single-item and distinguishes itself from the batch sibling `deleteExternallyLinkedWorkItems`.

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 tells the agent when to use this tool versus the batch alternative and includes the dry_run preview tip to validate before committing to an irreversible call.

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

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

The description adds valuable behavioral context beyond the annotations: it states the operation is irreversible and data cannot be recovered through the API, which reinforces the destructiveHint. It also introduces the dry_run tip and explains that the preview appears as an error-flagged result because it's not real tool output. This is genuinely useful information an agent wouldn't get from annotations or schema alone.

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

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

The description is compact yet information-dense: each sentence serves a purpose. It front-loads the core action, then quickly covers scope, alternative, irreversibility, and a safety tip. There is no filler or redundancy, making it easy to parse in one glance.

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 batch operation with no output schema, the description covers the essential facts: what it does, scope, irreversibility, and a dry-run safeguard. It doesn't mention prerequisites like required permissions or behavior when some items don't exist, but given the schema already details the payload and the annotations carry the destructiveness, this is nearly complete. A short note on error/partial-failure behavior would push it to 5.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds extra meaning by explaining the cardinality of the operation ('full collection or a batch') and noting that a single item by ID belongs to the sibling tool.This helps an agent understand how the requestBody array should be populated, which goes slightly beyond the schema's dry property descriptions. Thus a 4 is appropriate.

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

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

The description opens with 'Deletes a list of Externally Linked Work Items', which is a specific verb and resource, and immediately clarifies scope with 'Cardinality: targets the full collection or a batch.' It also differentiates from the sibling 'deleteExternallyLinkedWorkItem' by explicitly stating for a single item, use that other tool. This leaves no ambiguity about what the tool does or how it differs from its closest alternative.

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

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

The description provides clear context for when to use this tool: when deleting a list, collection, or batch. It explicitly names the alternative for single-item deletion, which is a strong routing signal. However, it doesn't enumerate other situations where this tool should be avoided (e.g., if partial deletion is needed or if soft-delete semantics are required), so it falls short of fully explicit when-not-to-use guidance.

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

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

Beyond the annotations (destructiveHint, idempotentHint), the description discloses that the operation is irreversible and cannot be recovered via the API. It also explains the dry_run preview behavior, including the error-flagged result quirk, which adds significant behavioral context.

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

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

The description is tight, front-loaded with the core purpose, then scope, alternative, effect, and tip. Each sentence earns its place without redundancy, making it easy for an agent to parse quickly.

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

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

For a destructive, irreversible operation with no output schema, the description covers all essential aspects: scope, alternative, irreversibility, dry_run usage, and the preview's error-flag nuance. Nothing an agent needs to call it correctly is missing.

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

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

The schema already documents all parameters with high coverage. The description adds value by explaining the dry_run preview's error-flag behavior, which is not in the schema. This extra nuance justifies a score above the baseline of 3.

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

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

The description states a clear verb (Deletes), a specific resource (Custom Field configuration), and the context (Global context). It explicitly differentiates from the sibling deleteProjectCustomFields, making the tool's scope unambiguous.

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

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

It explicitly tells when to use this tool (for global scope) and when to use the alternative (deleteProjectCustomFields for a single project). It also recommends a dry_run tip for safe preview, providing clear guidance on how to invoke it safely.

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 discloses that the operation is irreversible and data cannot be recovered through the API, which is critical behavioral context. It also explains the dry_run preview behavior, including that the preview is returned as an error-flagged result. The annotations already declare destructiveHint=true and idempotentHint=true, so the description adds value by explaining the irreversibility and the dry_run behavior beyond what 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 concise and well-structured, with the core purpose front-loaded. It covers scope, alternatives, effect, and a usage tip in a compact form without unnecessary words. Every sentence earns its place.

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

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

The description is complete for a destructive operation: it states scope, irreversibility, and provides a safe preview mechanism. There is no output schema, but the description explains what to expect from the dry_run preview. The only minor gap is not describing the success/failure response format for the actual deletion, but the irreversibility warning and dry_run tip largely compensate.

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

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

The schema description coverage is 100%, so the schema already documents all four parameters. The description adds some context by mentioning dry_run: true as a tip, but it doesn't add significant meaning beyond what the schema already provides. Baseline 3 is appropriate given the high schema coverage.

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

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

The description clearly states the tool deletes a specified Enumeration from the Global context, with a specific verb and resource. It also explicitly distinguishes itself from deleteProjectEnumeration, which operates on a single project. This makes the tool's purpose unambiguous and differentiates it from its sibling.

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

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

The description explicitly states when to use this tool (Global context, no project filter) and when not to (use deleteProjectEnumeration for a single project). It also provides a clear tip to use dry_run: true first to preview the request, which is actionable usage guidance.

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

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

The description provides substantial behavioral context beyond annotations: it states the effect is irreversible, explains the dry_run preview behavior, and details how the preview appears as an error-flagged result. These insights go well beyond the destructiveHint and idempotentHint annotations, giving the agent a clear picture of side effects and safety measures.

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

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

The description is concise and front-loaded with the core action, followed by the platform caveat, irreversibility note, and the dry_run tip. It is efficient in wording, though the sequence could be slightly more organized for scanning. Overall, it earns its place without unnecessary verbosity.

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

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

The description covers the tool's purpose, irreversibility, platform compatibility, and a safety tip for previewing requests. Given the tool's moderate complexity (3 parameters, no output schema) and the rich annotations, this is nearly complete. It lacks explicit details on return values or error handling, but those are not required given the absence of 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 input schema already provides detailed descriptions for all parameters (typeId, dry_run, requestBody), achieving 100% coverage. The description adds a practical tip about using dry_run but does not elaborate on parameter meaning beyond the schema, so it stays at the baseline of 3.

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

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

The description explicitly states the action (deletes), the resource (Group license slots), and specifies it operates on a list, distinguishing it from the singular deleteLicenseSlot. It also notes the platform limitation (not supported by cloud-based Polarion X), leaving no ambiguity about what the tool does.

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

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

The description implies usage for bulk deletion of license slots and provides a safety tip to use dry_run first. However, it does not explicitly contrast with alternatives like deleteLicenseSlot (singular) or explain when to choose one over the other. The guidance is present but implicit rather than explicit.

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 goes beyond annotations by disclosing irreversibility, exact singular cardinality, and the dry-run preview behavior including the error-flagged result nuance. These details align with the destructive/readOnly annotations and add valuable operational context.

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

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

The description is well-structured and front-loads the core action, then covers exclusions, cardinality, the batch alternative, effect, and dry-run tip. The Java API reference is minor filler, but the overall density is justified and scannable.

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

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

For a destructive single-link deletion with no output schema, the description covers scope, irreversibility, dry-run safety, and batch alternatives. It does not explicitly describe the normal success/failure response shape, but the abundant schema documentation and behavioral warnings largely compensate.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters. The description adds only a usage tip around `dry_run` and does not materially expand parameter semantics beyond what is already present in the schema.

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

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

The description clearly states the action: deletes a single direct outgoing Work Item link by ID. It distinguishes itself by excluding external links and backlinks and by naming the batch sibling `deleteLinkedWorkItems`, leaving no ambiguity about scope.

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

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

It explicitly states when to use this tool (single link targeting one item) and when not to: use `deleteLinkedWorkItems` for full collection/batch, and this does not handle external links or backlinks. It also promotes a safe workflow by recommending `dry_run: true` first.

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

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

Beyond annotations (destructiveHint true, etc.), the description adds irreversibility warning, dry_run tip, and error-flagged preview behavior. This provides valuable context about consequences and testing without contradicting any annotation.

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 appropriately sized, front-loads the core purpose, and each sentence adds distinct value (scope, cardinality, alternative, effect, tip). The dry_run explanation is slightly verbose but not excessive.

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

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

Despite no output schema, the description covers purpose, scope, cardinality, alternative, and behavioral caveats. It doesn't detail return values or edge cases (e.g., empty batch), but for a destructive tool with strong annotations, the info is sufficient for correct invocation.

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

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

Schema description coverage is 100%, so all parameters are already documented. The description adds minimal extra parameter meaning, mostly reinforcing the dry_run tip and cardinality; it does not introduce new semantics beyond the schema, which is acceptable given high coverage.

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

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

The description clearly states the verb 'deletes' and the resource 'direct outgoing links to other Work Items', distinguishing it from external links and backlinks. It also specifies cardinality (full collection or batch) and names the singular sibling tool, so an agent can immediately differentiate.

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

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

Explicitly directs to 'deleteLinkedWorkItem' for a single item and clarifies that external links/backlinks are out of scope. It doesn't exhaustively cover all related alternatives (e.g., postLinkedWorkItems), but the core usage context and primary alternative are 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?

The description adds valuable behavioral context beyond the destructiveHint annotation: the operation is irreversible through the API, only the link is removed, and dry_run previews the request without changing anything. It also warns about how the preview may appear as an error-flagged result, which is important for interpreting tool output.

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 the core action, then follows with scope boundaries, alternatives, irreversibility, and a practical dry-run tip. Every sentence contributes essential decision-making or usage information without redundancy.

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

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

Given the annotations, full schema coverage, and no output schema, the description covers everything an agent needs: what is deleted, what is not deleted, how to identify targets, when to use alternatives, and safety/preview behavior. No critical contextual gap remains.

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

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

Schema description coverage is 100%, so the parameters are already well documented. The description adds extra meaning by specifying that requestBody.data contains link IDs returned by getOslcResources and by explaining the effect of dry_run, which goes beyond the schema's generic field descriptions.

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

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

The description states a specific verb and resource: 'Removes one or more OSLC links from a Work Item'. It also distinguishes itself from sibling tools by explicitly contrasting with postOslcResources and deleteLinkedWorkItems, so an agent can select the correct operation without guessing.

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

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

The description gives explicit routing guidance: use postOslcResources for adding links and deleteLinkedWorkItems for Polarion-internal links. It also clarifies the boundary by noting the remote OSLC artifact is untouched, which helps agents decide when this tool is not appropriate.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false. The description adds that the effect is irreversible and data cannot be recovered via the API, which goes beyond the annotation. It also explains the dry_run preview behavior, clarifying that the preview returns an error-flagged result. This provides meaningful behavioral context beyond the structured fields.

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

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

The description is two sentences, front-loaded with the core action ('Deletes the specified Page') followed by the irreversibility warning and the dry_run tip. Every sentence adds value and there is no fluff. The structure is optimal for quick parsing.

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

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

For a simple delete tool with three required parameters and one optional, the description covers the essential behavioral aspects: irreversibility, dry_run preview, and the preview's error-flag behavior. The output schema is absent, so no need to explain returns. It doesn't mention side effects on related data (e.g., attachments) but that is not required for a basic delete operation. Overall, it is sufficiently complete.

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

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

The input schema has 100% coverage with clear descriptions for all four parameters, including dry_run, projectId, spaceId, and pageName. The description does not add meaning beyond the schema; it only references dry_run in the tip. Per calibration, baseline 3 is appropriate when schema covers everything.

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

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

The description clearly states the action: 'Deletes the specified Page.' It specifies the resource (Page) and the verb (Deletes), and distinguishes it from read/update tools like getPage and patchRichPage by making the destructive nature explicit.

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 useful tip about dry_run but does not mention when to use this tool versus alternatives, nor does it state conditions where it should not be used. There is no explicit comparison to sibling tools like deletePageRelationships or patchPage, leaving the agent to infer usage from the name and action.

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

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

Annotations already flag destructiveHint and readOnlyHint=false, but the description adds crucial context: the operation is irreversible and data cannot be recovered. It also explains the dry_run preview behavior and how to interpret the error-flagged result, which goes beyond annotation data. No contradiction with annotations.

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

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

The description is concise, with the core action front-loaded, followed by irreversibility warning and a practical tip. No wasted words; every sentence adds value.

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

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

For a delete tool with no output schema, the description covers the essential action, irreversibility, and dry_run guidance. It does not specify the success return behavior, but that is often implicit for delete operations and not critical given the lack of output schema. The dry_run preview explanation adds completeness.

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

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

Schema description coverage is 100% and all parameters have thorough descriptions. The tool description does not add any parameter-specific meaning beyond the schema. It mentions dry_run but the schema already explains it. Baseline 3 is appropriate given full schema coverage.

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

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

States a specific verb ('Deletes') and resource ('Page Attachment'), clearly distinguishing it from sibling get/patch operations. The irreversibility note further clarifies the destructive nature. The purpose is unambiguous and distinguishes from alternatives by verb.

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

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

The description clearly implies when to use (to permanently remove an attachment) and emphasizes irreversibility, which guides usage caution. It also provides a concrete usage tip (dry_run) for safe preview. However, it does not explicitly name alternatives or when not to use, but for a delete operation that is largely implicit.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=true. The description adds valuable context: irreversibility, the dry_run preview tip, and the note about error-flagged results for previews. This goes beyond annotations without contradicting 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?

The description is three sentences, front-loaded with the primary purpose, then the critical irreversible effect, then the practical dry_run tip. It is concise and well-structured, with no wasted words.

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

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

For a destructive delete tool with 6 params, nested objects, and no output schema, the description covers the essential operational details: irreversibility, dry_run preview, and preview behavior. It does not explain what a page relationship is, but that is covered by the schema and sibling context. Overall, it is sufficiently complete for an agent to call it correctly.

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

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

Schema description coverage is 100%, so all parameters are documented in the schema. The description adds no parameter-specific details beyond what the schema provides, except highlighting dry_run in the tip. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states the verb ('Deletes') and resource ('Page Relationships'), and explicitly notes the irreversible effect. This distinguishes it from read tools like getPageRelationships and update tools like patchPageRelationships, making the purpose unambiguous.

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

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

The description implies usage for deleting page relationships but does not explicitly contrast with alternatives like postPageRelationships or patchPageRelationships. There is no 'use this when...' or 'use X instead' guidance, though the destructive nature is highlighted. This is adequate but not explicit.

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 destructiveHint=true, but the description adds context about irreversibility ('data removed or overwritten by this call cannot be recovered through the API') and explains the dry_run preview behavior, including the error-flagged result nuance. This goes beyond annotations, providing valuable behavioral insight without contradiction.

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 structured clearly: purpose, cardinality, alternative, effect, and tip. It is a bit verbose with the dry_run preview explanation, but each sentence serves a purpose and the main point is front-loaded. No wasted words.

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

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

For a delete tool with no output schema, the description covers all necessary guidance: what it does, when to use alternatives, irreversibility, and a safe workflow via dry_run. Required parameters are handled by the schema. Nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 100%, so parameters are already well-documented. The tool description reinforces the `dry_run` tip but doesn't add fundamentally new semantics beyond what the schema provides. Baseline 3 is appropriate given high schema coverage.

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

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

The description states a specific verb and resource: 'Deletes the specified Plan.' It also clarifies cardinality ('targets a single item by ID') and explicitly distinguishes from the plural sibling `deletePlans`. An agent can immediately understand the tool's function and how it differs from 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?

It explicitly directs when to use this tool vs. alternatives: 'For the full collection or a batch, use `deletePlans` instead.' It also provides a practical tip about using `dry_run` to preview the request, which is actionable guidance for safe usage.

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

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

Beyond the destructiveHint annotation, the description explicitly warns that the operation is irreversible and that removed/overwritten data cannot be recovered through the API. It also discloses the dry_run preview behavior, including the note about error-flagged results. This adds meaningful behavioral context beyond the annotations.

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

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

The description is concise and front-loaded: purpose, then destructive effect, then the dry_run tip. The final sentence about typed output schemas is slightly tangential because this tool does not have an output schema, but the overall length is still appropriate and focused.

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

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

The description covers the essential intent, irreversibility, and safe preview guidance, which is particularly important for a destructive mutation tool. The schema provides rich parameter descriptions. It does not describe success/error response details, but with no output schema and strong parameter documentation, the description is sufficiently complete for invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself does not add parameter-level detail beyond the schema, and it does not need to; the schema already documents planId, projectId, relationshipId, requestBody, and dry_run. No additional semantic value is provided for parameters.

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

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

The description states a specific action and resource: 'Removes the specific Relationship from the Plan.' This is clear and matches the tool name. It does not explicitly contrast this with sibling tools like deleteCollectionsRelationship or deleteWorkItemsRelationship, but the Plan-scoped target is evident from the name and description.

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

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

The description implies this tool is used when a Relationship on a Plan needs to be removed, and the dry_run tip gives operational guidance. However, it does not explicitly state when to choose this tool over alternatives or mention related tools such as postPlanRelationships or patchPlanRelationships. The usage context is mostly implied rather than stated.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, but the description adds crucial context: irreversibility (data cannot be recovered via the API) and the behavior of dry_run (returns error-flagged preview). It also explains how to interpret that preview, which is valuable beyond the annotations.

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

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

The description is concise, front-loaded with the core purpose and cardinality, and every sentence adds value. The dry_run tip is practical and the exclusion of deletePlan is clear, with no wasted words.

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

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

Given the destructive nature, the description covers the essential aspects: cardinality, irreversibility, alternative for single deletion, and a safe preview mechanism. It does not need to describe return values since there is no output schema, and annotations already cover idempotency. The description is complete for correct invocation.

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

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

Schema coverage is 100%, so parameters are fully documented in the schema. The description mentions dry_run but does not add new parameter semantics beyond what the schema already states. Baseline of 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states it deletes a list of Plans, specifies cardinality (full collection or batch), and distinguishes itself from deletePlan for single-item deletion. This gives a precise verb+resource+scope that an agent can act on without ambiguity.

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

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

It explicitly directs users to deletePlan for a single item by ID, providing an alternative and the condition for choosing it. The dry_run tip also guides safe usage by recommending a preview step before actual deletion.

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 goes beyond the destructiveHint annotation by stating the effect is irreversible and that data cannot be recovered through the API. It also explains the dry_run preview behavior, including the unusual error-flagged result, which adds meaningful behavioral clarity.

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

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

The description is three sentences with no filler: it states the action, the risk, and the safe invocation path. The dry-run output caveat is included because it is genuinely important, and the structure is front-loaded.

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

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

For a destructive two-parameter tool with an output schema and supporting annotations, this description is complete. It covers the destructive effect, irreversibility, the safe preview pathway, and the non-obvious preview output behavior.

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

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

Schema coverage is 100%, so the schema already fully documents projectId and dry_run. The description adds a useful tip about setting dry_run first, but does not introduce additional parameter-level semantics beyond the schema.

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

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

The description opens with an explicit verb and resource: 'Deletes the specified Project.' This clearly states the tool's function and distinguishes it from sibling read/update tools like getProject and patchProject.

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 conveyed somewhat implicitly: use this when you need to delete a project. The dry-run tip and irreversibility warning provide useful context, but the description does not explicitly name alternatives or state when deleteProject should not be used.

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 destructiveHint=true, but the description adds crucial context: the effect is irreversible and data cannot be recovered via the API. It also discloses the dry_run preview behavior, including the error-flagged result quirk, which is not visible in annotations or schema. This is rich behavioral disclosure beyond structured data.

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

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

Every sentence serves a distinct purpose: purpose, scope/alternative, irreversibility, and dry_run tip. The information is front-loaded and there is no filler or repetition of schema content.

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

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

For a destructive tool with no output schema, the description covers all essential call decisions: what it does, scope, the alternative for global scope, irreversible effect, and a safe preview mechanism. The dry_run error-flag behavior is a subtle but critical operational detail that would otherwise be a surprise. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by tying projectId to scoping ('Scope: one project (requires a project ID)') and by recommending dry_run with a concrete purpose ('preview the exact request... without changing anything'). This goes beyond simply restating schema.

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

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

The description opens with a specific verb and resource ('Deletes the specified Custom Field configuration') and immediately scopes it to one project. It explicitly names the sibling tool deleteGlobalCustomFields and the condition that selects it (across all projects), making differentiation 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?

Provides explicit guidance: use for one project, use deleteGlobalCustomFields for all projects. Also gives a practical workflow tip (dry_run first) with a clear rationale. There is no ambiguity about when this tool is the right choice.

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 destructiveHint=true)Skip, but the description adds 'irreversible 'and clarifies the dry_run behavior, including the error-flagged result on preview. This goes beyond annotations and gives critical behavioral context 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?

The description is well-structured, starting with the action, then scope, alternative, effect, and tip. It is a bit verbose, especially the last sentence about typed output schemas which may not apply to this tool (no output schema). However, it remains front-loaded and every sentence provides value, making it appropriately sized for the safety-critical nature.

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

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

The description covers the key aspects: the operation, scope, irreversibility, and a safe execution tip. It does not describe return values or error handling, but there is no output schema and parameters are fully documented. The sibling alternative is clearly named. Minor omission: no mention of idempotency despite the idempotentHint, but that's covered by annotations. Overall sufficient for correct invocation.

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

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

Schema description coverage is 100% for all 5 parameters, so the schema already fully describes each parameter. The description does not add new parameter-level details, only restates the project scope which is already in the schema. Baseline 3 is appropriate.

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

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

The description explicitly states 'Deletes the specified Enumeration from the Project context', giving a clear verb and resource. It further distinguishes itself from deleteGlobalEnumeration by scoping to one project, making the purpose unambiguous and differentiating from a direct sibling.

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

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

It provides explicit when-to-use guidance: 'Scope: one project (requires a project ID). To act across all projects, use deleteGlobalEnumeration instead.' This tells the agent exactly when to choose this tool over the alternative Mandarin, and the dry_run tip adds practical usage advice.

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 and readOnlyHint=false, so the description correctly aligns with them and adds extra value: it warns the effect is irreversible and that data cannot be recovered through the API. It also explains how the dry-run preview surfaces as an error-flagged result, which is useful beyond the annotations.

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

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

The description is front-loaded with the primary action and cardinality, and it keeps the alternative and dry-run guidance compact. The note about typed output schemas is slightly generic and not directly applicable here since this tool has no output schema, but it still explains the preview behavior without bloating the text.

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

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

Given there is no output schema, the description still covers the key operational context: what is deleted, that deletion is irreversible, when to use the batch sibling, and how to preview safely with `dry_run`. Combined with the annotations and fully covered parameters, an agent has enough information to invoke this tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3; the description does not need to restate parameter meanings. It does not add substantial semantics beyond the schema, and the schema's `testParamId` description is sparse, but the tool-level text does not compensate for that specifically.

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: it deletes a single Test Parameter Definition scoped to a Project. It also distinguishes itself from the batch sibling `deleteProjectTestParameterDefinitions` by explicitly stating cardinality, so an agent can tell them apart.

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

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

It explicitly says to use the plural `deleteProjectTestParameterDefinitions` for a full collection or batch, which routes the agent to the correct sibling. It also recommends `dry_run: true` as a safe preview step before actually deleting.

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 this as destructive, but the description adds meaningful context beyond the hint: the operation is irreversible and data 'cannot be recovered through the API.' It also discloses the dry_run preview behavior and the unusual error-flagged preview result, providing behavioral nuance the annotations alone do not 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?

The description is compact yet information-dense. Every sentence earns its place: purpose, cardinality, sibling alternative, irreversibility, and dry_run guidance are all front-loaded and directly useful. There is no filler or redundant restatement of the tool name.

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

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

For a destructive batch operation with no output schema, the description is complete: it explains scope, irreversibility, the safer dry_run flow, and how to interpret the preview result. An agent has all necessary context to call this tool correctly and avoid unintended data loss.

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

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

Schema description coverage is 100%, so the schema already documents `projectId`, `dry_run`, and `requestBody` adequately. The description does not add significant parameter-level meaning beyond reaffirming the dry_run tip. Baseline 3 is appropriate because the schema carries the full weight.

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

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

The description opens with a specific verb and resource: 'Deletes a list of Test Parameter Definitions for the specified Project.' It also clarifies cardinality ('full collection or a batch') and explicitly differentiates from the single-item sibling by naming `deleteProjectTestParameterDefinition`. An agent can immediately understand what this tool does and how it differs from related tools.

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

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

The description provides explicit when-to-use boundaries: batch or full-collection deletion vs. 'For a single item by ID, use `deleteProjectTestParameterDefinition` instead.' It also offers a concrete usage tip (`dry_run: true`) to preview the request. This fully guides an agent on when to choose this tool over 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 mark the tool as destructive and not read-only, but the description adds important context beyond those flags: the effect is irreversible and data cannot be recovered through the API. It also explains the non-obvious dry_run behavior, including that preview results are error-flagged on typed-output tools. This materially helps an agent understand consequences before invoking the tool.

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

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

The description is front-loaded with the core purpose and uses three concise sentences. The irreversibility warning and dry_run tip are each necessary given the destructive nature of the operation. The final sentence is a bit dense with the error-flag caveat, but every clause earns its place and there is 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?

With a fully documented schema and annotations covering the safety profile, the description is largely complete for a destructive tool. It adds irreversibility and a safe-preview workflow, which are critical for correct usage. A minor gap is that it does not explicitly explain how the parameters collectively identify a Test Record, but the schema's parameter descriptions already cover that.

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

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

Schema description coverage is 100%, so the individual parameter descriptions already carry the semantic load. The tool description mostly refers to 'the specified Test Record' without adding new meaning to parameters like iteration or testCaseProjectId. The dry_run tip reinforces the existing dry_run schema description but does not extend it significantly, so the baseline score of 3 is appropriate.

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

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

The description opens with a clear, specific verb and resource: 'Deletes the specified Test Record.' This distinguishes it from sibling tools like deleteTestRun or deleteTestRecordAttachments because the resource is uniquely named. It does not explicitly name a sibling it is not, but the resource itself is unambiguous enough for an agent to identify the operation.

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

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

The intended use is implied by the first sentence: use this when you want to delete a specific Test Record. The dry_run tip provides practical usage guidance for safe execution, but the description does not mention when to prefer this tool over alternatives or any exclusion criteria. This is implied usage rather than explicit routing.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false; the description adds value by stating irreversibility ('cannot be recovered through the API') and explaining the dry_run preview behavior. It does not contradict any annotation. It could have mentioned behavior on missing attachments, but the annotation-plus-description combination is strong.

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?

Each sentence earns its place: operation, cardinality/alternative, irreversibility, and dry_run guidance. The final sentence about typed output schemas is slightly generic and less relevant because this tool has no output schema, but the rest is tight and front-loaded.

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

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

For a destructive single-item delete with no output schema, the description covers what it does, when to use the plural alternative, irreversibility, and how to preview safely. All required parameters are documented in the schema. The missing response-shape details are acceptable given the absence of an output schema and the relative simplicity of the operation.

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

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

Schema description coverage is 100%, so all seven parameters are already documented in detail, including `dry_run` and the nuanced `testCaseProjectId`. The description adds no parameter-level semantics beyond the single-item cardinality, which is appropriate but not an extra contribution.

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

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

The description opens with a specific verb and resource: 'Deletes the specified Test Record Attachment.' It also clarifies cardinality ('targets a single item by ID') and explicitly names the plural sibling `deleteTestRecordAttachments` for batch operations, so an agent can disambiguate without inspecting other tools.

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

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

It gives explicit when-to-use guidance: use this tool for a single targeted attachment, and use `deleteTestRecordAttachments` for the full collection or a batch. The `dry_run: true` tip also provides a safe invocation path before committing to an irreversible operation.

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 signal destructiveHint and readOnlyHint=false; the description adds the crucial detail that the operation is irreversible and cannot be undone through the API. It also explains the dry_run preview behavior and how to interpret error-flagged preview results, which is valuable context beyond the structured annotations.

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

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

The description is organized with the core action and scope first, followed by the alternative tool and important safety/dry-run notes. It is slightly verbose due to the detailed preview explanation, but every sentence carries useful information and the structure supports quick scanning.

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

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

For a destructive tool with rich schema coverage and annotations, the description covers cardinality, the singular alternative, irreversibility, and dry-run preview. No output schema exists, but the absence is not a major gap here since the tool's operation and safeguards are well described.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's dry_run tip is procedural usage guidance rather than new parameter-level semantics; it does not meaningfully enhance understanding of parameters like projectId, requestBody, or iteration beyond what the schema already documents.

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: 'Deletes a list of Test Record Attachments.' It also clarifies cardinality ('full collection or a batch') and explicitly distinguishes itself from the singular sibling tool, deleteTestRecordAttachment. An agent can immediately tell which operation this is and how it differs from related tools.

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

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

The tool explicitly says to use deleteTestRecordAttachment for a single item by ID, and implies this tool for full-collection or batch deletions. This provides a clear when-to-use rule and names the relevant alternative, leaving no ambiguity about selection between the two 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 mark destructiveHint=true and readOnly=false, and the description builds on that by stating the effect is irreversible and that removed/overwritten data cannot be recovered via the API. It also discloses the dry_run preview behavior and how to interpret error-flagged preview output, adding valuable context beyond the annotations.

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

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

Three sentences with the primary action first, followed by an irreversibility warning and a dry_run tip. The final sentence is somewhat long and contains a general caveat that may be less relevant since this tool has no typed output schema, but it is still useful guidance.

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

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

Given 100% schema coverage, no output schema, and annotations covering the safety profile, the description is largely complete. It adds the irreversibility warning and preview guidance, but it does not explicitly distinguish itself from the nearby deleteTestRecordTestParameters sibling, which would be helpful in this large sibling set.

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

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

Schema description coverage is 100%, so the schema already documents all seven parameters including dry_run. The description's dry_run tip largely restates what the schema's dry_run description already explains, adding little new parameter-level meaning. Baseline 3 is appropriate since the schema carries the load.

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

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

The description opens with 'Deletes the specified Test Parameter for the specified Test Record' — a specific verb and resource. It clearly identifies the singular object of the deletion, though it never names sibling tools like deleteTestRecordTestParameters or deleteTestRunTestParameter to draw an explicit 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?

The description gives no when-to-use advice or exclusion criteria relative to sibling tools. The only usage guidance is the dry_run tip, which is a how-to tip rather than a selection guide. Usage context is implied from the tool's name and parameter set rather than explicitly stated.

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

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

Annotations already declare `destructiveHint: true` and `idempotentHint: true`, but the description adds crucial context: it emphasizes the irreversible nature of the operation and explains how the dry_run preview behaves (returns an error-flagged result that should still be read). This goes beyond the annotations and fully discloses the behavioral traits.

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

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

The description is well-structured and front-loaded: it starts with the core purpose, then clarifies cardinality, then the irreversible effect, and finally the dry_run tip. Each sentence earns its place, and the most critical information appears first. No wasted words.

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

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

For a destructive single-item delete operation with annotations covering the destructive and idempotent hints, the description fully covers what an agent needs: the scope, the irreversibility, the batch alternative, and the safe preview mechanism. No output schema exists, but that is not a gap here since the description adequately conveys the operational context.

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

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

Schema description coverage is 100%, so the schema already documents all parameters in detail. The description adds a useful tip about `dry_run` but doesn't provide additional parameter semantics beyond what the schema offers. This meets the baseline of 3 for full schema coverage.

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

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

The description states the exact action ('Deletes the specified Test Run') with a specific resource, clearly distinguishing it from the batch variant. It explicitly names the sibling tool (`deleteTestRuns`) for batch operations, leaving no ambiguity about what this tool does.

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

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

It provides explicit guidance: 'For the full collection or a batch, use `deleteTestRuns` instead.' This directly tells the agent when to choose the alternative. It also advises using `dry_run: true` to preview the request, which is a clear usage recommendation.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, and the description reinforces the irreversibility ('irreversible — data removed or overwritten by this call cannot be recovered through the API'). It also discloses the dry_run preview behavior and how to interpret the error-flagged preview result, which is valuable context beyond the annotations. It doesn't detail auth requirements or rate limits, but the destructive nature and preview behavior are well covered.

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

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

The description is compact and front-loaded: the core action and cardinality come first, followed by the sibling distinction, the irreversibility warning, and the dry_run tip. Every sentence earns its place; no filler or repetition.

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

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

For a single-item delete with a typed schema and annotations covering destructive/idempotent behavior, the description is nearly complete. It explains the batch alternative, the irreversible effect, and the dry_run preview. The only minor gap is that it doesn't explicitly state what a successful response looks like, but there is no output schema and the tool's behavior is simple enough that this is not a significant omission.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters thoroughly. The description adds the dry_run preview semantics and the note that attachmentId comes from list/get-attachment calls, but most parameter meaning is already in the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Deletes') and resource ('the specified Test Run Attachment'), and explicitly distinguishes it from the batch sibling `deleteTestRunAttachments`. It also clarifies cardinality ('targets a single item by ID'), which removes any ambiguity about scope.

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

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

The description explicitly says when to use this tool vs the alternative: 'For the full collection or a batch, use `deleteTestRunAttachments` instead.' It also provides a concrete usage tip: set `dry_run: true` first to preview the request without changing anything. This is clear, actionable guidance.

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

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

Annotations already flag destructiveHint=true and idempotentHint=true, and the description goes further by warning that the effect is irreversible and data cannot be recovered through the API. It also explains how the dry-run preview is surfaced (error-flagged but readable text), which an agent would not otherwise know.

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?

Purpose, cardinality, and routing are front-loaded in the first two sentences with no waste. The tail sentence about typed output schemas is useful context but reads as generic boilerplate that may not apply to this tool, which has no output schema, making it slightly less tight than ideal.

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?

Covers the essential decisions: which tool to pick, the destructive and irreversible nature, and how to preview safely. It does not specify how to encode 'full collection' vs 'batch' in the requestBody, and there is no output schema to describe success/error returns, though annotations and the 100%-documented schema cover most remaining ground.

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

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

Schema description coverage is 100%, and the schema itself fully documents projectId, testRunId, requestBody, and dry_run (including redaction and byte-length summary). The description's dry_run tip largely restates the schema, so it adds little parameter-level meaning beyond the baseline.

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

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

States a specific verb and resource — 'Deletes a list of Test Run Attachments' — and clarifies cardinality (full collection or batch). It also names the singular sibling deleteTestRunAttachment, so an agent can distinguish them without opening the schema.

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

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

Explicitly routes single-item deletions to deleteTestRunAttachment, and describes cardinality to signal when this batch/collection tool is appropriate. The dry_run tip adds a concrete recommended workflow for safe previewing.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, but the description adds the explicit 'Effect: irreversible — data removed or overwritten by this call cannot be recovered through the API' and explains the dry_run preview behavior, including how to interpret error-flagged results. This goes beyond the structured annotations without contradicting 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?

The description is four sentences, each with distinct purpose: what it does, cardinality, irreversibility, and dry-run tip. It is front-loaded with the primary action and avoids fluff. Every sentence earns its place.

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

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

For a destructive, batch-delete operation with no output schema, the description covers the essential context: action, scope, irreversibility, and a safe preview mechanism. The schema and annotations cover parameters and safety profile, leaving no critical gap for an agent to call 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 100%, so the baseline is 3. The description does not add meaning beyond the schema; it only references dry_run without detailing its semantics, which the schema already covers. The requestBody structure is fully described in the schema, so no extra value 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 opens with 'Deletes a list of Test Runs', giving a specific verb and resource. It explicitly differentiates from the sibling `deleteTestRun` by noting the cardinality difference ('targets the full collection or a batch' vs 'single item by ID'), so an agent can immediately distinguish the tools.

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

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

The description states exactly when to use this tool versus the singular alternative: 'For a single item by ID, use `deleteTestRun` instead.' It also provides a concrete safety tip (dry_run first) that guides usage. No ambiguity remains about scope or alternative selection.

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

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

Beyond the annotations, the description discloses that the deletion is irreversible and cannot be recovered through the API. It also explains the dry-run preview behavior, including how error-flagged results should be interpreted, which adds valuable behavioral context not present in the annotations.

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

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

The description is compact and front-loaded with the core purpose, followed by cardinality, alternative routing, irreversibility, and a practical tip. Every sentence serves a distinct purpose without padding or repetition.

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

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

The description covers the essential selection, safety, and preview behavior, and the schema/annotations already handle parameter details and mutation flags. It is slightly less complete because it does not describe what a successful deletion returns or confirm expected response behavior, though this is not critical for correct invocation.

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

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

Schema description coverage is 100%, so the parameters are already fully documented in the schema. The description adds only the dry-run tip, which is useful but does not materially expand the meaning of individual parameters beyond what the schema provides.

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

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

The description uses a specific verb and resource ('Deletes the specified Test Parameter for the specified Test Run') and explicitly states single-item cardinality. It distinguishes itself from the sibling batch operation `deleteTestRunTestParameters`, so an agent can immediately tell which 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?

It gives explicit selection guidance: use this tool for a single item by ID, and use `deleteTestRunTestParameters` for the full collection or a batch. It also recommends `dry_run: true` as a safe preview step, adding actionable context for when and how to invoke the tool.

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

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

Goes well beyond the destructiveHint annotation by explicitly stating that data removed is unrecoverable through the API. It also discloses the dry_run preview behavior and the unusual error-flagged result for typed-output tools, which an agent could not reliably infer from annotations or schema alone.

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 front-loaded sentences: the action comes first, followed by irreversibility, the dry_run tip, and the preview-flag caveat. There is no filler or redundant restatement of schema fields.

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

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

Given no output schema, simple primitive parameters, and a destructive annotation set, the description covers purpose, safety, and unusual dry_run behavior. An agent has enough information to invoke the tool correctly and interpret the non-standard preview result.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters in sufficient detail. The description adds a useful dry_run tip but does not materially extend parameter semantics beyond what the schema provides.

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

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

Clearly identifies the action ('Deletes') and the resource ('Test Parameter Definition for the specified Test Run'), matching the method name and making the core purpose obvious. It does not explicitly contrast with sibling tools like deleteTestRunTestParameter, so differentiation is carried by the resource phrasing rather than an explicit comparison.

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 irreversible-effect warning and the suggestion to set dry_run first provide operational context and imply a safe usage pattern for a destructive operation. However, there is no explicit statement of when this tool should be preferred over related test-parameter tools or when not to use it.

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

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

Beyond the annotations (destructiveHint=true, readOnlyHint=false), the description adds critical context: the operation is irreversible and data cannot be recovered through the API. It also discloses the dry_run preview behavior, including the nuance that preview results are error-flagged. This goes well beyond what annotations provide, fully disclosing the destructive and non-idempotent nature despite the idempotentHint annotation (which is about repeatability, not non-destructiveness). No contradiction with annotations.

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

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

The description is concise and front-loaded with the primary purpose, followed by cardinality, alternative routing, and a practical tip. Each sentence adds value, though the dry_run tip is slightly verbose. Overall, it is well-structured and efficient.

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

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

The description covers essential operational context: scope (list vs single), irreversibility, and a safe preview mechanism. Given the nested requestBody schema is fully documented and there is no output schema, the description provides sufficient context for an agent to invoke the tool correctly. A small gap is the lack of explicit mention of required parameters, but these are clear from the schema.

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

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

The input schema already provides 100% coverage with descriptions for all parameters, including dry_run, projectId, testRunId, and requestBody. The description adds minimal extra semantics beyond what the schema provides, such as the cardinality note. Since the schema carries the parameter meaning effectively, a baseline score of 3 is appropriate.

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

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

The description clearly states the verb 'Deletes' and the resource 'a list of Test Parameters for the specified Test Run'. It explicitly differentiates from the singular variant `deleteTestRunTestParameter`, making the scope unambiguous. An agent can immediately understand what this tool does and how it differs from its sibling.

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

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

The description provides explicit guidance on when to use this tool versus the alternative: 'For a single item by ID, use `deleteTestRunTestParameter` instead.' This directly addresses selection criteria, leaving no ambiguity about which tool to choose based on the cardinality of the operation.

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 this as destructive and non-read-only, but the description adds specific behavioral detail: changes are irreversible and cannot be recovered via API. It also explains the dry_run preview behavior, including how the error-flagged result should be interpreted, which is not present in annotations.

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

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

The description is front-loaded with the action and cardinality, then offers the alternative, effect, and a practical tip. The dry_run explanation is slightly verbose but every sentence contributes useful information; 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 single-item delete tool with no output schema, the description covers the key operational context: scope (single item), irreversibility, batch alternative, and dry_run usage. It could mention error conditions or permissions, but given the annotations and schema, this is sufficient for correct invocation.

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

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

All four parameters are fully described in the input schema (100% coverage), so the baseline is 3. The description's cardinality note ('targets a single item by ID') adds minimal parameter-specific meaning, and the dry_run tip is more usage guidance than parameter semantics.

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

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

The description opens with 'Deletes the specified Test Step' – a specific verb and resource. It then clarifies cardinality ('targets a single item by ID') and explicitly contrasts with the batch sibling `deleteTestSteps`, so an agent can easily distinguish this tool from 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 directly instructs when to use the batch alternative: 'For the full collection or a batch, use `deleteTestSteps` instead.' It also advises a safe invocation pattern with `dry_run: true`, providing clear conditional guidance.

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

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

The description adds meaningful context beyond the annotations: it warns that the operation is irreversible and cannot be recovered through the API, explains the dry_run preview behavior, and clarifies how the preview appears as an error-flagged result. This does not contradict the annotations.

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

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

The description is front-loaded with the core action and cardinality, then provides the batch alternative, irreversibility warning, and dry-run tip. It is somewhat dense but each sentence earns its place; only the final explanation about typed output schemas could be trimmed without losing crucial guidance.

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 delete operation, the description covers the key aspects: what is deleted, the batch alternative, irreversibility, and a safe preview path. Since there is no output schema, the normal success response is not described, but that is a minor gap given the strength of the other guidance.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters. The description adds some useful framing around dry_run and the single-item-by-ID cardinality, but it does not otherwise add new meaning beyond the structured parameter descriptions.

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

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

The description opens with a clear verb and resource: 'Deletes the specified Test Step Result Attachment.' It also states cardinality as a single item by ID and explicitly contrasts itself with the batch sibling tool, making selection unambiguous.

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

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

It explicitly names the alternative tool for full-collection or batch operations and explains when to prefer that sibling. The dry_run tip also gives actionable guidance for safe trial usage before committing to the 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?

Annotations already indicate destructiveHint=true and readOnlyHint=false, but the description goes further by stating the effect is irreversible and that data cannot be recovered through the API. It also discloses dry_run preview behavior and warns that the preview may be returned as an error-flagged result, which is important for interpreting tool output.

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 the primary action and each sentence mostly earns its place. The final sentence about typed output schemas is a generic caveat that does not clearly apply here since this tool has no output schema, making it slightly extraneous.

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 batch operation, the description covers what is deleted, when to use the singular alternative, irreversibility, and a safe preview path. Combined with the fully described schema and relevant annotations, an agent has enough information to invoke the tool correctly without critical gaps.

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

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

Schema description coverage is 100%, so the schema fully documents all eight parameters and the baseline is 3. The description adds only a general cardinality note ('full collection or a batch') and a dry_run reminder; it does not meaningfully elaborate on individual parameters, but it does not need to because the schema is already detailed.

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

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

The description opens with 'Deletes a list of Test Step Result Attachments,' a clear verb, object, and cardinality. It further distinguishes itself from the sibling tool deleteTestStepResultAttachment by explicitly stating that the singular variant is for a single item by ID.

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 explicit routing guidance: use deleteTestStepResultAttachment for a single item, and this tool for 'the full collection or a batch.' It also provides a concrete safe-usage tip: set dry_run: true to preview the request without changing anything.

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 annotations (destructiveHint=true, readOnlyHint=false), the description discloses that the effect is irreversible and unrecoverable through the API. It also surfaces the dry_run preview behavior and the non-obvious quirk that previews may appear as error-flagged results, which an agent would otherwise misinterpret. No contradiction with annotations; idempotentHint=true is consistent with a delete operation.

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

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

The description is front-loaded with the core purpose, and the labeled sections (Cardinality:, Effect:, Tip:) make it scannable. Every sentence earns its place, though the final sentence about typed output schemas is lengthy and partially inapplicable since this tool has no output schema — it could be tightened.

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 batch-delete tool with nested requestBody and safety considerations, the description covers purpose, scope, sibling routing, irreversibility, and the dry_run safety mechanism. The schema covers all parameter semantics, and no output schema exists to explain. An agent has everything needed to call this tool safely and correctly.

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

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

Schema description coverage is 100%, so all four parameters (dry_run, projectId, workItemId, requestBody) are already documented in the schema. The description's mention of dry_run in the Tip reinforces usage but does not add meaning beyond the schema's own explanation, so the baseline of 3 applies.

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

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

The first sentence, 'Deletes a list of Test Steps,' states a specific verb, resource, and cardinality. The Cardinality note ('full collection or a batch') sharpens the scope, and the explicit pointer to deleteTestStep for single items distinguishes this tool from its closest sibling without requiring schema inspection.

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

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

The description explicitly names the alternative ('use `deleteTestStep` instead') and the exact condition that selects it ('For a single item by ID'). The Cardinality line further clarifies when this tool applies (full collection or batch), leaving no ambiguity about tool selection.

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

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

Beyond the annotations, the description discloses that the operation is irreversible, that data cannot be recovered through the API, and exactly how dry_run behaves, including that the preview may surface as an error-flagged result and that the text content should still be read. This is substantial behavioral context that annotations alone do not 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 front-loaded with the core purpose, then the irreversible effect, then the dry-run tip. The final sentence about error-flagged previews is slightly verbose and may not apply directly since this tool has no typed output schema, but it serves a real purpose in preventing confusion about dry-run results.

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

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

For a destructive mutation tool with no output schema, the description plus parameter schema cover what the operation does, its irreversibility, how to obtain the required IDs, and how to safely preview the request. The dry-run guidance is especially valuable for a delete operation and makes the tool safe to invoke correctly.

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

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

Schema description coverage is 100%, so the baseline is 3; each parameter already has a clear explanation. The description adds practical value by recommending dry_run: true and explaining what the preview does, going beyond the schema's dry_run description with usage-oriented guidance.

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

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

The description opens with a specific verb+resource: 'Deletes the specified Work Item Attachment.' It clearly distinguishes this tool from siblings like getWorkItemAttachment, postWorkItemAttachments, and patchWorkItemAttachment by naming the exact delete action against a precise resource type.

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

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

The description makes the deletion intent and destructive consequence explicit, and it gives concrete operational guidance: set dry_run: true first to preview without changing anything. It does not explicitly name sibling alternatives or state when not to use the tool, but the delete semantics are clear enough that an agent would not confuse this with get/post/patch operations.

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 annotations (destructiveHint=true), the description discloses irreversibility ('data removed or overwritten... cannot be recovered through the API') and explains the dry_run preview behavior, including the error-flagged result nuance. This adds meaningful behavioral context not covered by annotations.

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

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

The description is front-loaded with purpose and scope, then adds the alternative and effect. The tip about dry_run and the error-flagged result is useful but includes a somewhat technical implementation note that slightly extends beyond core selection guidance. Still, it is compact and each sentence earns its place.

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

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

For a destructive, irreversible operation, the description covers scope, effect, alternative, and a preview mechanism. With no output schema, it explains what the dry_run preview returns. It lacks explicit mention of prerequisites (e.g., authentication), but these are implied by the API context. Overall, it is complete enough for an agent to call it correctly.

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

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

Schema description coverage is 100%—all three parameters (projectId, requestBody, dry_run) already have detailed descriptions in the input schema. The description adds some extra context (e.g., projectId case-sensitivity, dry_run purpose), but it mostly reinforces what the schema states, so the baseline 3 is appropriate.

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

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

States the exact operation (deletes a list of Work Items) and immediately scopes it to one project, distinguishing it from the sibling deleteAllWorkItems. The verb and resource are specific, leaving no ambiguity about what the tool does.

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

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

Explicitly tells the agent when to use this tool vs. the alternative: 'To act across all projects, use deleteAllWorkItems instead.' It also provides a concrete safety tip (use dry_run) that guides invocation, fulfilling the when/alternatives requirement clearly.

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 the description meaningfully extends this with 'irreversible — data removed or overwritten by this call cannot be recovered through the API,' conveying data-loss consequence beyond the boolean hint. It also discloses a non-obvious behavioral quirk: dry_run previews are surfaced as error-flagged results, which the agent must interpret correctly. No contradiction with annotations.

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

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

Three sentences, front-loaded with the core purpose before the warning and tip. Each sentence earns its place, though the final dry_run explanation is somewhat verbose and partially overlaps with the schema's dry_run parameter description; the error-flag quirk it adds is genuinely new.

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

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

With no output schema and a nested requestBody containing a large type enum, the description covers purpose, risk, and a safe preview path, while the schema handles parameter details. It omits what a successful response looks like and does not explicitly distinguish this relationship-slot delete from sibling tools that delete individual link entries (e.g., deleteLinkedWorkItems).

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

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

Schema description coverage is 100%, so the schema fully documents all five parameters, including nuanced clarifications (projectId URL segment and case-sensitivity, WI-123 vs combined path, relationship slot vs link-entry ID, and dry_run redaction behavior). The tool description adds no parameter-specific meaning, which is acceptable under the baseline-3 rule since the schema carries the burden.

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 the verb and resource precisely: 'Deletes a list of Work Item Relationships.' The term 'list' signals batch scope, which loosely distinguishes it from single-relationship deletes, but it does not explicitly differentiate from sibling relationship tools (e.g., deleteLinkedWorkItems, patchWorkItemRelationships), leaving that distinction to the schema's parameter descriptions.

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 explicit when-to-use vs alternatives guidance and names no siblings or exclusion conditions. It does imply a safe usage workflow by recommending `dry_run: true` before executing and warning that deletion is irreversible, which is meaningful operational guidance but not alternative-selection guidance.

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

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

The annotations already mark this as destructive and non-read-only, but the description adds important behavioral context: the effect is irreversible and data cannot be recovered through the API. It also explains how the dry_run preview is surfaced as an error-flagged result, which is non-obvious behavior beyond the schema.

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

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

Every sentence earns its place: purpose, cardinality, sibling distinction, irreversibility, and the dry-run tip. The most important facts are front-loaded, and there is no filler or repetition of 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?

For a single-item deletion with three required ID parameters, the description fully covers what an agent needs: the target, the cardinality, the irreversible nature, the safer alternative, and how to preview the request. There is no output schema, so explaining the dry_run error-flag behavior is particularly valuable.

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

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

The input schema already describes all four parameters with 100% coverage, so the baseline is 3. The description does not add much parameter-level meaning beyond the schema; it reinforces that workRecordId identifies a single record, but the schema already conveys this.

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 begins with a specific verb and resource ('Deletes the specified Work Record') and immediately clarifies cardinality ('targets a single item by ID'). It explicitly distinguishes itself from the batch sibling deleteWorkRecords, so an agent can select the correct tool without inspecting other definitions.

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

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

The description explicitly states when to use this tool (single item by ID) versus an alternative (deleteWorkRecords for full collection or batch). It also gives a concrete pre-flight instruction—use dry_run: true first—which is actionable guidance for a destructive operation.

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