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

The readOnlyHint annotation already indicates this is a safe read operation. The description adds minimal behavioral context beyond listing what each operation does ('Fetch a single upcoming episode calendar' and 'List upcoming episode calendar'), which is consistent with the annotation. No additional side effects or edge cases are disclosed, but with the annotation present, the bar is lower.

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 clear introductory line followed by bullet-style operation signatures. Every sentence earns its place, and the structure makes the two operations easy to scan. No unnecessary filler or repetition.

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

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

Given the dispatcher pattern and the presence of an output schema, the description provides sufficient coverage by enumerating both operations and their parameters. It does not explain return formats, but the output schema likely covers that. It could add date format hints or examples, but overall it is complete for a read-only tool with clear operation signatures.

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 no description coverage for parameters (coverage 0%), so the description carries the burden. It lists all parameters for each operation, including defaults for sonarr_list_calendar (start, end, unmonitored, etc.), which adds significant meaning beyond the generic 'arguments' object in the schema. However, it does not explain parameter formats or detailed semantics, so it stops short of a 5.

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 tool as handling Sonarr calendar operations and enumerates two specific operations: sonarr_get_calendar and sonarr_list_calendar. While it distinguishes between fetching a single calendar entry and listing calendar items, it does not explicitly differentiate this tool from sibling tools, but the domain is clear.

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

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

The description implies usage by providing operation names and their parameters, but it does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions or context for choosing between the two operations. It is clear enough for basic selection but lacks explicit guidance.

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

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

With no annotations provided, the description must carry the full burden. It does disclose that update operations are writes ('WRITE: this modifies your Sonarr instance'), which is useful. However, it does not mention read-only semantics, return value behavior, potential side effects, authorization needs, or error conditions for other operations, leaving significant gaps.

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

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

The description is a well-structured bullet list with a clear opening instruction. It avoids unnecessary prose and each line is a discrete operation with its parameters. The format is efficient for a dispatcher tool, though it is long due to the number of operations.

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 an output schema, so return values need not be described in detail. The description explains the invocation pattern (operation plus arguments) and lists all operations, which is adequate for a complex dispatcher. However, it lacks context about error handling, whether operations are grouped in any way, and how this relates to other Sonarr tools, 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?

The schema has no descriptions for parameters, and coverage is 0%, so the description is the only source. It lists operation-specific parameters (e.g., id, body, rename_episodes) and sometimes defaults, which adds some meaning beyond the bare schema. However, it does not explain the semantic purpose of each parameter or the structure of the 'arguments' dict beyond matching operation parameters, so it only partially compensates.

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 it is for 'sonarr config operations' and enumerates specific operations, making the general purpose clear. However, the tool name and description are somewhat tautological ('sonarr config operations on Sonarr'), and it does not clearly differentiate from sibling tools that may also handle similar config tasks like download clients or indexers.

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 is provided on when to use this tool versus alternatives, and no exclusions or prerequisites are mentioned. The operation list implies usage based on the operation names, but there is no explicit statement about comparing with sibling tools or when not to use this dispatcher.

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

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

With no annotations provided, the description carries the burden of disclosing side effects. It does so explicitly, labeling all create/update operations as 'WRITE: this modifies your Sonarr instance' and delete operations as 'DESTRUCTIVE: this deletes data.' This effectively communicates the core behavioral traits, though it omits details like permission requirements or failure modes.

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

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

The description is a long bulleted list, but each entry is a compact function signature with a purpose and side-effect label, making it scannable. The intro is minimal. The repetitive side-effect phrasing is slightly wasteful but aids quick reading. Overall, it conveys a large amount of information efficiently.

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 provides a comprehensive list of operations and their side effects, and an output schema exists to cover return values. However, the lack of parameter semantics is a major completeness gap for a complex dispatcher, and it does not mention authentication or operation-specific prerequisites. It is adequate for selecting an operation but not for full safe invocation.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameters. It lists parameter names and defaults (e.g., force_save=False, body={}, id), but does not explain their meaning or how to structure the `arguments` dict. For a tool that requires operation-specific arguments, this is a significant gap that leaves callers guessing.

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 'sonarr download clients operations on Sonarr' and enumerates specific operations with function signatures, making the tool's purpose evident. However, it also includes remote path mapping operations under a 'download_clients' name, slightly muddying the scope and preventing a perfect score.

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

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

The description gives explicit usage instruction: 'Pass `operation` and an `arguments` dict matching that operation's parameters.' It also lists all operations with their parameters, providing a clear how-to. It does not explicitly differentiate from sibling tools, but the operation list itself makes the tool's coverage clear.

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

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

With no annotations provided, the description carries the full burden and does well by flagging destructive operations with 'DESTRUCTIVE: this deletes data.' and write operations with 'WRITE: this modifies your Sonarr instance.' It also adds nuance like 'blocklists the release by default' for the mark-failed operation. However, it could disclose more details (e.g., irreversibility, permissions), so it is not a perfect 5.

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 efficiently structured with a brief general instruction followed by a bullet list of operations. Each bullet is a single concise line containing the operation name, parameters, and safety label. No word is wasted, and the format makes scanning and selecting operations easy.

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 complexity of 7 sub-operations and no annotations, the description is quite thorough: it covers all operations, their signatures, and flags destructive/write behavior. An output schema exists, so return-value documentation is not required. However, it doesn't mention potential exceptions, authentication requirements, or how the arguments dict should be structured beyond listing parameters, leaving minor 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 only provides operation and arguments as a free-form object, but the description compensates by listing each operation's parameter signature with defaults (e.g., `page=1, page_size=10`). This adds substantial meaning beyond the schema. It could go further by explaining each parameter's semantics, but the coverage is strong for a dispatcher-style 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 explicitly states it handles 'sonarr history blocklist operations' and enumerates seven specific operations with clear verbs (delete, list, mark). This distinguishes it from sibling tools focused on other Sonarr aspects like profiles, config, or media library. The resource and scope are 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?

There is no explicit when-to-use guidance or comparison with sibling tools. Usage is implied by the tool name and the listed operations, but the description does not state when to choose this over other Sonarr tools or any exclusions. The per-operation notes give some context, but global usage guidance is absent.

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 manually marks write operations with 'WRITE: this modifies your Sonarr instance' and destructive operations with 'DESTRUCTIVE: this deletes data.' This is valuable behavioral disclosure beyond the schema. However, it does not cover other behavioral aspects like authentication, rate limits, or side effects, and no annotations are provided to offset this.

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

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

The description is a well-structured bullet list where each line is concise and focused on a single operation. No empty phrases; every line provides operation-specific information. While long, the length is justified by the 18 operations it covers.

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 (18 distinct operations), the description covers all operations, notes query parameters for the paged operation, and the presence of an output schema helps clarify return values. It is sufficiently complete for a dispatcher-style tool, though it could add more context on parameter semantics and operation selection.

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 is generic (only `operation` and `arguments`), with 0% schema description coverage. The description compensates by listing per-operation parameter names and defaults (e.g., `force_save=False`, `page=1`, `sort_key=''`), but does not explain the types or meanings of these parameters. This adds moderate value but is not exhaustive.

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 enumerates each operation with a specific verb+resource (e.g., 'Create import lists', 'Delete import list exclusions', 'Fetch a single import lists by id'), making the purpose of each sub-operation clear. The tool's overall role as a dispatcher for Sonarr import list operations is evident from the list.

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

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

There is no guidance on when to use this tool versus its siblings, nor any explanation of how to select between the numerous operations beyond their names. The description does not provide context like 'use this for managing import lists' or alternative tool recommendations.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly labels write operations as 'WRITE: this modifies your Sonarr instance' and deletes as 'DESTRUCTIVE: this deletes data', which is important context. It does not cover all possible side effects or errors, but it addresses the most critical mutating behaviors.

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 structured as a bullet list of operations, each concisely described with its parameters and side effects. While it is long due to 11 operations, every line adds necessary information and the list format makes it scannable.

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

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

The tool is complex with 11 sub-operations, and the description covers all of them, their parameters, and side effects. It also references an output schema, so return value details are not needed. Minor gaps include lack of details on argument dict structure and error handling, but the overall coverage is strong.

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 only operation and arguments with 0% description coverage, so the description must compensate. It lists signatures for each operation (e.g., sonarr_delete_indexer(id)) and parameter names, which helps, but it does not explain what 'body' should contain or the structure of the arguments dict beyond suggesting it matches operation parameters. This is partial compensation.

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 it performs 'sonarr indexers operations on Sonarr' and enumerates 11 specific operations with clear verbs (create, delete, list, update, etc.), which identifies the resource and action. However, it doesn't explicitly distinguish this tool from sibling Sonarr tools, though the focus on indexers makes it apparent.

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 by listing operations and instructing to pass an operation and arguments, but it does not provide explicit when-to-use guidance or contrast with alternative tools. There are no exclusions or specific scenarios, leaving usage to be inferred.

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

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

With no annotations provided, the description carries the full transparency burden. It marks every mutating operation with 'WRITE: this modifies your Sonarr instance' and every destructive action with 'DESTRUCTIVE: this deletes data', clearly disclosing side effects. This goes well beyond what a typical tool description provides.

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 long out of necessity—25 operations require enumeration—and is well-structured as a bulleted list. The opening line is slightly redundant ('on Sonarr' is implied by the tool name), and WRITE/DESTRUCTIVE tags are repeated verbatim, creating some noise. Still, every line earns its place and the signatures are formatted efficiently.

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 large operation count and the minimal schema, the description covers all operation names, parameter signatures, defaults, and side-effect labels. It does not include a concrete usage example of the `arguments` dict, nor does it explain the `body` resource types in detail. However, it does state that arguments must match the operation's parameters, which is sufficient for an agent familiar with Sonarr conventions.

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 only defines a generic `arguments` object with no property descriptions (0% schema coverage). The description compensates fully by listing each operation's parameter names and defaults (e.g., `sonarr_list_episode(series_id=None, season_number=None, ...)`). This gives the agent precise key names for the arguments dict, which is essential for correct invocation.

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

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

The description clearly identifies this as a dispatcher for Sonarr media library operations, then enumerates 25 specific operation signatures covering series, episodes, and files. This is a specific verb+resource scope that distinguishes it from sibling tools like sonarr_calendar or sonarr_release_search, despite not explicitly naming them.

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

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

The description implies usage by listing the exact operations available and instructing the agent to pass `operation` and `arguments`. However, it provides no explicit guidance about when to use this tool versus sibling Sonarr tools, nor does it mention exclusions or alternative tools for overlapping functionality.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It explicitly labels mutating operations as 'WRITE: this modifies your Sonarr instance' and destructive ones as 'DESTRUCTIVE: this deletes data', which is valuable. Read operations are left unlabeled, implying safety, though test operation semantics are not explained.

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

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

The description is front-loaded with a brief usage hook, then follows a consistent bulleted list of all operations. Each line contains necessary operation-specific information with no redundancy, making it appropriately sized for a dispatcher tool.

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

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

Given the dispatcher complexity, output schema presence, and lack of annotations, the description is largely complete: it enumerates all operations, their parameters, and safety status. It could note that `arguments` keys should exactly match parameter names, but this is inferable from the listed signatures.

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 compensates by listing each operation's parameter signature (e.g., force_save, body, id). This adds meaning beyond the generic `arguments` object, but it does not detail the structure of `body` or types of 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 the tool covers 'sonarr notifications metadata operations' and lists 18 specific operations with explicit verbs (create, delete, get, list, update) and resource targets (metadata, notification). This distinguishes it from sibling tools handling other Sonarr domains.

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

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

It provides clear instructions to pass an `operation` and an `arguments` dict matching that operation's parameters, which tells the agent exactly how to invoke it. It does not explicitly say when not to use it, but the operation list and domain scope make the usage context evident.

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

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

No annotations are provided, so the description carries the full burden. It clearly labels operations as WRITE (modifies your Sonarr instance) or DESTRUCTIVE (deletes data), which is critical safety information. It also gives basic signatures and defaults (e.g., 'body={}', 'id'). However, it does not disclose potential side effects beyond deletion/modification, such as cascading effects or validation errors, but the core safety traits are well covered.

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

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

The description is long but highly structured: an introductory sentence explaining how to use the tool followed by a line per operation with a terse summary. Every operation line earns its place because the tool is a dispatcher, and listing all operations is necessary. It could be more compact with grouping or a table, but the current format is scannable and front-loaded with the key usage instruction.

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

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

Given the high number of operations and sparse schema, the description provides a comprehensive catalog with safety labels and signatures, which is substantial. However, it lacks guidance on when to choose this tool over sibling tools, detailed parameter semantics for each operation, and any indication of what the output schema contains or how errors surface. The presence of an output schema helps, but the description does not explain return values or edge cases, leaving gaps for a complex tool.

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

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

Schema coverage is 0%, so the description must compensate. It provides call signatures for each operation, showing parameter names (e.g., 'id', 'body', 'after') and defaults, which adds value beyond the schema's generic 'arguments' object. However, it does not explain the expected structure or meaning of 'body' or how to format the arguments dict beyond 'matching that operation's parameters.' This is enough for basic understanding but lacks depth.

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 this tool handles 'sonarr profiles formats operations on Sonarr' and then enumerates all specific operations (create, delete, update, list, etc.) for profiles and formats. This distinguishes it from sibling tools that cover other Sonarr domains (e.g., tags, indexers) by naming the exact resources and actions. However, it is a multi-operation dispatcher rather than a single-verb tool, so it lacks the crisp specificity of a focused tool.

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 versus sibling tools, but the operation list effectively implies usage: if you need one of these named operations (e.g., 'sonarr_create_qualityprofile'), you use this tool. There is no direct comparison to alternatives or exclusion guidance, so the agent must infer the boundaries from the operation names. The absence of explicit 'use this for X, not Y' guidance makes this only minimally adequate.

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

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

With no annotations, the description flags destructive operations (DESTRUCTIVE: this deletes data) and write operations (WRITE: this modifies your Sonarr instance), and clarifies effects like 'forces the download client to fetch it'. It does not cover prerequisites, permissions, or reversibility, but the most critical safety traits 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 long but well-structured as a bullet list, with each operation on its own line and a brief annotation. The redundant first sentence is the only waste; overall it is efficient for a multi-operation tool.

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

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

Given the high complexity (7 sub-operations) and minimal schema, the description provides sufficient operational detail for each operation, including distinguishing read, write, and destructive actions. It relies on the output schema for return values, which is acceptable.

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 compensates by listing complete signatures with defaults for every operation. It also clarifies ambiguous parameters (e.g., 'body is a list of ids'). However, some parameter meanings like change_category remain 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 enumerates all seven queue operations with specific verbs (delete, get, list, grab) and their targets, distinguishing this from sibling Sonarr category tools. The operation list provides concrete purpose despite a redundant opening phrase.

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 instruction 'Pass operation and an arguments dict matching that operation's parameters' explains invocation but does not provide explicit guidance on when to choose this tool over alternatives, nor any exclusions. Usage is implied by the operation names.

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

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

With no annotations, the description carries the burden. It explicitly marks `sonarr_push_release` and `sonarr_search_releases` as WRITE operations that modify the Sonarr instance, which is valuable. However, it does not disclose other behavioral aspects such as error behavior, rate limits, or side effects beyond the modification, and the read operations are not explicitly labeled safe.

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 uses a terse opening plus a bulleted list of operations, making it scannable and concise. Each operation's purpose and params are on one line. The front-loaded sentence is slightly redundant with the tool name but harmless, and the WRITE flags are included inline.

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 wraps multiple operations with a generic schema, the description provides enough overview to route to the correct operation, and an output schema exists to cover return values. However, there are gaps: no details on the body structure for push/search, no semantics for the optional parameters, and no guidance on how to pass arguments as a dict. This is adequate but not thorough.

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

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

Schema description coverage is 0%, so the description compensates by specifying operation-specific parameters (e.g., series_id, episode_id, season_number for list_release) and noting that body carries seriesId/episodeId for search_releases. This adds meaning beyond the generic `arguments` dict, though some parameters like the body contents for push_release remain unspecified.

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 enumerates four specific operations with one-line summaries, establishing that this tool covers release-related actions (indexer flags, list, push, search). It distinguishes from sibling tools by naming the Sonarr release search domain, though the opening sentence is generic and 'operations' could be more precise.

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

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

Usage is implied through operation examples (e.g., searching for releases for a series/episode), but there is no explicit guidance on when to choose this tool over alternatives like sonarr_queue or sonarr_media_library, nor any exclusions. The write operations are flagged, which hints at caution, but this doesn't substitute for explicit alternatives.

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

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

With no annotations, the description carries the burden for behavioral disclosure. It marks create_rootfolder as 'WRITE: this modifies your Sonarr instance' and delete_rootfolder as 'DESTRUCTIVE: this deletes data', which is useful. However, it omits other behavioral traits such as authentication requirements, reversibility, side effects on disk, or error behavior, so transparency is only partial.

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

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

The description is well-structured as a bulleted list of operations with signatures and brief warnings. It front-loads the invocation instruction. Minor redundancy exists ('sonarr storage operations on Sonarr'), but overall each line earns its place and there is no substantive 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 complex with eight operations, yet the description provides only one-line comments for each and lacks contextual details such as when to use specific operations, typical use cases, prerequisites, or failure modes. An output schema exists, which may cover return values, but the description does not round out the behavioral context adequately for reliable agent selection.

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 lists parameter names and defaults (e.g., path='', include_files=False) and indicates that arguments should match operation parameters, but it fails to explain the meaning or valid values of key parameters. For example, sonarr_create_rootfolder(body={}) does not describe what fields 'body' should contain, leaving the agent without enough information to construct correct arguments.

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 tool as 'sonarr storage operations' and enumerates specific verbs and resources (create_rootfolder, delete_rootfolder, list_filesystem, etc.), making each operation's purpose understandable. However, it does not explicitly differentiate this tool from sibling tools, relying on the tool name and operation list for context.

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

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

There is no explicit guidance on when to use this tool versus alternatives, and no prerequisites or exclusions are mentioned. The only usage instruction is syntactic ('Pass operation and an arguments dict'), which does not help the agent decide when to call this tool instead of siblings like sonarr_media_library.

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

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

With no annotations provided, the description takes full responsibility for behavioral disclosure. It explicitly flags destructive operations with 'DESTRUCTIVE: this deletes data' and write operations with 'WRITE: this modifies your Sonarr instance.' It also notes 'limited support' for multipart upload and states that ping verifies reachability and authentication.

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

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

The description is front-loaded with an overview and usage instruction, followed by a well-structured bullet list of all operations. Each line is concise and informative, covering 20 operations without unnecessary verbosity. Every sentence earns its place by adding needed operation semantics or safety warnings.

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 20 operations, the description is comprehensive. It covers all operation types, provides safety annotations, explains the arguments dict, and gives specific parameter details for complex operations. The presence of an output schema means return values need not be described. The description is sufficient for an agent to select and invoke operations 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 provides only an operation enum and a generic arguments object with no descriptions. The description compensates by explaining each operation's purpose and providing parameter hints, e.g., 'sonarr_list_log(page=1, page_size=10, sort_key='', sort_direction='', level='')' lists query params, and run_command specifies that body is a CommandResource with a `name`. This adds meaning well beyond the bare schema.

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

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

The description clearly identifies the tool as handling 'sonarr system commands operations on Sonarr' and then enumerates 20 specific operations. Each operation has a verb and resource (e.g., 'sonarr_get_health() — List health'), distinguishing this dispatcher tool from sibling tools like sonarr_config or sonarr_history_blocklist.

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 a clear usage pattern: 'Pass `operation` and an `arguments` dict matching that operation's parameters.' It also gives operation-specific details (e.g., query params for list_log, body example for run_command). However, it does not explicitly state when to use this tool over alternatives, nor does it mention any exclusions or when-not-to-use 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?

With no annotations, the description carries the burden and does disclose side effects for write and delete operations ('WRITE: this modifies your Sonarr instance' and 'DESTRUCTIVE: this deletes data') and uses fetch/list for reads. It does not cover other behavioral nuances like auth requirements, error behavior, or rate limits, so it is only partially transparent.

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

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

The description is well-structured with a summary sentence followed by a compact bullet list of operations. It is appropriately sized for seven sub-operations, though it redundantly repeats 'sonarr_' and 'tags' in each line, which is unnecessary but not harmful.

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

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

The description covers all operation names and side effect hints, but the presence of an output schema does not eliminate the need for parameter detail. For a multi-operation tool with complex body arguments, it lacks examples or field explanations, making it only partially complete for the complexity involved.

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 only defines operation and a generic arguments object with no property descriptions. The description compensates by showing the required parameters for each operation (e.g., body={} for create/update, id for delete/get/get_detail), adding meaning beyond the schema. Yet it does not describe the inner structure of 'body', so it's not a 5.

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 this tool handles Sonarr tag operations and enumerates all supported sub-operations (create, delete, get, get_detail, list, list_detail, update). It distinguishes the resource 'tags' from sibling tools by naming the resource explicitly, though the primary verb 'operations' is generic.

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 explains the mechanism for using the tool (pass operation and arguments dict) and flags write/destructive operations. However, it does not explicitly compare with sibling tools or state when to use this tool versus alternatives, leaving usage context implied.

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 readOnlyHint=true already indicates a safe read operation, so the description does not need to repeat safety info. It adds contextual behavior by documenting pagination parameters and query params (e.g., page, page_size, sort_key), but does not describe edge cases or response details (which are covered by the output schema).

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

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

The description is well-structured: an intro sentence explains the dispatch pattern, followed by a concise bulleted list of operations with signatures and defaults. It is easy to scan and does not contain unnecessary elaboration.

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 generic schema (only operation and arguments) and multiple operations, the description covers all four operations and their parameters sufficiently. The output schema exists to handle return-value documentation, so the description need not explain that. It lacks deeper context about the 'wanted' concept, but overall is adequate for invoking 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?

Schema description coverage is 0%, so the description carries the full burden for parameter meanings. It provides complete operation signatures with defaults for list operations (e.g., page=1, page_size=10, monitored=True), making the generic 'arguments' dict understandable. However, it does not explain each parameter's domain-specific meaning (e.g., what include_images affects).

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's scope as 'sonarr wanted operations' and enumerates four specific operations (get/list for cutoff and missing). It differentiates from siblings by focusing on wanted items, but does not explicitly contrast with other Sonarr tools.

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

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

The description explains the dispatch pattern by requiring an 'operation' and 'arguments' dict, and lists operation signatures, which implies how to invoke it. However, it does not explicitly state when to use this tool versus sibling tools like sonarr_release_search or sonarr_queue, nor does it provide any exclusion/alternative guidance.

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