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

The 'WRITE' warning merely restates the annotation readOnlyHint=false and adds no detail about what modifications occur, whether the operation is reversible, or whether it can cause side effects. Not enough behavioral context is disclosed beyond the structured 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 brief but under-specified. The awkward phrase 'action on a action' wastes the few words used, and the 'WRITE' sentence is the only useful part. It reads more like an incomplete stub than a concise explanation.

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 output schema exists, return values may be self-documenting, but the description still fails to clarify what 'action' means, what the 'body' should contain, or how the download client is selected. The tool is too ambiguous to use confidently without external documentation.

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

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

Schema coverage is 0%, so the description must compensate. It only clarifies that 'name' selects an action, while the 'body' object is completely unexplained. The freeform body parameter likely carries important action-specific data, but users receive no 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 reads 'Run an action on a action', which is tautological and confusing—it doesn't explain what the action does or that it applies to download clients beyond the tool name. It fails to clearly distinguish this from sibling action tools like radarr_action_indexer or radarr_action_notification.

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

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

No guidance is given on when to use this tool versus alternatives. The only hint is that 'name selects the action', but there is no explanation of what actions are available, what context they apply to, or any prerequisites/exclusions.

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

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

The description voluntarily adds 'WRITE: this modifies your Radarr instance,' which is helpful and aligns with readOnlyHint=false. It also notes that 'name selects the action,' but it does not elaborate on what actions exist or what side effects they may have. Given the presence of annotations, this is only a modest contribution beyond the structured metadata.

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

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

The description is extremely short, but brevity here is under-specification rather than effective conciseness. The phrasing 'Run an action on a action' is awkward and unpolished, and the sentence does not convey essential details in a structured way.

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 having an output schema and numerous siblings, the description leaves the agent entirely in the dark about valid actions, request body shape, and response expectations. It is not sufficient for correct invocation of this action-based tool.

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

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

The description gives minimal meaning to 'name' by stating it selects the action, but it completely ignores the 'body' parameter, which is an object that likely carries action-specific payload. With schema description coverage at 0%, the description fails to compensate for the lack of parameter documentation 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 'Run an action on a action' is tautological and grammatically confusing. It does not state what the tool does with respect to import lists, nor does it differentiate from sibling action tools. The only hint is the tool name itself, which the description fails to leverage.

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

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

No guidance is given on when to use this tool versus alternatives like radarr_action_indexer or radarr_action_downloadclient. No prerequisites, scenarios, or exclusions are mentioned, leaving the agent without context for 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?

While annotations already indicate this is a write operation (readOnlyHint: false), the description only adds a redundant 'WRITE' warning. It does not disclose what type of actions are available, whether changes are reversible, or any side effects beyond modifying the instance.

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

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

The description is short but poorly worded ('on a action' is grammatically incorrect) and under-specified. It lacks essential details, so the brevity is a liability, not a strength.

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 severely incomplete for a tool with a required name parameter, an optional nested body, and no parameter descriptions. It doesn't explain how to construct the body or what output to expect, leaving an agent with insufficient information 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 coverage is 0%, so the description must fully explain parameters. It only states that 'name selects the action', giving minimal meaning to name, but does not list valid values or explain the 'body' object at all. The nested body parameter is completely undocumented.

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

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

The description 'Run an action on a action' is essentially a tautology that restates the tool name without specifying what the action does, what resource it affects, or how it differs from sibling action tools. It fails to mention 'indexer' or provide a clear verb-resource pair.

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

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

No usage guidance is provided. There is no mention of when to use this tool versus other action tools (e.g., radarr_action_downloadclient) or how to discover valid action names. The description does not state expected input or prerequisites.

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

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

Annotations already indicate readOnly=false, and the description adds a plain-language 'WRITE: this modifies your Radarr instance' which reassures the write nature. It also reveals that the 'name' parameter selects the action, but it does not disclose side effects, authentication needs, or allowed actions, which limits transparency.

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

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

The description is short and avoids fluff, but the first sentence is awkwardly phrased ('on a action') and could be clearer. The 'WRITE' hint is useful but placed at the end, reducing front-loading effectiveness.

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

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

The tool appears to be a generic action runner for a metadata resource, but the description fails to explain what metadata is, which actions are available, or what the 'body' parameter contains. With output schema present, return values aren't needed, but the operation semantics remain obscure, making the tool difficult 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?

With 0% schema description coverage, the description must compensate for parameter explanations. It clarifies that 'name' selects the action, but the 'body' parameter is entirely unexplained, and no valid action names are enumerated. This leaves the agent guessing about the most critical input.

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

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

The description 'Run an action on a action' is tautological and grammatically incorrect, restating the tool name without clarifying what 'metadata' is or what the action accomplishes. The only useful clue is 'name selects the action,' which hints at the parameter but does not define the tool's purpose.

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

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

No usage guidance is provided. The description does not state when to use this tool versus alternatives, nor does it mention any prerequisites, exclusions, or specific scenarios. It is purely a generic statement with no actionable context.

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

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

Annotations already declare readOnlyHint=false. The description adds an explicit 'WRITE: this modifies your Radarr instance' warning, which is useful but does not elaborate on side effects, reversibility, or required permissions. It adds minimal 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 very short, but the first sentence is grammatically awkward and unclear ('on a action'). While concise, it sacrifices clarity and does not front-load useful information effectively.

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

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

The tool has a generic action-executor pattern with no enums on name and an opaque body object. The description does not provide valid action values, explain body usage, or tie the tool to notification-specific actions. Output schema exists but does not compensate for missing 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 0%, so the description must compensate. It only clarifies that 'name selects the action' for the name parameter, leaving the body object completely unexplained. This is insufficient for a parameter with arbitrary additional properties.

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 'Run an action on a action' is vague and tautological, failing to identify the target resource (notifications). It says 'name selects the action' but does not clarify what domain the action operates on, making it hard to distinguish from siblings like radarr_action_downloadclient.

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

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

No guidance is provided on when to use this tool versus alternatives, nor any exclusions or prerequisites. The description offers no contextual hints for 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?

The description says 'WRITE: this modifies your Radarr instance', which aligns with the annotation readOnlyHint=false but adds little beyond what annotations already reveal. It does not disclose specific side effects, prerequisites, potential failures, or what happens to existing data. The annotations already establish the safety profile (write, non-destructive), so this description offers minimal additional 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 extremely concise: two short sentences that are front-loaded with the primary action and immediately follow with a clear write warning. Every word earns its place, and it avoids unnecessary elaboration or repetition of the tool name.

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

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

Despite having an output schema and annotations, the description is incomplete for correct invocation. The body parameter is completely undocumented—no mention of required properties like tmdbId, qualityProfileId, or rootFolder. The tool could be considered usable if the agent already knows Radarr's MovieResource structure, but the description alone does not provide enough to construct a valid request, making it a clear 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?

With schema description coverage at 0%, the description must explain the 'body' parameter. It only says 'body is a MovieResource', which gives a type hint but not the required fields, structure, or constraints of a MovieResource. This is insufficient for an agent to construct a valid request, as the schema itself is opaque (additionalProperties true, no property descriptions).

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

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

The description clearly states the action: 'Add a movie to Radarr', with a specific resource ('movie') and verb ('add'). It distinguishes from sibling tools by its explicit focus on adding movies, while other tools handle different resources like download clients or indexers. The parenthetical 'body is a MovieResource' further clarifies the nature of 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 description implies the tool is for adding movies to the Radarr instance, but it provides no explicit guidance on when to use it versus alternatives (e.g., radarr_import_movie or radarr_update_movie). There are no exclusions or alternative suggestions, so usage context is only implied by the tool name and basic 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?

The description repeats the annotation-inferred write behavior ('WRITE: this modifies your Radarr instance') without adding new operational detail such as permission requirements, duplicate handling, or response behavior. Given readOnlyHint=false is already present, this adds no new value.

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

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

The description is brief and front-loads the purpose in the first sentence. The second sentence is somewhat redundant given the annotations, but generally efficient and well-structured.

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?

While the high-level purpose is clear, the tool's input is an opaque body array with no item definition. The description does not mention the format of entries, any limits, or preconditions, making it insufficient for correct invocation despite an output schema being present.

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 a single 'body' array with empty item schema, and the description provides no details about the required structure of exclusion objects. At 0% schema coverage, the description fails to compensate, leaving the agent without necessary 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 clearly states the tool creates multiple import list exclusions, using a specific verb and resource. However, it does not explicitly distinguish from the sibling radarr_create_exclusions, relying on the 'bulk' in the name and the word 'multiple'.

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

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

No guidance is provided on when to use this tool versus alternatives like radarr_create_exclusions or radarr_delete_exclusions. The only context is a write warning, which conveys the mutation nature but not selection criteria.

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

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

The annotation destructiveHint=true already communicates the destructive nature, and the description largely restates this with 'DESTRUCTIVE: this deletes data.' No additional behavioral traits are disclosed, such as irreversibility, required permissions, or side effects beyond what annotations cover.

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

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

The description is very short and front-loaded with the main action. The second sentence about destructiveness is somewhat redundant with annotations but serves as a clear warning; however, it adds little for an AI agent and could be considered fluff.

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

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

For a bulk delete operation, the description lacks essential context about the request body, such as expected fields or format. Although an output schema exists, the input semantics remain unexplained, making the tool difficult to use correctly without additional documentation.

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 one generic 'body' object with no description, and the schema description coverage is 0%. The description does not mention what the body should contain (e.g., a list of blocklist IDs), leaving the agent without sufficient information to construct a valid request.

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 ('Bulk delete') and resource ('blocklisted releases'), clearly indicating the action and target. The word 'bulk' distinguishes it from the sibling tool radarr_delete_blocklist, which suggests a single-entry deletion.

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

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

No guidance is provided on when to use this tool versus alternatives such as radarr_delete_blocklist for a single entry. The description does not mention any conditions, exclusions, or context where this tool should or 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 declare destructiveHint=true; the description adds only a redundant warning ('DESTRUCTIVE: this deletes data') without additional context such as irreversibility, impact on associated items, or required permissions. Thus it provides little 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 two short sentences and directly states the purpose and the destructive warning. It is appropriately sized without unnecessary 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?

Although the tool is a bulk delete operation, the description fails to specify the request body format, the nature of 'bulk' (e.g., list of IDs), or any prerequisites. The output schema is present but not described. This makes it inadequate for an agent 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?

The schema contains one 'body' parameter with 0% coverage; the description provides no information about the expected body structure (e.g., array of IDs). The additionalProperties:true object leaves the agent without any guidance on how to construct a valid request.

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 (bulk delete) and the resource (custom formats), using a specific verb. It distinguishes from the sibling radarr_delete_customformat by indicating a bulk 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 description does not explicitly state when to use this tool vs. alternatives. The 'bulk' qualifier implies it is for deleting multiple custom formats, but no direct comparison to radarr_delete_customformat or other bulk operations is provided.

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

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

The description's 'DESTRUCTIVE' warning merely echoes the destructiveHint=true annotation, adding no new information such as what data is deleted, irreversibility, or side effects. Since annotations already cover the destructive nature, the description provides no additional behavioral transparency.

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

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

The description is highly concise, using two short sentences with no redundancies. While the destructive warning repeats the annotation, it is purposeful for emphasis. No wasted words, but it could have included more critical information without becoming verbose.

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

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

For a destructive bulk delete tool, the description lacks essential context about what payload is expected (e.g., list of IDs) and the consequences. The schema provides no guidance, and there is no explanation of return values or validation, making it only partially complete.

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

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

Schema description coverage is 0%, and the description says nothing about the 'body' parameter. The schema only shows an open-ended object with additionalProperties, leaving the agent without any hint about required fields (e.g., IDs) or the request structure.

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

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

The description states the action clearly: 'Bulk delete downloadclient' with a specific verb and resource. It implies bulk vs. individual deletion, distinguishing it from siblings like radarr_delete_downloadclient, though it does not explicitly mention alternatives.

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

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

No guidance is provided on when to use this tool vs. alternatives (e.g., individual delete, bulk update). The destructive warning is a caution, not a usage guideline, and there are no prerequisites or contexts described.

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. The description adds a human-readable warning and specifies the target resource (import list exclusions), but it adds no new context beyond the annotation, such as irreversibility or scope of deletion.

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

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

The description is short and front-loaded with the purpose, but the second sentence ('DESTRUCTIVE: this deletes data.') is largely redundant with the destructiveHint annotation. It is concise but not every sentence adds unique 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?

Given the tool's complexity (bulk delete) and the presence of an output schema, the description is insufficient. It does not explain the request body structure, how multiple exclusions are identified, or any response behavior. The annotations cover safety but not operational details.

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

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

The schema has one parameter ('body') with no description and 0% coverage. The description does not mention the body parameter or explain how to specify which exclusions to delete. With such low schema coverage, the description must compensate but fails to provide any parameter 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 clearly states the action ('Bulk delete') and the resource ('import list exclusions'), which is specific and distinguishes it from single-delete or list siblings. The DESTRUCTIVE warning further emphasizes the purpose.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives like radarr_delete_exclusions for single deletions. The word 'bulk' implies multiple items, but there is no direct comparison or exclusions provided.

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

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

The annotations already declare destructiveHint=true and readOnlyHint=false. The description's 'DESTRUCTIVE: this deletes data' merely restates the annotation without adding new behavioral details such as irreversibility, effect on related entities, or required confirmation.

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

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

The description is extremely concise and front-loaded: it states the action in the first sentence and adds a warning in the second. There is no waste.

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?

While the tool's purpose is clear, the absence of parameter clarification and limited behavioral context (beyond annotations) means an agent would struggle to invoke it correctly. It lacks instructions on how to specify which import lists to delete.

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

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

The schema's single 'body' parameter has no description and allows arbitrary properties. The tool description does not explain what the body should contain (e.g., list of import list IDs). With 0% schema description coverage, this is a critical gap.

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

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

The description clearly states the action ('Bulk delete') and the resource ('import lists'), which directly matches the tool name and distinguishes it from singular delete or update operations among siblings.

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., radarr_delete_importlist for single deletion). It simply states the action without 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 annotation destructiveHint=true already declares the destructive nature, and the description merely repeats it with 'DESTRUCTIVE: this deletes data.' No additional context is provided, such as irreversibility, affected resources, or authorization needs.

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 exceptionally concise, using a single sentence and a short warning. It is front-loaded and contains no filler, earning full marks for brevity.

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

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

Despite having an output schema, the description lacks critical usage details: it does not explain how the bulk delete request should be structured, what response to expect, or any edge cases. The input schema is vague, and the description does not compensate for this incompleteness.

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

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

The schema has a single 'body' object parameter with no description and additionalProperties true. The description does not explain what should be placed in 'body' (e.g., list of indexer IDs), leaving the parameter entirely undefined.

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 'Bulk delete indexers' with a clear verb and resource, and the 'DESTRUCTIVE' warning reinforces the tool's purpose. It distinguishes from single-delete tools like radarr_delete_indexer by specifying 'bulk'.

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

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

No guidance is provided on when to use this tool versus alternatives such as radarr_delete_indexer or radarr_bulk_update_indexer. There is no mention of prerequisites, id formats, or how to select multiple indexers, leaving the agent to infer usage.

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

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

The annotation destructiveHint=true already indicates the destructive nature. The description's 'DESTRUCTIVE: this deletes data' adds no new information beyond the annotation, and fails to clarify what exactly is deleted (e.g., database entries vs files) or if confirmation is needed.

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

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

The description is appropriately short and front-loaded, but the second sentence repeats the destructiveHint annotation, making it redundant for an agent and thus not fully earning 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 bulk operation with an opaque body parameter, this description is severely inadequate. It does not explain the request structure, selection criteria, side effects, or any prerequisites, making it impossible for an agent to correctly invoke the tool.

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

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

The input schema has a single generic 'body' object with no property descriptions and 0% schema_description_coverage. The description does not explain what the body should contain, leaving the agent without guidance on how to specify which movies to delete.

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 'Bulk delete movies' uses a specific verb and resource, clearly distinguishing it from 'radarr_delete_movie' (singular) and 'radarr_bulk_delete_moviefile' (files). The purpose is immediately 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?

No guidance is provided on when to use this tool vs alternatives. It does not mention that this is for multiple movies, nor does it reference radarr_delete_movie for single deletions.

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 explicitly warns 'DESTRUCTIVE: this deletes data,' which reinforces the destructiveHint annotation. However, it adds no additional behavioral context such as permanence, required permissions, or recovery options. Since annotations already cover the destructive safety profile, the added value is minimal but not zero.

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

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

The description is extremely concise and front-loaded, with the action stated first. The warning earned its place. It is slightly under-specified for a destructive tool, but as far as structure and efficiency, it is well-formed.

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 bulk operation, the description is incomplete. It does not clarify what 'bulk' means, how to specify which files to delete, or what the request body should look like. Even though an output schema exists, the lack of parameter documentation and usage context leaves significant gaps.

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

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

The schema has a single 'body' parameter with no description and additionalProperties true, and the description provides zero parameter information. With schema description coverage at 0%, the description fails to compensate. The agent has no idea what the body should contain (e.g., list of movie file IDs).

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 'Bulk delete movie files' with a specific verb and resource. The 'bulk' qualifier distinguishes it from the singular 'radarr_delete_moviefile' sibling, 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?

No guidance is provided on when to use this tool versus alternatives. It does not mention the singular delete tool, nor does it explain what 'bulk' implies (e.g., multiple IDs, prerequisites). The agent gets no decision support.

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's 'DESTRUCTIVE: this deletes data' merely restates the destructiveHint annotation without adding new behavioral context. It does not disclose specifics like irreversibility, impact on download client, or any rate limits or authentication requirements. Since annotations already cover destructive behavior, the description adds minimal transparency value.

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

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

The description is exceptionally concise at two short sentences, front-loaded with the core action. However, the second sentence is redundant with the annotations, and the under-specification means it sacrifices essential detail for brevity.

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

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

Given the tool's complexity (5 params, a free-form body object) and destructive nature, the description is insufficiently complete. It lacks any mention of parameter semantics, the output schema, or behavioral caveats, leaving the agent with critical gaps in understanding.

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

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

The schema has 5 parameters with 0% description coverage, and the description provides no explanation of any parameter. Users are left without guidance on what 'body', 'blocklist', 'change_category', 'skip_redownload', or 'remove_from_client' do, making the tool significantly harder to use correctly.

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 ('Bulk delete') and the resource ('download client queue items'), making the tool's purpose immediately obvious. It also distinguishes it from sibling tools like radarr_delete_queue (singular) and radarr_grab_queue_bulk, which serve different actions.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives, such as radarr_delete_queue for single deletions or other bulk delete tools. While the 'DESTRUCTIVE' warning implies caution, it does not articulate scenarios for use or prerequisites.

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

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

Annotations already declare readOnlyHint=false, and the description adds an explicit 'WRITE: this modifies your Radarr instance' warning, which reinforces the state-changing behavior. However, it doesn't provide details on what exactly is modified, whether the operation is reversible, or any consequences beyond the generic write notice; still, the annotation coverage lowers the bar and the explicit warning earns a 3.

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

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

The description is extremely short and to the point, with no filler. The first sentence states the action, and the second provides a necessary safety warning. It's concise though it sacrifices informative detail.

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

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

Given the tool involves a bulk mutation and an opaque 'body' parameter, the description and schema together are incomplete. The agent cannot determine how to construct a valid request, what movie file properties can be edited, or what the response will contain. The output schema exists, but no parameter semantics are provided.

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

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

The input schema has a single 'body' object with no description, and the schema coverage is 0%. The description fails to mention what fields the body should contain (e.g., movie file IDs, values to update), leaving the agent to guess the entire payload. This is a critical gap.

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

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

Description clearly states the core action ('Bulk update movie files') and labels it as WRITE, which tells the agent this is a mutation operation on Radarr. However, it doesn't differentiate itself from sibling tools like radarr_bulk_update_moviefile or radarr_update_moviefile, so it stops short of a 5.

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

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

No guidance is given about when to use this tool vs. the many sibling update/list tools. The 'WRITE' warning is a side effect flag, not a usage guideline. There are no mentions of alternatives, prerequisites, or 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 declare readOnlyHint=false, indicating a write operation. The description adds 'WRITE: this modifies your Radarr instance,' which is a natural-language restatement of the existing annotation rather than a new behavioral disclosure. It omits crucial details such as whether the update overwrites all custom formats or only those specified, whether it is idempotent, or what side effects occur.

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

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

The description is very short and front-loaded with the core action. The first sentence 'Bulk update custom formats' essentially restates the tool name, which is somewhat redundant, but the second sentence adds a useful warning. There is no unnecessary verbosity, so it earns a high score for conciseness, though it could be more informative.

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

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

The tool is a bulk write operation with a complex body parameter, but the description does not explain how to construct the request, which custom formats are affected, or how this differs from the single-update sibling. While an output schema exists (so return values need not be described), the input side is severely underdocumented, making it difficult for an agent 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 0%, so the description must compensate for the lack of parameter documentation. The only parameter is a generic 'body' object with additionalProperties true, and the description provides no information about its expected structure, required fields, or how to specify which custom formats to update. This is a significant gap.

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

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

The description states 'Bulk update custom formats.' This clearly identifies the action (update), the resource (custom formats), and the scope (bulk). It distinguishes itself from sibling tools like radarr_update_customformat (single update) and radarr_bulk_delete_customformat (delete 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?

No guidance is provided on when to use this tool versus alternatives. The description does not mention when a bulk update is appropriate, nor does it reference radarr_update_customformat for single updates or any prerequisites. The 'WRITE' warning is a safety note, not usage guidance.

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

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

Annotations already indicate readOnlyHint=false, and the description's 'WRITE: this modifies your Radarr instance' adds little beyond that. The description does not disclose additional behavioral traits such as whether updating is partial or full replacement, whether it applies to multiple download clients simultaneously, or any potential side effects. It is not contradictory, but it provides minimal added transparency beyond the 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?

The description is extremely concise, consisting of two short sentences. The first sentence states the action, and the second adds a write-operation warning. Every word earns its place, and the structure is front-loaded. It sacrifices necessary detail, but from a pure conciseness standpoint it is efficient and free of 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?

Despite having an output schema, the tool's overall completeness is poor. The input schema is vague, and the description does not compensate. There is no explanation of what a bulk update entails, what fields can be updated, or how the request body should be structured. The tool is part of a large family of downloadclient operations, and without more context, an agent cannot correctly select and invoke this tool. The description covers only the surface, leaving critical operational details 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 input schema contains only a generic 'body' object with additionalProperties true and no descriptions (0% schema coverage). The description does not explain what the body should contain, how to specify which download clients to update, or the expected structure. For a bulk update operation, this is a critical omission, leaving the agent with no semantic guidance for constructing a correct request.

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 'Bulk update downloadclient', which clearly identifies the verb (update) and resource (downloadclient), and implies batch operation. It distinguishes from sibling tools like list, get, create, single update, and delete. However, it lacks explicit clarification of what 'bulk' entails (e.g., updating multiple download client configurations at once), so it is not as fully differentiated as the high-calibration example.

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

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

The description provides no guidance on when to use this tool versus alternatives such as radarr_update_downloadclient (single update) or radarr_bulk_delete_downloadclient. It only warns that it modifies the Radarr instance, which is a caution rather than usage direction. No prerequisites, body expectations, or context for bulk operations are given.

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

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

The description adds 'WRITE: this modifies your Radarr instance,' which aligns with the annotations (readOnlyHint=false, destructiveHint=false). It reinforces that this is a write operation, but adds no further context about side effects, required permissions, or what specifically gets modified. With annotations already covering the write nature, the added value is minimal but not contradictory.

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

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

The description is extremely concise and front-loaded with the primary purpose ('Bulk update import lists'). The WARNING is a single short sentence that adds necessary emphasis without unnecessary verbosity. 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?

Despite having an output schema, the description lacks critical input context. It does not specify how the bulk update works, what fields are accepted in the body, or how to provide multiple import list updates. Given the loose body schema and complete absence of parameter guidance, the description is inadequate for correct invocation.

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

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

The schema has a single 'body' parameter with additionalProperties allowed, but no field documentation. Schema description coverage is 0%, and the description does not explain what the body should contain (e.g., IDs, fields to update). The tool is unusable without knowing the expected payload structure.

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 'Bulk update import lists' with a specific verb and resource. This distinguishes it from sibling tools like radarr_update_importlist (single update) and radarr_bulk_delete_importlist (delete operation). The intent is unambiguous.

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

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

No explicit guidance on when to use this tool versus alternatives. It does not mention that single updates should use radarr_update_importlist or that bulk operations are for multiple lists. The WRITE warning is generic and does not help select among similar tools.

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

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

Annotations already mark readOnlyHint=false, so it is known to be a write. The description adds 'WRITE: this modifies your Radarr instance,' reinforcing the mutating nature. However, it does not disclose specifics like what gets changed, whether all indexers or a subset are affected, or any side effects. 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 two short sentences, immediately stating the action and then flagging it as a write operation. Every word is purposeful, with no filler or redundancy.

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

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

Given this is a mutation tool with an untyped 'body' parameter, the description lacks essential contextual information: what request payload is expected, whether it requires specific fields, or how 'bulk' is defined (list vs. all). The output schema exists but does not help with input construction. The description is insufficient for safe and correct invocation.

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

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

The schema has one parameter 'body' with additionalProperties true and no property descriptions (0% schema coverage). The description does not explain the expected structure—e.g., list of indexer IDs, update fields, or how to target indexers—leaving the agent to guess. This is a severe gap for a bulk update tool.

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

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

The description clearly states 'Bulk update indexers' with a specific verb ('update') and resource ('indexers'), distinguishing it from singular radarr_update_indexer and other bulk operations by resource. However, it lacks detail on what 'bulk update' entails or the scope of modifications, so it falls short of a 5.

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

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

The description gives no guidance on when to use this tool versus radarr_update_indexer (singular) or radarr_bulk_delete_indexer. It only warns that it's a write operation, which is a behavioral note, not a usage directive. 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?

The description adds a 'WRITE: this modifies your Radarr instance' warning, which is useful but largely redundant with annotations (readOnlyHint: false). It doesn't disclose additional behavioral traits such as idempotency, required permissions, or potential impact on existing data beyond the annotation's implication.

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

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

The description is very brief with no filler, but it sacrifices essential details. It is appropriately front-loaded, but the second sentence is redundant with annotations. Still, it earns high marks for efficiency.

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

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

For a bulk write operation, the description lacks critical context: what fields can be updated, how movies are identified, whether the operation is reversible, and what the response looks like. Despite having an output schema, the input body is completely opaque.

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

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

The schema has one 'body' parameter with no description and 0% schema description coverage. The description provides no information about what the body should contain, expected fields, or format. It completely fails to compensate for the schema's generic additionalProperties: true.

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 phrase 'Bulk update movies' uses a specific verb and resource, clearly distinguishing it from sibling tools like radarr_update_movie (singular) and radarr_bulk_update_moviefile (different entity). It states exactly 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?

No guidance is provided on when to use this tool versus alternatives like radarr_update_movie or radarr_bulk_update_moviefile. There is no mention of exclusions, prerequisites, or use cases.

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 indicate a write operation (readOnlyHint false), and the description adds an explicit 'WRITE' warning stating it modifies the Radarr instance. This is consistent with annotations but adds little beyond them. It does not disclose side effects, reversibility, or what exactly is modified, so behavioral transparency is limited but not contradictory.

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

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

The description is extremely concise: two short sentences with the main action front-loaded and no unnecessary words. The WRITE warning is relevant and earns its place. It is appropriately sized for the minimal information it conveys.

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 having an output schema, the input side is entirely opaque: the body parameter is unspecified, and the description does not explain what 'update' does, what fields are affected, or any prerequisites. For a bulk write operation, the description is severely incomplete and leaves the agent without enough context 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 one parameter, 'body', which is an array with empty item schema and no description. The description provides zero information about what the body should contain, and schema description coverage is 0%. With no compensation from the description, the agent has no understanding of the required payload structure.

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 (bulk update) and resource (movie files), which is a specific verb+resource pair. However, it does not distinguish from sibling tools like radarr_bulk_edit_moviefiles, and the exact meaning of 'update' is left unclear. The WRITE tag reinforces the operation type but does not add purpose differentiation.

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

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

No guidance is given on when to use this tool versus alternatives such as radarr_update_moviefile or radarr_bulk_edit_moviefiles. The only additional note, 'WRITE: this modifies your Radarr instance,' is a warning rather than a usage guideline. There are no explicit use cases or exclusions.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false. The description adds the explicit 'WRITE: this modifies your Radarr instance' statement, reinforcing the mutation aspect but not detailing side effects, idempotency, or prerequisites. Some value added but limited.

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

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

The description is two short sentences, front-loaded with the primary action and a clear parameter hint. No unnecessary 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 write operation, the description lacks critical context: no indication of prerequisites (e.g., fetching manual import items first), no mention of idempotency, and no explanation of the outcome. The output schema exists, so return values are covered, but workflow and side effects remain unexplained.

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

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

Schema coverage is 0% and the only parameter 'body' has no description. The description states body is a list of manual import items, which adds some meaning, but it does not describe the structure of individual items or required fields, leaving the agent under-informed.

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 commits a manual import, using a specific verb ('Commit') and resource ('manual import'). It also clarifies the body is a list of manual import items, distinguishing this from list_manualimport.

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 finalizing manual imports but provides no explicit guidance on when to use this versus alternatives like list_manualimport, nor any workflow context. The WRITE hint offers minimal direction.

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 readOnlyHint=false, and the description adds 'WRITE: this modifies your Radarr instance,' which confirms the write nature. This provides some context beyond annotations but lacks details on side effects or idempotency.

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 purpose, and contains no redundant wording. It is concise, though it sacrifices detail that would aid usability.

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 free-form body parameter and the existence of a schema endpoint, the description fails to reference how to obtain the expected structure. It is incomplete for a create operation with nested object input, though output schema exists which reduces the need to explain return values.

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 a single generic 'body' object with no property descriptions and 0% schema description coverage. The description does not explain what the body should contain, leaving the agent without guidance for constructing a valid request.

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 'Create auto tagging rules' with a clear verb and resource, distinguishing this tool from sibling operations like update, delete, and list. The additional 'WRITE' context reinforces its purpose.

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

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

The 'Create' verb implies this is the tool for adding new auto tagging rules, but there is no explicit guidance on when to use it vs alternatives or whether to consult radarr_get_autotagging_schema beforehand. Usage is 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?

The description explicitly states 'WRITE: this modifies your Radarr instance', which adds behavioral context beyond the annotations' readOnlyHint=false. However, it does not detail side effects beyond modification, such as whether filters are appended or replaced. This does not contradict 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 two sentences, front-loads the purpose, and every word earns its place. No redundant information or 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?

Despite having an output schema, the tool involves a complex 'body' parameter and nested objects, but the description gives no context about what a custom filter is, what body fields are required, or how the creation behaves. The description is excessively thin for a create tool with an opaque body 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 schema has a single 'body' parameter with 0% description coverage and additionalProperties=true, yet the description provides no information about required fields or expected structure. The description fails to compensate for the schema's lack of parameter detail.

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

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

The description 'Create custom filters' uses a specific verb and resource, clearly distinguishing it from sibling tools like radarr_list_customfilter, radarr_update_customfilter, and radarr_delete_customfilter. The WRITE note reinforces the action 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 implies usage for creation but does not explicitly state when to use this over alternatives. There is no mention of when to use radarr_update_customfilter for modifying existing filters, leaving usage context to be inferred from the tool name and sibling list.

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

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

With annotations already indicating readOnlyHint=false, the description explicitly states 'WRITE: this modifies your Radarr instance,' which adds plain-language confirmation of the write behavior. However, it provides no additional context such as side effects, required permissions, or reversibility, so it adds only marginal value 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 extremely concise and front-loaded with the purpose. The two sentences each carry relevant information: the action and the write warning. No words are wasted.

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

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

Given this is a create operation with a generic free-form body and no parameter descriptions, the description is far too minimal. It does not explain the body structure, reference the schema endpoint, or describe expected outcomes. The agent lacks essential information to use the tool correctly, despite the presence 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 schema has one generic 'body' object with additionalProperties true, and the description offers zero parameter guidance. Schema description coverage is 0%, and the description does not compensate by describing required fields, structure, or pointing to the schema tool. An agent would have no idea what to put in the body.

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 'Create custom formats' uses a specific verb and resource, clearly distinguishing it from sibling tools like update_customformat, delete_customformat, and get_customformat. It unambiguously states 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 provides no guidance on when to use this tool versus alternatives, nor any prerequisites like fetching the schema first. It does not mention using radarr_get_customformat_schema or any context for when creation is appropriate.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false. The description adds 'WRITE: this modifies your Radarr instance,' which essentially restates the readOnlyHint=false annotation without adding new context like side effects, idempotency, or required permissions. Minimal additional transparency.

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

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

The description is two short sentences, front-loaded with the purpose. The second sentence is somewhat redundant with annotations, but the overall length is appropriate. No wasted words, though information is missing.

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

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

For a create operation with a free-form body and no schema guidance, the description is severely incomplete. The agent cannot know what payload to construct, whether there are constraints, or how the operation behaves. The presence of an output schema helps but is not shown here, and the description does not address it.

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

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

The input schema defines a single 'body' object with additionalProperties: true and no required properties. The description gives zero information about what fields the body should contain or what structure is expected. Schema coverage is 0%, so the description was expected to compensate but fails entirely.

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

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

The description clearly states the verb 'Create' and the resource 'delay profiles', distinguishing it from sibling tools like update, delete, or get. However, it does not elaborate on what a delay profile is or what specific parameters are needed, so it is clear but minimal.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that updates should use radarr_update_delayprofile, nor does it describe prerequisites or scenarios. The only extra sentence is a warning that it modifies the instance, which is not usage guidance.

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

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

The 'WRITE: this modifies your Radarr instance' warning adds little beyond the existing annotation readOnlyHint=false, which already signals a write operation. No additional behavioral traits such as dependencies, validation, or side effects are disclosed.

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

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

The description is brief and front-loaded with the action ('Create downloadclient'). The additional warning sentence is short, though somewhat redundant with the annotations, but it does not add 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?

Given that creating a download client typically requires a structured body parameter, the description is incomplete. It fails to mention the need to obtain or construct the body schema, leaving the agent without enough context to invoke the tool correctly despite an output schema existing.

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

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

Schema description coverage is 0%, and the description does not compensate for the generic 'body' object or 'force_save' boolean. The description provides no insight into what fields the body should contain or when force_save should be used.

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 'Create downloadclient' with a specific verb and resource, clearly distinguishing this from the many list/update/delete/test download client siblings. It lacks a bit of detail about what a downloadclient is, but the core purpose is unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives, or that one should consult radarr_get_downloadclient_schema first to build a valid body. The description only restates the action without any contextual usage instructions.

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

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

Annotations already declare readOnlyHint=false, and the description adds the explicit warning 'WRITE: this modifies your Radarr instance,' which is consistent. However, no further behavioral details are provided—such as idempotency, side effects on import list processing, or permission requirements—so the description adds only marginal value 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 one short sentence, front-loaded with the purpose and a clear write warning. Every word earns its place, and there is no redundant or tangential 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?

Despite having an output schema, the tool has a complex, unconstrained body parameter that is completely undocumented. The description provides only a high-level purpose and no information about required payload fields, request construction, or expected behavior—making it inadequate for an agent to invoke reliably. The sibling tools indicate surrounding context, but this description itself is far too sparse.

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 contains a single free-form 'body' object with additionalProperties true and zero property description coverage. The description fails to compensate by listing any expected fields (e.g., movieId, title) or the structure of the request body, leaving the agent with no semantic guidance for constructing a valid call.

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

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

The description clearly identifies the action ('Create') and the target resource ('import list exclusions'), so the purpose is understandable. However, it does not distinguish this tool from the sibling 'radarr_bulk_create_exclusions' (or update/delete variants), leaving ambiguity about whether this is for single or multiple exclusions.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention that this is likely for single exclusions while bulk_create_exclusions handles multiple, nor does it suggest when to prefer update or delete. The agent receives no contextual help for choosing the right 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?

Annotations already show readOnlyHint=false and destructiveHint=false. The description adds 'WRITE: this modifies your Radarr instance,' which reinforces the mutating nature but adds little beyond what annotations imply. No additional side effects or idempotency details are provided.

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

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

The description is two short sentences with no filler. Every word contributes either the core action or a warning, making it highly concise and well-structured.

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

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

For a create operation with a free-form body parameter, the description is far too incomplete for correct invocation. It omits body field requirements, relationship to schema endpoints, and any operational context. The output schema exists but cannot compensate for the undefined input contract.

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

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

Schema description coverage is 0% and the description provides no information about 'body' or 'force_save'. The 'body' parameter is an open object with additionalProperties true, leaving the agent completely uninformed about required fields or valid structure.

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 'Create import lists' with a specific verb and resource. This distinguishes it from sibling tools like radarr_list_importlist, radarr_update_importlist, and radarr_delete_importlist.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention prerequisites, the need to fetch schema first, or that updating existing lists should use a different 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?

Annotations already indicate readOnlyHint=false, and the description reinforces with 'WRITE: this modifies your Radarr instance'. This adds a warning about side effects, but doesn't detail what exactly gets modified, prerequisites, or required permissions. Beyond the annotation, it adds little.

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 only two sentences, front-loaded with the action verb and a short warning. It is efficient and has no wasted words, though it could have included more detail without losing conciseness.

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

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

For a creation tool with an open 'body' object and no parameter descriptions, the description is severely incomplete. It doesn't reference how to structure indexer configuration, what fields are required, or that force_save affects validation. The existence of radarr_get_indexer_schema is not hinted at, leaving the agent without sufficient 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?

The input schema has 0% description coverage for its two parameters. The description provides no explanation of 'body' (an open object) or 'force_save' (a boolean). This leaves the agent without any guidance on what content to provide.

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

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

The description uses the verb 'Create' with the resource 'indexers', clearly identifying the action. It distinguishes from sibling tools like update_indexer, delete_indexer, and list_indexer. The WRITE modifier adds clarity about its mutating nature.

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 'Create indexers' and warns 'WRITE: this modifies your Radarr instance', giving clear context that this is for creating new indexers. It doesn't explicitly mention alternatives or when-not-to-use, but the action is unambiguous among 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 declare readOnlyHint=false, and the description merely restates this as 'WRITE: this modifies your Radarr instance.' It adds no additional behavioral context such as side effects, reversibility, or permission requirements.

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

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

The description is compact and front-loaded with the purpose. It contains no fluff, though the second sentence is a mild redundancy with annotations. It is appropriately sized for a simple statement, but is too short for the needed detail.

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

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

With an output schema present, return values need not be described, but the input parameters are entirely undocumented. For a create tool with a free-form body, the description is critically incomplete and fails to provide any context on how to construct a valid request.

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 0%, and the description provides no explanation for 'body' or 'force_save'. The body parameter is a free-form object with additionalProperties true, making it impossible to know what content is expected. The description does not compensate at all.

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 'Create' and the resource 'metadata providers', clearly distinguishing it from sibling tools like radarr_update_metadata or radarr_list_metadata. The purpose is unambiguous.

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

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

No guidance is given on when to use this tool versus alternatives. The 'WRITE' warning is not usage guidance; it does not mention prerequisites, alternatives like radarr_list_metadata, or when creating is appropriate.

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

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

The description discloses that this is a write operation modifying the Radarr instance, which adds context beyond the annotation readOnlyHint=false. It clearly warns about side effects. However, it doesn't mention other behaviors like validation or duplicate handling, but with annotations present, this level is adequate.

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

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

The description is extremely concise with two short sentences, front-loaded with the core action. Every word is meaningful, and it avoids unnecessary detail.

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

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

For a create tool with an open-ended body parameter, the description is too sparse. It does not explain expected input structure or mention related tools like radarr_get_notification_schema, which would help construct a valid request. The output schema exists, so return values are covered, but input semantics are lacking.

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 two parameters (body, force_save) with 0% description coverage. The description provides no explanation of what 'body' should contain or the meaning of 'force_save'. The schema is open-ended (additionalProperties: true), so the agent receives no semantic guidance beyond the parameter names. This is a significant gap.

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

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

The description clearly states 'Create notification providers' with a specific verb and resource. This distinguishes it from sibling tools like radarr_update_notification, radarr_delete_notification, and radarr_list_notification. The explicit 'WRITE' label reinforces the action.

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

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

The description implies usage for creating notification providers but does not provide explicit guidance on when to use it versus alternatives (e.g., test_notification, update_notification) or any prerequisites. It is minimally sufficient but lacks exclusion or 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 indicate a write operation (readOnlyHint=false). The description's additional 'WRITE: this modifies your Radarr instance' merely restates this without adding new behavioral context like idempotency, validation requirements, or side effects.

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

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

The description is two short sentences, front-loaded with the core action. Every word contributes to clarity, and there is no unnecessary verbiage.

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 having an output schema, the tool requires a complex body parameter that is entirely undocumented in both the schema and description. The description does not point to radarr_get_qualityprofile_schema or outline required fields, making it inadequate for agent execution.

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 a single 'body' object with no property definitions or descriptions (0% coverage). The description provides no guidance on what the body should contain or how to construct a valid quality profile, failing to compensate for the schema's lack of detail.

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

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

The description clearly states the action (create) and the resource (quality profiles). It effectively distinguishes this tool from siblings like radarr_list_qualityprofile, radarr_update_qualityprofile, and radarr_get_qualityprofile.

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

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

The description implies use when creating a new quality profile, but does not explicitly contrast with updating or retrieving. No exclusions or alternative tool references are provided, leaving the usage context 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 readOnlyHint=false and destructiveHint=false, so the description's statement 'WRITE: this modifies your Radarr instance' merely restates the annotation without adding new context. No additional behavioral details are provided (e.g., side effects, required permissions, or idempotency).

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

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

The description is extremely short and front-loaded, conveying the core action in four words. The WRITE warning adds a necessary caution but otherwise the text is minimal and free of fluff. Slightly more detail would be useful, but it is not verbose.

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

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

Despite having an output schema, the tool involves a complex operation (creating a release profile) with an arbitrary body parameter. The description lacks any context about the payload structure, required fields, or how to obtain a schema template. It is inadequate for an agent to construct a correct request.

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

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

The schema has a single 'body' parameter with additionalProperties=true and 0% description coverage. The description provides no field names, structure, or examples for building a release profile body, making it impossible to know what payload to supply.

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 'Create release profiles' uses a specific verb ('Create') and a clear resource ('release profiles'), which unambiguously distinguishes it from sibling tools like list, update, or delete release profiles. The action is immediately understandable.

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

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

The description provides no guidance on when to use this tool versus alternatives, no prerequisites, and no mention of related tools such as update or get release profile. The only extra sentence is a WRITE warning, which is a caution, not a usage guideline.

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 readOnlyHint=false and destructiveHint=false, so the description's 'WRITE: this modifies your Radarr instance' adds a small amount of context by explicitly stating the modification side effect. However, it does not disclose other behavioral traits such as required permissions, idempotency, or error behavior, which are not covered by annotations. This is adequate but not rich.

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

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

The description is extremely concise and front-loaded with the primary purpose. Every word earns its place; the 'WRITE: this modifies your Radarr instance' is a meaningful behavioral note while remaining succinct. No redundancy or unnecessary detail.

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

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

Despite the tool having an output schema, the description is incomplete for a create operation with a generic body parameter. It does not explain what a remote path mapping is, what fields the body should contain, how to obtain valid values, or any prerequisites. Given the low schema coverage and the write nature of the tool, the description provides insufficient context for correct invocation.

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

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

The input schema defines a single 'body' object with additionalProperties:true and no property descriptions (0% schema coverage). The description does not mention any parameter details, field requirements, or structure expectations. The agent is left completely in the dark about what constitutes a valid remote path mapping, so the description fails to compensate for the schema's lack of information.

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

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

The description 'Create remote path mappings' clearly states the specific verb ('Create') and resource ('remote path mappings'), which immediately distinguishes it from sibling tools like update_remotepathmapping, delete_remotepathmapping, and list_remotepathmapping. The additional 'WRITE: this modifies your Radarr instance' reinforces the operation type without confusion.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives, but the verb and resource make the intended usage clear (i.e., use this to create a new remote path mapping, not to update or delete one). This is implied rather than stated, meriting a score of 3 rather than 4.

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

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

Annotations already indicate readOnlyHint=false, so the tool is known to be a write operation. The description adds a 'WRITE: this modifies your Radarr instance' callout, which reinforces this but offers little beyond the annotation. It does not disclose specifics about what gets modified, potential side effects, or error conditions, but with annotations present, a moderate score is appropriate.

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

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

The description is two sentences and front-loaded with the core purpose. The write warning is placed after the main action, making it easy to parse. However, it is too sparse to earn a 5, as the 'WRITE' note is somewhat redundant with annotations and the description lacks valuable details.

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

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

For a create operation with a generic 'body' parameter and no schema descriptions, the description is inadequate. It does not explain what a root folder is, what fields are needed, or how to validate the request. While the output schema exists, the input side remains unexplained, making this incomplete for real-world use.

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 one parameter 'body' with no description, default {}, and additionalProperties=true. Schema coverage is 0%, so the description must compensate. However, the description says nothing about what the body should contain (e.g., path, name) or how to structure the request. This leaves users completely in the dark about parameters.

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

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

The description clearly states 'Create root folders' with a specific verb and resource. This distinguishes it from sibling tools like radarr_list_rootfolder, radarr_get_rootfolder, and radarr_delete_rootfolder, which have different actions.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that you should use this when you need to add a new root folder to Radarr, nor does it reference sibling tools or prerequisites. The only additional note is a write warning, which is not usage guidance.

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

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

Annotations already declare readOnlyHint=false, so the 'WRITE' note merely restates redundant information. The description adds no new behavioral context such as required permissions, idempotency, or side effects beyond what annotations provide. It does not contradict the annotations, but adds minimal value.

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

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

The description is extremely concise, using only two short sentences. 'Create tags' front-loads the action, and the 'WRITE' warning adds essential safety information. No unnecessary words or repetition appear, and the structure is straightforward.

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 having an output schema, the description fails to explain the required request body structure for the 'body' parameter, which is a free-form JSON object. The tool is simple, but without input guidance, the description is incomplete 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?

With zero schema description coverage and no parameter documentation in the description, the 'body' parameter remains completely undefined. The agent cannot infer what fields or structure are needed to create a tag, making the tool effectively unusable without external knowledge.

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 'Create tags' uses a specific verb and resource, clearly indicating the tool's function. It also distinguishes from sibling tools like radarr_update_tag, radarr_delete_tag, and radarr_list_tag by specifying creation. The explicit 'WRITE' note reinforces the action.

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

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

The description provides no guidance on when to use this tool versus alternatives such as radarr_update_tag or radarr_delete_tag. It only states the basic action without context or exclusions, leaving the agent without decision-support information.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false. The description's 'DESTRUCTIVE: this deletes data' merely repeats the annotation and adds no new behavioral information such as permanence or permission requirements.

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

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

The description is concise and front-loaded with the verb and resource. However, the second sentence is redundant with the destructiveHint annotation, so it could be shorter without losing information.

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

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

Given the minimal schema and annotations, the description is incomplete for an agent needing to invoke the tool correctly. It lacks any indication that id is the auto-tagging rule identifier, how to obtain it, or the result of deletion. The output schema exists, but the description doesn't clarify the expected input.

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

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

The schema has one parameter (id) with zero description coverage, and the description does not explain what id refers to or how to find it. No parameter semantics are provided beyond the schema's data 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 clearly states the verb 'Delete' and the resource 'auto tagging rules', which exactly matches the tool name and distinguishes it from sibling delete tools like delete_tag or delete_customfilter.

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

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

No guidance is provided on when to use this tool or how it relates to alternatives. It does not mention that the rule ID should come from list_autotagging, nor does it contrast with create/update autotagging.

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 the warning 'DESTRUCTIVE: this deletes data,' but this merely echoes the annotation destructiveHint=true without adding new behavioral context. No additional risks, side effects, or constraints beyond the annotation are disclosed.

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

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

The description is extremely concise: one action sentence plus a clear warning. Every word earns its place, and it is appropriately sized for a simple delete operation. No redundancy or fluff.

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

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

The tool is simple with one parameter and an output schema, and the destructive annotation partially covers safety. However, the description lacks essential usage context (how to get the id, when to use individual vs bulk delete) and does not explain the parameter, making it only marginally 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 describes a single 'id' parameter with no description, and the description does not explain what the id refers to (e.g., a blocklist entry ID) or how it is used. With 0% schema description coverage, the description fails to compensate, leaving the parameter semantically unexplained.

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 ('Delete') and the resource ('blocklisted releases'), which is specific and unambiguous. It also distinguishes from sibling tools like radarr_bulk_delete_blocklist by using the singular form, and the name reinforces this.

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

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

No guidance is provided on when to use this tool versus radarr_bulk_delete_blocklist or how to obtain the required id. The description only states what the tool does, not the circumstances for choosing 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?

The description adds the scope 'queued/running' beyond the destructiveHint annotation, clarifying which commands are affected. It also reiterates destructiveness, though the annotation already covers that.

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

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

Two short sentences, front-loaded action and resource. The second sentence adds emphasis on destructiveness, which is slightly redundant but not verbose.

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

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

While the tool is simple and an output schema exists, the description lacks parameter meaning and usage context, leaving the agent without enough information to invoke it correctly without external knowledge.

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

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

The schema has 0% description coverage, and the description does not explain what the 'id' parameter refers to or how to obtain it, making it impossible to know what value to pass.

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

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

The description clearly states the specific action (Delete) on a specific resource (queued/running commands), distinguishing it from related tools like radarr_run_command and radarr_get_command.

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

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

No guidance is provided on when to use this tool vs alternatives, prerequisites, or exclusions. The description only states the action, leaving the agent to infer when 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?

The annotations already declare destructiveHint=true and readOnlyHint=false. The description adds no new behavioral context beyond restating the destructive nature, such as irreversibility, permission requirements, or cascade effects. It is consistent with annotations but provides no additional transparency.

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

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

The description is extremely concise with two sentences. The first sentence efficiently states the tool's action. The second sentence repeats the destructive annotation, which is somewhat redundant but still serves as a clear warning. Overall, it is well-structured 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 simple delete operation with annotations and an output schema, the description is adequate. It covers the core behavior and destructiveness. It does not describe return values, but the output schema exists. It lacks details about prerequisites or error handling, but these are less critical given the tool's simplicity.

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 one required parameter 'id' (integer), but schema description coverage is 0%. The description does not explain that 'id' refers to the custom filter to delete. Although 'id' is self-explanatory in context, the description offers no added meaning, failing to compensate for the low 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 uses the specific verb 'Delete' and resource 'custom filters', clearly distinguishing it from sibling tools like radarr_create_customfilter, radarr_update_customfilter, radarr_get_customfilter, and radarr_list_customfilter. The purpose is unambiguous.

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

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

The context is clear: this tool is for deleting custom filters. While no explicit exclusions or alternatives are mentioned, the verb+resource combination makes the intended use obvious. For a simple delete operation, the guidance is sufficient.

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 repeats the destructiveHint annotation ('this deletes data') without adding contextual detail such as permanence, required permissions, or effects on related records. Since annotations already disclose the destructive nature, the description adds no new behavioral insight.

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

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

The description is very short and front-loaded, but the second sentence redundantly repeats the destructive annotation. It remains concise, though not entirely waste-free.

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 a single undocumented parameter and no usage guidance, the description is inadequate. It fails to specify what the id identifies, irreversible consequences, or alternative bulk operations, even though the tool complexity is low.

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 schema description coverage at 0%, the description should compensate for the undocumented 'id' parameter. It fails to explicitly state that 'id' is the identifier of the custom format to delete. While the parameter name is self-explanatory, the description provides no direct clarification.

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 'Delete custom formats' with a specific verb and resource. However, it does not explicitly distinguish this single-delete tool from the sibling radarr_bulk_delete_customformat, relying on the tool name and singular id parameter to imply the difference.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention that this deletes a single custom format by id, nor does it reference bulk deletion as an alternative. The only usage-related information is the destructive warning, which duplicates the annotation.

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 set destructiveHint=true, and the description repeats this with 'DESTRUCTIVE: this deletes data.' While this adds emphasis, it does not disclose additional behavioral traits such as permanence, cascading effects, or required permissions. Given annotations cover the destructive nature, the description adds minimal extra value.

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

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

The description is extremely concise: two short sentences. It front-loads the core purpose and adds a warning. There is no fluff or irrelevant detail, making it easy 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?

The tool is simple with one parameter and an output schema. The description tells the agent it deletes and warns that it is destructive. However, it lacks details about what happens to associated data, whether deletion is reversible, or what the expected outcome might be. While annotations cover safety, the description is minimally 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?

The schema has one parameter 'id' with no description (0% schema description coverage). The description provides no explanation of what 'id' refers to, such as the delay profile ID, or any format expectations. It fails to compensate for the lack of schema 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 'Delete delay profiles' with a specific verb and resource, distinguishing it from sibling tools like create, list, update, and get delay profiles. It is direct and unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention prerequisites, conditions for deletion, or contrast with other delay profile operations. The description simply states the action without contextual usage hints.

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 annotation destructiveHint=true already informs the agent that this operation is destructive. The description's 'DESTRUCTIVE: this deletes data' merely restates this annotation without adding new behavioral context such as irreversibility, impact on related settings, or confirmation requirements. No additional safety or side-effect information is provided.

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

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

The description is extremely concise and front-loaded, with the core action stated in the first three words. However, the second sentence 'DESTRUCTIVE: this deletes data' is redundant with the destructiveHint annotation, so it does not earn its place. Still, overall it is appropriately brief for a simple delete operation.

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

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

For a simple delete tool, the description lacks essential context: no explanation of the 'id' parameter, no usage guidance, and no behavioral details beyond the annotation. The presence of an output schema does not compensate for missing parameter semantics and usage context. The tool is not complete enough for an agent to confidently invoke it.

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

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

The input schema defines a single required parameter 'id' as an integer, but the description provides no explanation of what this ID represents or how to obtain it. With 0% schema description coverage, the description completely fails to compensate, leaving the parameter semantics fully opaque.

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

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

The description 'Delete downloadclient' clearly states the verb (delete) and resource (downloadclient), matching the tool name exactly. It distinguishes this from sibling tools like radarr_list_downloadclient, radarr_create_downloadclient, and radarr_update_downloadclient by specifying the delete action.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention radarr_get_downloadclient for retrieving the ID, radarr_bulk_delete_downloadclient for bulk operations, or any prerequisites. The description only states the action without contextual 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 destructiveHint annotation already signals destructiveness. The description adds 'DESTRUCTIVE: this deletes data,' which restates the annotation but does not provide additional behavioral context such as irreversibility, permissions required, or side effects on related records.

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

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

The description is short and front-loaded, but the second sentence ('DESTRUCTIVE: this deletes data') is largely redundant with the destructiveHint annotation. It could be trimmed to a single sentence without losing meaning.

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

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

For a simple delete operation, the description is minimal. It lacks details on what the id refers to, whether the deletion is permanent, and any consequences. The output schema exists but the description does not help an agent understand the operation beyond the basic action.

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

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

The schema has one 'id' integer parameter with no description and the description does not explain its meaning. While the tool name implies the id refers to an exclusion, the description fails to clarify this explicitly, and with 0% schema coverage, it needed to compensate.

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 ('Delete') and the target resource ('import list exclusions'), using a specific verb and noun. It distinguishes from siblings like radarr_bulk_delete_exclusions by indicating a single-item delete.

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

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

No guidance is given about when to use this tool versus alternatives such as bulk delete or update. It simply states what it does without context on prerequisites or preferred scenarios.

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

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

The annotation already declares destructiveHint=true, and the description merely repeats 'DESTRUCTIVE: this deletes data' without adding new context. It does not explain potential cascading effects (e.g., associated import list movies), irreversibility, or error behavior, so it adds no value beyond the structured 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 short and front-loaded, but the second sentence ('DESTRUCTIVE: this deletes data.') is redundant with the annotations and adds no value. It is concise but not optimally structured since it wastes a sentence repeating existing metadata.

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-by-ID tool, annotations cover the destructive nature and an output schema exists, so return values need no explanation. However, the description lacks any usage context, such as whether the tool deletes a single import list, error handling for non-existent IDs, or guidance on choosing between this and the bulk delete sibling.

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 one required 'id' integer parameter, and schema description coverage is 0%. The description does not mention the parameter or explain what the ID refers to. While the ID is self-explanatory given the tool name, the description fails to compensate for the lack of schema documentation.

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

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

The description clearly states the action (Delete) and resource (import lists), making the core purpose unambiguous. However, it does not distinguish this tool from the sibling radarr_bulk_delete_importlist, and the plural 'import lists' could imply deleting all at once rather than a single instance 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?

There is no guidance on when to use this tool versus radarr_bulk_delete_importlist or other delete tools. The description does not specify prerequisites, recommended scenarios, or exclusions, leaving the agent to infer usage solely from the tool name.

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

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

The description says 'DESTRUCTIVE: this deletes data,' which essentially reiterates the destructiveHint=true annotation without adding new context. It does not mention irreversibility, cascading effects, or any permissions needed. With annotations already covering the destructive nature, the description adds minimal value 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?

The description is extremely brief—two short sentences—and front-loads the action. It is not verbose, but the second sentence is redundant given the annotations, so it does not fully earn its place. Still, the structure is clear and no words are wasted.

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

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

For a destructive delete tool with one parameter and an output schema, the description is incomplete. It lacks information about what the ID identifies, any side effects, or whether the operation can fail. The annotations cover the destructive flag, but the description does not adequately complete the picture for an agent to safely invoke the tool.

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

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

The input schema has one required 'id' integer with no description (0% schema description coverage). The description does not explain what 'id' refers to (e.g., indexer ID) or require any format. The burden falls on the description to clarify parameters, and it fails to do so, leaving the agent to guess.

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 'Delete indexers' with a specific verb and resource. It clearly distinguishes this from sibling tools like 'list_indexer' or 'update_indexer' by declaring the delete operation. The name itself reinforces the purpose, and the description adds a clear action-target pairing.

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

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

There is no guidance on when to use this tool versus alternatives like 'radarr_bulk_delete_indexer' or how to specify which indexer to delete. The description simply states the action without context, prerequisites, or exclusions. A user would have to infer from the name that it deletes a specific indexer by ID.

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 explicitly states 'DESTRUCTIVE: this deletes data', which aligns with the destructiveHint=true annotation but adds no new behavioral information beyond what the annotation already provides. No additional context is given about irreversibility, cascading effects, or required permissions.

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

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

The description is two short sentences that are front-loaded with the primary purpose and include a brief warning. It is appropriately sized for a simple delete operation without extraneous text.

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

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

For a simple deletion tool, the description covers the basic purpose and destructiveness, but it leaves gaps: no mention of what the id parameter means, no usage conditions, and no reference to alternatives. Given the existing annotations and output schema, the description is minimally sufficient but not complete.

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

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

The input schema has one required parameter 'id' with no description, and the description does not explain that 'id' refers to the metadata provider ID or how to obtain it. With 0% schema description coverage, the description fails to compensate, leaving the parameter's semantics implicit at best.

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

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

The description uses the specific verb 'Delete' with the resource 'metadata providers', clearly distinguishing this from sibling tools like radarr_get_metadata, radarr_update_metadata, and radarr_list_metadata. The operation is unambiguous and matches 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 provides no guidance on when to use this tool instead of alternatives such as radarr_update_metadata or radarr_disable_metadata. It lacks any context about prerequisites, such as needing the metadata provider ID, or when deletion is appropriate versus other actions.

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 repeats the annotation's destructiveHint (DESTRUCTIVE: this deletes data) without adding new behavioral context. It does not disclose that the delete_files parameter can permanently remove files from disk, or whether the action is reversible. Since annotations already cover the destructive nature, the description adds little value beyond the structured metadata.

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

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

The description is very concise at two sentences, with the primary action front-loaded. The 'DESTRUCTIVE' warning is somewhat redundant given the annotations but does not add significant verbosity. It is appropriately brief for a simple delete operation, though it could better use the space for parameter semantics.

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 incomplete given the tool's complexity. While an output schema exists (so return values need not be described), the description fails to mention critical side-effect options like delete_files (which deletes movie files from disk) and add_import_exclusion. For a destructive operation with multiple boolean toggles, more context is essential for safe and correct use.

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

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

The schema has 0% description coverage, and the tool description provides no explanations for the three parameters (id, delete_files, add_import_exclusion). The description must compensate for the missing schema descriptions but fails entirely, leaving the agent without guidance on what each parameter does beyond their names.

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 and resource: 'Delete movies.' This is a specific verb+resource pairing that distinguishes it from related operations like deleting movie files (radarr_delete_moviefile). However, it does not explicitly differentiate from radarr_bulk_delete_movie or clarify that it operates on a single movie, so it loses a point for not fully disambiguating among siblings.

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

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

There is no guidance on when to use this tool versus alternatives like bulk delete, nor any mention of prerequisites or context. The description offers no 'when to use' or 'when not to use' instructions, leaving the agent to infer usage solely from the name.

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

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

The annotation destructiveHint: true already indicates the operation is destructive. The description's 'DESTRUCTIVE: this deletes data' simply restates that without adding new behavioral context like permanence, cascading effects, or required permissions. It does not contradict annotations but adds no extra transparency.

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

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

The description is two short sentences, making it appropriately concise and front-loaded with the warning. The second sentence is somewhat redundant given the annotations, but it does not waste words. Overall, it is efficient.

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

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

For a simple delete operation, the description is minimally viable: it states the action and warns about data loss. However, it omits details about the parameter, any side effects, or when to use it. Given the output schema exists and annotations are present, the description is partially complete but not thorough.

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

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

The description does not explain the id parameter, and the schema provides no description for it (coverage 0%). While the tool name and parameter type suggest it is the movie file's ID, the description lacks explicit clarification. This is a noticeable gap for a single-parameter tool.

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

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

The description clearly states the tool deletes movie files, using a specific verb and resource. It is distinct from sibling tools like radarr_list_moviefile and radarr_bulk_delete_moviefile by its focus on deletion. The tool name reinforces the singular 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 provides no guidance on when to use this tool versus alternatives such as radarr_bulk_delete_moviefile. There is no mention of prerequisites, contexts, or exclusions. The destructive warning is behavioral, not usage guidance.

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

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

The description repeats the destructive nature already captured by the destructiveHint annotation without adding new behavioral context. It does not explain consequences like irreversibility or the exact scope of data removed, so it adds minimal value 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 very concise with two short sentences. The first sentence is essential; the second sentence contains a redundant warning already present in the annotations, slightly reducing efficiency but not causing bloat.

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

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

For a simple delete operation with one parameter and annotations indicating destructiveness, the description is sufficiently complete. It clearly states the action and resource, and the parameter is straightforward, though it could benefit from noting the id's purpose.

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

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

With 0% schema description coverage, the description fails to elaborate on the 'id' parameter. Although it is inferable that the id refers to a notification provider, the description does not clarify the format, source, or required context for the parameter.

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

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

The description uses a specific verb 'Delete' and identifies the resource 'notification providers', making the action unambiguous. It clearly distinguishes from sibling tools like create/update/get notification by specifying the deletion 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 description implies the tool should be used to delete notification providers, but it does not explicitly state when to use it versus alternatives or provide any exclusionary guidance. There is no mention of prerequisites or cautionary notes beyond the destructive warning.

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 the description's 'DESTRUCTIVE: this deletes data' simply reiterates this without adding context about permanence, side effects, or required permissions.

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 first sentence is appropriately concise, but the second sentence is redundant with the destructiveHint annotation, wasting a sentence without adding 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?

Given the simple destructive operation, the description is incomplete: it doesn't clarify the id parameter or any consequences beyond the generic destructive label. The output schema exists but doesn't compensate for the missing parameter semantics.

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 defines a single 'id' integer with no description (0% coverage), and the description fails to explain that this id identifies the quality profile to delete, leaving the parameter's purpose ambiguous.

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

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

The description clearly states the action ('Delete') and the resource ('quality profiles'), making it unambiguous and distinct from sibling tools such as radarr_create_qualityprofile and radarr_update_qualityprofile.

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

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

No usage guidance is provided. The description doesn't mention when to use this tool, any prerequisites, or alternatives to consider.

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 readOnlyHint=false. The description adds a human-readable warning 'DESTRUCTIVE: this deletes data,' which reinforces the safety profile but does not disclose additional behavior such as the effect of remove_from_client or other parameters. Since annotations cover the core destructive nature, this is adequate but not enhanced.

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

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

The description is extremely concise with a single clear sentence and a separate warning. It is well-structured and front-loaded, but its brevity comes at the cost of omitting essential usage details. Still, as a structure, it earns points for clarity and not wasting words.

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

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

Given the tool has 5 parameters, a destructive nature, and exists alongside a bulk-delete sibling, the description is incomplete. It does not explain the effect of parameters like blocklist or remove_from_client, nor does it differentiate from radarr_bulk_delete_queue. An output schema exists but the description fails to provide necessary operational context beyond the basic action.

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

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

Schema description coverage is 0% and the description provides no explanation of any of the 5 parameters (id, blocklist, change_category, skip_redownload, remove_from_client). The description must compensate for the low coverage but does not mention any parameter semantics, leaving the agent to guess meanings.

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 ('Delete download client queue items') with a specific verb and resource. It distinguishes itself from sibling tools like radarr_bulk_delete_queue by implying singular deletion and from radarr_grab_queue_item which is a different action. The destructive warning also reinforces the tool's intent.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention radarr_bulk_delete_queue for batch deletion or explain conditions for single-item deletion. The description lacks any contextual or exclusionary guidance, leaving the agent to infer usage.

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

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

Annotations already declare destructiveHint=true, and the description adds 'DESTRUCTIVE: this deletes data' which is slightly redundant but reinforces the risk. No additional behavioral details are provided (e.g., irreversibility, effects on associated 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?

Extremely concise: two short sentences, front-loaded with the action and followed by a clear warning. Every word earns its place.

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

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

The tool is simple and has an output schema, so return values are documented elsewhere. However, the description lacks context about prerequisites (e.g., id must exist) and consequences beyond generic destructiveness, leaving gaps for an agent.

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

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

The schema has one parameter 'id' (integer) but the description does not explain what the id refers to (i.e., the release profile ID). With 0% schema description coverage, the description provides no semantic help, forcing the agent to infer from the tool name.

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 'Delete release profiles' uses a specific verb (delete) and resource (release profiles), clearly distinguishing it from sibling tools like create/update/list/get. The additional destructive warning reinforces the action.

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

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

No explicit guidance on when to use this tool versus alternatives. It doesn't mention that the 'id' parameter should come from list/get operations, nor does it state that it's for removing existing profiles only. The context is minimal.

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