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

Annotations declare readOnlyHint: true, so the agent knows this is a safe read operation. The description adds operation-level details (fetch/list) but does not disclose additional behavioral traits such as pagination, date format expectations, or error handling. It is adequate but not rich 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 compact: a short lead-in sentence followed by a clearly formatted bulleted list. It front-loads the operations and avoids redundancy or filler. Every sentence earns its place.

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

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

Given that an output schema exists, the description need not explain return values. It covers the core operations and parameter lists. However, it could add more detail on argument value formats (e.g., date formats, tags structure) to be fully complete for a complex calendar tool. Still, it is sufficient for an agent to invoke the tool correctly in most cases.

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 'operation' and a generic 'arguments' dict, with 0% coverage of the actual operation-specific parameters. The description compensates by listing parameter names and defaults (e.g., start, end, unmonitored, include_artist, tags) in function signatures. It falls short of explaining the meaning and format of each parameter, but it provides essential structural information the schema lacks.

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 'lidarr calendar operations' and enumerates two distinct operations with specific verbs and resources: 'lidarr_get_calendar(id) — Fetch a single calendar entry (album) by id' and 'lidarr_list_calendar(...) — List albums releasing in a date range.' This distinguishes it from sibling Lidarr tools and leaves no ambiguity about 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 description provides clear context for using each operation: get for a single ID, list for a date range. It also explains the overall pattern of passing an `operation` and `arguments` dict. However, it does not explicitly mention when to use this tool versus alternative Lidarr tools, which is a minor gap given the 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 no annotations, the description carries the transparency burden. It flags update operations as 'WRITE: this modifies your Lidarr instance', which is important. Yet it does not mention side effects for read operations, permissions, or other behavioral nuances. It provides some but not rich 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 long but necessary given the 25 operations. It is well-structured as an indented list with clear operation signatures and WRITE flags. It front-loads the general instruction before enumerating operations. Slightly verbose but justified.

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 operations and their parameters, and with an output schema present, return values are not the description's responsibility. It lacks information about error handling, auth requirements, or configuration change side effects, but for a multi-operation config tool it is reasonably 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 only has generic 'operation' and 'arguments' fields. The description compensates fully by listing each operation with its specific parameters, defaults, and query params (e.g., renaming examples, filesystem paths). This adds substantial meaning beyond the schema.

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

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

The description clearly states this is for 'lidarr config operations' and enumerates all specific sub-operations (get, list, update) with resource targets. It distinguishes itself from sibling tools by focusing solely on configuration management, not search, library, etc.

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 that you pass an 'operation' and 'arguments', and lists every operation. However, it does not explicitly state when to use this tool over alternatives or when not to use it. Usage context is implied but not explicitly contrasted with sibling 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?

With no annotations, the description carries the full transparency burden. It explicitly marks operations as WRITE or DESTRUCTIVE, including non-obvious behaviors like test operations modifying the instance. It does not disclose additional details like permissions or rate limits, but the safety profile is 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 efficiently structured: a one-sentence overview followed by a bullet-style list of operations with minimal but sufficient detail. Each line is concise and the layout makes scanning easy, with no redundant phrasing.

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 a dispatcher with 11 operations, the description covers all operations, their purposes, and safety flags. It does not explain return values or error cases, but the presence of an output schema reduces that need. Overall it provides enough context for an agent to use 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 schema coverage is 0%, so the description must compensate. It explains that 'arguments' is a dict matching each operation and gives hints like 'body carries ids' or 'body is a list of resources', but it does not specify exact fields for each operation. This is moderately helpful but leaves many parameter details unresolved.

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

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

The description clearly states it handles 'lidarr download clients operations' and enumerates all 11 specific operations with distinct verbs (list, get, create, update, delete, test, etc.). This distinguishes it from sibling tools that cover other Lidarr 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?

The description provides clear context that this tool is for download client management, and each sub-operation is described with its role. It does not explicitly mention when not to use it or point to alternatives, but the scope is unambiguous relative to 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?

With no annotations, the description takes on the full burden of behavioral disclosure. It explicitly labels 'lidarr_bulk_delete_blocklist' and 'lidarr_delete_blocklist' as DESTRUCTIVE, and 'lidarr_mark_history_item_failed' as WRITE, which is valuable. The read-only operations are not explicitly marked as safe, but their list-like nature is implied. No contradictions with annotations exist.

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 clear usage pattern ('Pass operation and an arguments dict') and then lists each operation in a compact, consistent format. Each line earns its place, but the overall length is substantial. The bullet-like structure aids readability.

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 (7 sub-operations) and the generic schema, the description covers each operation's purpose and parameters thoroughly. It omits error handling and response details, but an output schema exists to cover return values. The destructive/write mentions add important safety context. Overall, it is reasonably complete for a dispatcher 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 is generic with only 'operation' and an opaque 'arguments' object, providing zero parameter documentation. The description compensates fully by listing each sub-operation's parameters, types, and defaults (e.g., page=1, page_size=10, include_artist=False). This 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 states the tool's domain ('lidarr history blocklist operations') and enumerates seven specific sub-operations, making its purpose evident. It distinguishes from sibling tools by focusing on history and blocklist functionality. However, it lacks a single specific verb and reads as a collection rather than a primary 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. It simply lists operations without explaining context or exclusions. The only implicit hint is the 'DESTRUCTIVE'/'WRITE' flags, which indicate caution but not usage 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 provided, the description carries the full burden. It consistently labels operations as 'WRITE: this modifies your Lidarr instance' or 'DESTRUCTIVE: this deletes data' (e.g., lidarr_delete_importlist, lidarr_test_importlist). This is valuable behavioral disclosure beyond the schema. However, it omits other potential behaviors such as authentication requirements, rate limits, or error cases, so it is not a perfect disclosure.

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 structured bullet list with each operation on its own line, making it easy to scan. The opening sentence explains the dispatch pattern. While repetitive (each WRITE/DESTRUCTIVE note is repeated), it is still efficient for a tool with 16 operations. It is arguably longer than necessary, but every line adds the operation name and mutability flag, 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?

Given that an output schema exists and the tool has moderate complexity (16 distinct operations), the description covers all operations, their signatures, and mutability implications. It does not dive into prerequisites or edge-case behaviors, but for a dispatch tool this is a solid level of detail. The lack of annotations and parameter descriptions is partially offset by the operation list.

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 no descriptions (0% coverage), so the description must compensate. It lists parameter names and gives some brief hints (e.g., 'body carries ids', 'body is a list of resources', 'body is an ImportListResource'), which adds meaning. However, many parameters remain unexplained (e.g., 'name', 'force_save', 'force_test'), and the semantics are incomplete. This is a partial compensation, hence a 3.

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

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

The description begins with 'lidarr import lists operations on Lidarr' and then enumerates all 16 operations with specific verbs and resources (e.g., 'Create an import list', 'Bulk delete import lists'). Each operation clearly specifies its action, and the overall scope is unmistakable. This distinguishes it from sibling tools which target different categories (e.g., lidarr_indexers, lidarr_tags).

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 list of operations provides clear context for when to use each operation (e.g., 'lidarr_list_importlist() — List import lists'). The opening instruction 'Pass `operation` and an `arguments` dict' tells the agent how to invoke the tool. However, it does not explicitly contrast with sibling tools or provide 'when not to use' guidance, so it falls short of a 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly labels each operation as WRITE or DESTRUCTIVE, even noting nuances like 'lidarr_test_indexer(force_test=False, body={}) — Test an indexer configuration (body, without saving). WRITE: this modifies your Lidarr instance.' This clearly alerts the agent to side effects. Read-only operations are left unlabelled, implying safety, which is acceptable given the explicit labeling of mutating ones.

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-organized bulleted list where each line is short, consistent, and necessary. It front-loads a general instruction ('Pass operation and an arguments dict...') followed by all 23 operations. No sentence is wasted; the length is justified by the number of operations covered. The formatting improves scanability for an agent.

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

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

Given the complexity (23 operations, 2 generic parameters, output schema present), the description is remarkably complete. It covers every operation in the enum, their parameters, safety labels, and even explains the arguments dict concept. It does not need to explain return values because an output schema exists. The only minor gap is the lack of detailed resource schemas, but that is beyond the scope of a tool description and is likely provided elsewhere.

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 zero descriptions for parameters (0% schema coverage), so the description must compensate. It does so by listing each operation's parameter names and defaults, e.g., 'lidarr_create_indexer(force_save=False, body={})', and sometimes explaining body contents ('body carries ids', 'body is a list of resources'). This adds significant meaning beyond the schema, but it does not fully describe the internal structure of resource objects (e.g., IndexerResource), leaving some ambiguity.

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 each operation with a specific verb and resource (e.g., 'lidarr_list_indexer() — List indexers', 'lidarr_delete_indexer(id) — Delete an indexer'), making the purpose of each sub-operation unambiguous. It fully distinguishes the tool's scope from sibling tools by listing all included operations in a detailed, function-by-function format.

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 implicitly defines when to use the tool: any operation involving Lidarr indexers, delay profiles, or release profiles. It provides clear context for each operation's function, but does not explicitly mention when not to use it or point to alternatives. However, since sibling tools cover distinct domains (e.g., release_search, media_library), the boundary is obvious and the operations are self-explanatory.

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 safety disclosure burden. It explicitly labels WRITE vs DESTRUCTIVE operations, e.g., 'DESTRUCTIVE: this deletes data', and notes additional behaviors like 'add_import_list_exclusion' and 'Preview track renames'. It does not mention permissions or other side effects, but the mutation flags are a strong addition.

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

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

The description is front-loaded with the dispatch pattern and then formatted as a bulleted list, with each operation on one line including its signature and safety flag. It is long due to the number of operations, but each line is dense and free of fluff, making it appropriately concise for the scope.

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

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

For a tool with 26 sub-operations and no annotations, the description provides enough detail to select and invoke the correct operation: names, parameters, query params, and safety classifications. It lacks detailed return-value explanations, but the presence of an output schema may cover that; the main missing element is the structure of body resources.

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 provides generic `operation` and `arguments` fields, so the description is the only source of parameter meaning. It lists specific parameters per sub-operation (e.g., `id`, `delete_files`, `body`) and often explains their purpose, like 'body carries artist ids'. This compensates well for the 0% schema coverage, though detailed body resource schemas are not described.

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

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

The description clearly states it is a dispatcher for 'lidarr media library operations' and enumerates the full set of 'lidarr_*' sub-commands. This distinguishes it from sibling tools by scope and explicitly lists the covered 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?

It instructs to pass an `operation` and `arguments` dict, and each sub-command includes its parameters, implying usage for that action. However, it does not explicitly state when to prefer this tool over alternatives, such as using `lidarr_release_search` for releases or `lidarr_calendar` for calendar data.

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 available, the description carries the burden of disclosing side effects. It explicitly labels write operations and destructive deletions, and clarifies that test operations do not save configurations. It does not mention auth requirements or rate limits, but the safety profile is reasonably 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 opens with a concise dispatch instruction, then presents a structured bullet list that groups all 18 operations. Each line earns its place by providing the operation name and a brief, non-redundant explanation. The formatting is very readable despite the length.

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 operations), the absence of annotations, and an input schema that is nearly empty, the description covers every operation's purpose, marks write/destructive behaviors, and gives parameter hints. An output schema exists, so return values don't need detailed explanation. The tool is fully comprehensible from the description alone.

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

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

The input schema only defines a generic operation enum and a free-form arguments object. The description adds significant meaning by showing function-style signatures for each operation (e.g., 'id', 'force_save', 'body') and noting that body is a MetadataResource or NotificationResource. This compensates for the schema's 0% description coverage, though type details remain high-level.

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

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

The description begins with a clear statement that this tool handles Lidarr notifications and metadata operations, then enumerates every sub-operation with a specific verb and target (e.g., 'lidarr_create_metadata', 'lidarr_list_notification'). This distinguishes it from sibling tools that cover other domains such as release search or media library.

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

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

The description clearly delineates the scope of the tool (notifications and metadata consumers) and lists each operation, making it obvious when to use this tool. However, it does not explicitly name sibling tools or provide exclusionary guidance, so it stops short of the top score.

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 full burden and does well: it labels DESTRUCTIVE operations ('this deletes data') and WRITE operations ('this modifies your Lidarr instance'). It also clarifies what the body parameter should contain (e.g., 'body carries custom format ids'). It does not cover auth, rate limits, pagination, or error handling, but for a dispatcher tool, it gives essential safety information for each action.

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 efficiently structured as a bulleted list. The initial instruction is front-loaded, and each operation is described in a single, dense line. No wasted words: the details (e.g., DESTRUCTIVE/WRITE flags, parameter names) are relevant and precisely formatted. The length is proportionate to the 26 operations being documented.

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 multi-operation dispatcher, the description is highly complete: it documents every operation, marks read vs. write vs. destructive behavior, and lists parameters. It does not describe return values or error handling, but the presence of an output schema (as indicated in context) reduces the need to explain return formats. Overall, it gives an agent enough context to select and invoke any listed operation 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 only defines 'operation' (enum) and a generic 'arguments' dict, offering minimal guidance. The description compensates by providing per-operation Python-style signatures (e.g., 'lidarr_delete_customformat(id)', 'lidarr_update_customformat(id, body={})') and explaining what body should carry (list of resources, ids, etc.). This adds significant meaning beyond the raw schema, making parameter usage clear for every operation.

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 that this tool performs 'profiles formats operations on Lidarr' and enumerates all supported operations (e.g., lidarr_create_customformat, lidarr_delete_qualityprofile). It makes the dispatcher nature explicit with 'Pass operation and an arguments dict'. While it doesn't explicitly contrast with sibling tools, the operation list distinctively scopes it to profiles/formats management, which is clear enough.

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

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

The description provides a clear usage pattern ('Pass operation and an arguments dict matching that operation's parameters') and each operation lists its parameters. However, it does not explicitly state when to prefer this tool over the sibling tools (e.g., for config, tags, etc.). The intended usage is implied by the operation names, but there is no direct exclusion or alternative 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 carries the full burden of behavioral disclosure. It clearly marks destructive operations with 'DESTRUCTIVE: this deletes data' and write operations with 'WRITE: this modifies your Lidarr instance.' It also provides behavioral nuances such as 'Full download queue with all detail, unpaged' versus 'Paged download queue.' This gives substantial insight into side effects and behavior, though it stops short of discussing error handling or rate limits.

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 appropriately structured as a bulleted list of sub-operations. Each line is concise and action-focused, earning its place. A minor improvement would be grouping read vs write operations, but the current structure is scannable and 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?

Given the tool's complexity (9 sub-operations, many parameters) and sparse annotation/schema, the description is remarkably complete. It covers all operations, their parameters, side effects, and query params. An output schema exists (per context signals), which presumably documents return values, so the description does not need to explain those. The description gives an agent enough to select and invoke the correct operation.

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

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

The input schema only defines `operation` and a generic `arguments` dict, so the description is the sole source of parameter details. It lists every sub-operation's parameters with defaults and type hints, and adds meaning by noting which are query params ('Query params: blocklist, skip_redownload') and that `body` carries queue item IDs. This fully compensates for the 0% 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 opens with 'lidarr queue operations on Lidarr' and then enumerates nine distinct sub-operations with descriptive names like 'lidarr_get_queue_details' and 'lidarr_delete_queue'. Each operation has a clear verb and resource, and the overall tool is clearly scoped to queue management. This fully distinguishes it from sibling tools covering different Lidarr 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?

The description explains how to use the tool ('Pass `operation` and an `arguments` dict') and lists all operation names, implying when each sub-operation would be used. However, it does not explicitly state when to use this tool versus alternative sibling tools, nor does it provide exclusions or 'if you need X, use Y' guidance. Usage is implied but not fully explicit.

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

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

With no annotations, the description carries the burden of disclosing side effects. It explicitly marks lidarr_download_release and lidarr_push_release as 'WRITE: this modifies your Lidarr instance,' and describes push_release as interacting with the download client. The other operations are implied read-only, though not stated. No contradiction with annotations exists.

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

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

The description is efficiently organized: a brief usage instruction followed by a dash-separated list of operations. Each entry is one line and minimally worded. Minor redundancy like 'on Lidarr' and 'your Lidarr instance' appears, but overall it earns its place.

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

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

For a multi-operation dispatcher with no annotations and generic schema, the description provides a reasonable overview, parameter guidance, and side-effect warnings. It does not explain return values, but an output schema exists (though not shown). It also doesn't explicitly tie to sibling tools, but the operation set is clear enough for an agent to operate.

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

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

Since the schema only exposes generic `operation` and `arguments`, the description is the sole source of parameter semantics. It lists parameter names per operation (e.g., `title`, `album_id`, `artist_id`, `term`) and indicates body parameters are ReleaseResource. However, there is an inconsistency: lidarr_list_release lists `artist_id` in the signature but only mentions `album_id` as a query param, creating potential confusion.

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

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

The opening line, 'lidarr release search operations on Lidarr,' is somewhat generic and largely restates the tool name. However, the bulleted list concretely defines five sub-operations (download, parse, list, push, search), making the tool's scope clear and distinct from sibling Lidarr tools like media_library or calendar.

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 instructs users to pass `operation` and an `arguments` dict, and each operation includes a one-line description of what it does and its parameters. This helps an agent decide which operation to invoke. It does not explicitly discuss alternatives or when not to use the tool, but the operation list serves as a form of 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?

With no annotations, the description carries the full burden of behavioral disclosure. It explicitly flags write operations with 'WRITE: this modifies your Lidarr instance' and destructive operations with 'DESTRUCTIVE: this deletes data,' and adds a safety note for delete_rootfolder that it does not delete library files. This is solid disclosure for a multipurpose tool.

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

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

The description is a well-formatted bullet list with each operation on its own line, including a one-line explanation and safety flags. The opening sentence is slightly redundant ('lidarr storage operations on Lidarr') but the list structure makes it scannable. Every line earns its place without unnecessary prose.

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 router tool with 10 operations, the description covers each operation's purpose, argument signature, and side effects. It even notes the return of `list_rootfolder` ('with free space and default profile ids'). It lacks examples and detailed return values for other operations, but given the complexity and the presence of an output schema, it is reasonably 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 an open-ended `arguments` object with zero description coverage, so the description must compensate. It does so by showing function signatures for each operation, e.g., `lidarr_create_remotepathmapping(body={})` and `lidarr_delete_remotepathmapping(id)`, indicating the expected argument names and whether they are optional. It does not define the contents of `body`, but the signatures provide meaningful 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 identifies the tool as 'lidarr storage operations on Lidarr' and lists specific storage sub-operations like root folders and remote path mappings. The operation names use clear verbs (create, delete, list, update), making the purpose evident. It does not explicitly contrast with sibling tools, but the storage-specific scope is distinct.

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 how to invoke operations ('Pass `operation` and an `arguments` dict...') but offers no guidance on when to choose this tool over sibling lidarr tools. No alternatives or when-not-to-use scenarios are provided. The operation names imply their usage, but explicit selection criteria are missing.

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 behavioral disclosure. It excels at this by marking destructive operations (delete command, delete backup) and write operations (restart, restore, run command, shutdown) with clear labels like 'DESTRUCTIVE: this deletes data' and 'WRITE: this modifies your Lidarr instance.' It also explains the purpose of read-only operations, though it could add more detail on response behavior or side effects for complex operations like restore/restart.

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 longer than average, but it's well-structured as a bullet list of operations where each line contains the signature and a brief description. The opening line explains the dispatch pattern, and every listed operation earns its place. It is front-loaded with the usage pattern, and the list format aids scanning. The slight length is justified by the number of sub-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?

Given the complexity of a 22-operation dispatcher and the lack of annotations, the description provides a solid overview: it names all operations, gives brief functional descriptions, and marks mutating operations with danger labels. It does not deeply explain edge cases or prerequisites, but the output schema exists to handle return types. Some operations like lidarr_get_system_routes_duplicate could use more context, but overall the coverage is appropriate for the tool's breadth.

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, so the description fully compensates. It lists each operation with its specific parameters, including defaults and example values (e.g., lidarr_list_log(page=1, page_size=10, sort_key='', sort_direction='', level=None) and lidarr_run_command(body={}) with example command names). This goes far beyond the bare schema and gives the agent enough context 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 states it handles 'lidarr system commands operations' and enumerates every available operation with a concise one-line description. This distinguishes it from sibling tools like lidarr_media_library or lidarr_release_search, as it is specifically the system command dispatcher.

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 opening sentence gives explicit instructions: 'Pass operation and an arguments dict matching that operation's parameters.' Each listed operation also includes its parameters, making it clear how to invoke it. While it doesn't explicitly mention alternatives or exclusions, the domain separation from sibling tools is obvious, so the context is clear and practical.

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 marks each operation as WRITE or DESTRUCTIVE, noting that writes 'modify your Lidarr instance' and deletions 'delete data.' This exceeds minimal disclosure, though it omits details like error handling or side effects beyond the operation descriptions.

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 concise introductory line followed by a well-organized bullet list of operations. Each line is short and contributes necessary information. Though the length is considerable (18 operations), this is justified for a dispatcher tool and avoids redundancy.

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

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

For a complex multi-operation tool, the description is reasonably complete: it enumerates all sub-operations, indicates read/write/delete behavior, and references an output schema (which presumably documents return values). It lacks deeper parameter details and usage scenarios, but these are less critical given the structured list and output schema presence.

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 two parameters (operation and arguments) with 0% schema description coverage. The description adds value by listing each operation's signature (e.g., 'lidarr_create_autotagging(body={})') and for one operation clarifies that body is an AutoTaggingResource. However, it does not define the structure of the 'arguments' dict or body fields for most operations, leaving significant gaps.

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 a dispatcher for Lidarr tag-related operations, listing all 18 specific sub-operations. This differentiates it from sibling tools that focus on other areas (release search, media library, etc.). The verb 'operations' is broad, but the exhaustive list makes the purpose unambiguous.

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

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

The description does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions. However, the list of tag-related operations implies its use case compared to siblings. It also instructs how to invoke sub-operations, but lacks context about when a particular operation 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=true, and the description adds useful behavioral context: single-item fetch vs paginated lists, cutoff/missing distinctions, pagination defaults, and the monitored filter. It does not contradict annotations and provides meaningful detail beyond the structured fields.

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

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

The description is well-structured with a one-line summary followed by a compact bullet list of operations. Each line earns its place, providing signatures and defaults without unnecessary prose.

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

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

Since an output schema exists, return-value details are not needed. The description covers all operations, parameters, and defaults, and read-only behavior is annotated. A concrete example of the arguments dict or explicit error/return notes would add marginal value, but the description is sufficiently complete for a dispatcher-style 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%, but the description compensates by listing all operation-specific parameters with defaults in the function signatures and identifying query params. Some semantics (e.g., sort_key values, meaning of monitored) are implicit from names, but the dispatch structure is clarified well.

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

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

The description clearly states it covers Lidarr 'wanted' operations and enumerates four specific sub-operations with distinct verbs and resources (get/list, cutoff/missing). This distinguishes the tool from sibling domains and makes the exact purpose unambiguous.

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

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

The description explains how to invoke the tool ('Pass operation and an arguments dict matching that operation's parameters') and lists all operations with their parameters. It does not explicitly state when to prefer this over siblings, but the domain is distinct and sibling tools are non-overlapping.

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