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

No annotations are provided, so the description carries the burden. It lists HTTP methods (GET, POST, PUT, DELETE) which imply mutating vs read-only behavior, and it includes a dry-run and preview operation. However, it doesn't disclose any side effects, permissions, rate limits, or what happens on deletion (e.g., whether it's reversible). The method hints are useful but not comprehensive.

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

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

The description is a single paragraph with a clear instruction and a bulleted list of operations corrected with endpoints post-pended, which is efficient. However, it could be improved by summarizing the common pattern more concisely and perhaps grouping operations (e.g., list vs. mutate). The list of 12 operations is necessary for enumeration but adds 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?

With no annotations and a low schema description coverage, the description must provide full context Sports. It gives the dispatch mechanism and lists all operations with endpoints, which is helpful. However, it lacks details on the actual arguments for each operation (e.g., required path parameters like instanceID and ruleID are not explicitly documented, though they appear in endpoints). It also doesn't describe return values, though an output schema exists (which helps). Overall, it's adequate but leaves gaps.

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

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

The schema has only two parameters: `operation` (an enum of all operations) and `arguments` (a free-form object). The description explains that `arguments` should contain path variables, query params, and body, but it doesn't detail what each operation expects within those arguments. Since schema coverage is 0%, the description must compensate, but it only lists endpoints without parameter specifics. For example, it doesn't explain what fields each automation operation requires, leaving significant 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 states that this tool handles automation operations, and it lists all 12 operations with their HTTP methods and endpoints, which identifies what it does. However, it does not explicitly distinguish from sibling tools beyond the domain of automations; siblings like qui_torrents and qui_instances are clearly different domains, so the purpose is distinct but not explicitly differentiated.

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

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

The description provides a clear usage pattern: pass `operation` and an `arguments` object, with detailed instructions on where path variables, query values, and JSON body go. It implicitly says when to use this tool (any automation-related operation) but doesn't explicitly state when-not-to-use or alternatives, as the sibling tools are for other domains.

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 of behavioral disclosure. It reveals HTTP methods and endpoints, which imply destructive operations like `qui_delete_all_backup_runs`, but it does not warn about irreversible deletion, permissions, side effects, rate limits, or response behavior.

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

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

The description is compact and scannable: one short instruction paragraph followed by a bullet list of ten operations with method and path. The opening sentence is slightly redundant with the tool name, but every other line contributes necessary endpoint mapping information.

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

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

Given the high complexity of ten distinct operations and the generic `arguments` schema, the description provides a useful operation-to-endpoint map and general argument conventions. However, it lacks operation-specific parameters such as required query strings or request body schemas, leaving some invocations under-specified. The existence of an output schema reduces the need to document return values, but does not fill this gap.

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

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

The input schema only has an enum and a generic `arguments` object with 0% description coverage, so the description must compensate. It does so by explaining the argument envelope—path variables in `arguments`, query values in `arguments.params`, and body in `arguments.body`—and mapping each operation to its endpoint path with visible path parameters. It still omits per-operation query and body field details, but the provided structure is significantly useful.

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 ten backup-related operations with their exact HTTP methods and paths, making it clear this tool exposes qui backup REST endpoints. It distinguishes from sibling tools by the backup domain and consistent qui_ prefix, though the opening phrase 'qui backups operations on qui' is somewhat tautological.

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 context by listing all backup operations and explaining how to invoke them with `operation` and `arguments`. It does not provide explicit guidance on when to prefer this tool over sibling qui_* tools or mention exclusions, so the guidance is implied rather than stated.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It lists HTTP methods (GET, POST, PUT, DELETE) which imply side effects (reads vs. writes), but it does not explicitly state whether operations are destructive, require authentication, or have rate limits. It also does not describe error behavior or response formats. This lack of transparency is a significant gap for a tool with multiple mutating operations.

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

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

The description is concise and well-structured. It starts with the general dispatch rule, then lists each operation in a clean format with method and endpoint. There is no redundant or filler content; every sentence and line contributes value.

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

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

The tool is complex with 7 operations, and the description provides a clear dispatch pattern and endpoint list. However, it does not explain the return values (though an output schema exists), nor does it cover authentication, permissions, or specific argument requirements beyond the generic pattern. It is complete enough for basic usage but lacks depth for edge cases or error handling.

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

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

The input schema has 0% coverage, so the description must compensate. It provides a general pattern: path variables go in arguments, query values in arguments.params, and JSON body in arguments.body. It also lists endpoints that indicate required parameters (e.g., {instanceID}). However, it does not detail the exact arguments structure for each operation, leaving the agent to infer from operation names and endpoint templates. This is minimally adequate but not comprehensive.

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 'qui categories tags operations' and enumerates each specific operation with its HTTP method and endpoint (e.g., 'qui_create_category: POST /instances/{instanceID}/categories'). This is specific enough to distinguish it from sibling tools that manage other resources (torrents, RSS, etc.). However, it does not elaborate on the semantic purpose of each operation beyond its name, so it's not a perfect 5.

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

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

The description explains how to invoke the tool (pass `operation` and `arguments`, with path variables in arguments, query in arguments.params, body in arguments.body), but it does not explicitly state when to use this tool versus alternatives. The usage is implied by the operation names and endpoints, but there is no guidance on prerequisites, exclusions, or when a sibling tool would be more 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?

With no annotations, the description carries the burden of behavioral disclosure. It details how arguments are formatted (behavioral for invocation) and lists HTTP methods (POST, DELETE, etc.), which implies side effects, but it does not explicitly state outcomes (e.g., 'this creates a blocklist entry' or 'this modifies settings') or safety considerations. The operation names hint at effects, but the description itself does not elaborate on consequences, auth needs, or reversibility.

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 essential usage pattern and then lists all operations. Each line is a necessary mapping of operation to endpoint. It is efficient without redundancy, though the list is long. The structure is logical and skippable, making it concise for its purpose.

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 (29 operations) and lack of annotations, the description is remarkably complete: it explicitly maps every operation to an HTTP method and path, and explains the argument structure. Since an output schema exists, return values are not the description's responsibility. For a generic API dispatcher, no critical information is missing.

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

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

Schema coverage is 0% in the description, but it compensates by explaining the generic argument pattern: path variables go directly, query values in arguments.params, and body in arguments.body. This adds critical meaning not present in the schema (which just has an open object). It does not detail per-operation parameters, but for a generic dispatcher, the pattern is sufficient.

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 as 'qui cross seed operations on qui' and enumerates 29 specific operations with HTTP endpoints. This precisely defines the tool's scope as a dispatcher for cross-seed API calls, distinguishing it from sibling tools like qui_torrents or qui_system.

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 usage context by explaining the argument structure (path variables go directly, query params in arguments.params, body in arguments.body) and maps each operation to an HTTP method. It implies use for cross-seed tasks, but does not explicitly state when to avoid using it (e.g., 'use qui_torrents for torrent-specific actions'). Exclusions are missing, but context is strong.

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?

There are no annotations, so the description carries the transparency burden. It reveals behavioral intent through operation names and HTTP verbs (DELETE, POST, GET, PATCH) and endpoint paths, making it clear which operations read, mutate, delete, create, or requeue. However, it does not describe side effects such as whether deletes are permanent, what a scan cancellation does, or whether these actions require elevated permissions, so the behavioral picture is only partially painted.

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 every line is a one-to-one operation/endpoint mapping that is useful. The first two sentences front-load the invocation pattern, and the list is sorted and consistently formatted. No filler or repetition exists, though the list of 15 endpoints is necessarily dense.

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

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

Given this is a multi-operation dispatcher with 15 endpoints, the description provides a good enumeration plus argument structure rule. However, it does not describe per-operation required parameters, the outcome of each operation, or any caveats needed for safe use. The presence of an output schema removes the need to detail return values, but the behavioral gaps in such a complex tool mean the description is only moderately complete.

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

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

Schema description coverage is 0%, so the description must add meaning. It does exactly that by explaining how to structure `arguments`—path variables in `arguments`, query values in `arguments.params`, and request bodies in `arguments.body`. This is essential and not present in the input schema. It stops short of documenting per-operation argument names, but the endpoint templates show those placeholders.

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 'qui dir scan operations on qui' and then enumerates 15 concrete operations with endpoints, making it clear that this tool dispatches directory-scan operations. It distinguishes itself from siblings like qui_orphan_scan by focusing specifically on directory scan resources. It lacks a single verb+resource framing but the operation list fully clarifies scope.

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

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

It provides clear instructions for how to invoke the tool: pass an `operation` and an `arguments` object, with path variables, query values, and body placed in the appropriate nested locations. It also lists the exact operations, giving an explicit scope and exclusion boundary—this tool covers dir-scan operations and nothing else. There is no explicit guidance on when to prefer a sibling alternative, but the clear domain and operation set are enough.

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 must carry the full burden. It reveals the tool is a router/aggregator for multiple sub-operations, which is critical behavioral info. However, it does not disclose mutation risks (e.g., qui_delete_instance permanently deletes, qui_update_instance modifies settings) or whether operations are safe/idempotent. This is a significant gap for a tool with 17 operations, many of which are mutating.

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 list is compact and front-loaded with the general pattern, then each operation with its endpoint. It's efficient for a router with 17 operations. The opening two sentences explain the calling convention. The list is a necessary enumeration for completeness, though it makes the description long; still, every item adds value.

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

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

Given the tool's complexity (17 operations) and absence of annotations, the description gives the operation list and basic argument structure, but lacks per-operation parameter details, expected responses, or error handling. It has an output schema, which partially compensates. For an agent to correctly call this tool, it needs more per-operational detail (e.g., required fields for qui_create_instance), so it's only minimally complete.

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

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

Schema has 2 params: operation (enum) and arguments (loose object with anyOf null). The description adds crucial semantics for arguments: path variables go directly, query values in arguments.params, JSON body in arguments.body. This is genuinely helpful. However, it does not explain per-operation argument requirements (which operations need instanceID, what fields for creation/update), leaving the agent to infer from endpoint paths. Schema coverage is 0%, so more compensation was needed.

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

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

The description enumerates 17 operations with their HTTP endpoints, clearly indicating this is a dispatch router for instance-related actions. It specifies the resource (instances) and the action spectrum, distinguishing it from sibling tools that target other domains (torrents, RSS, backups). However, it lacks a general one-line summary, relying on the list to convey 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 implies usage: pass the operation and an arguments object with path variables, query params, and body. It does not explicitly state when to use this tool versus alternatives (e.g., qui_torrents for torrent-specific actions). The context implies all instance operations go here, but exclusions or comparator guidance are 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?

No annotations are provided, so the description carries the full burden. While it reveals HTTP methods (DELETE, POST, GET, PUT) implying mutating vs. read operations, it does not disclose side effects, destructive consequences, authentication needs, or response implications. For operations like cancel or confirm, destruction is implicit but not stated.

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 starts with a concise instruction on how to pass operations and arguments, then presents a clear list of sub-operations with methods and endpoints. It is reasonably concise and well-organized, though slightly verbose due to the repetition of 'qui_' prefixes.

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 tool with no per-operation documentation, the description is incomplete. It does not specify required arguments for each operation, expected return values (though output schema exists), side effects, or error conditions. The description is merely an endpoint list and a routing pattern, leaving significant gaps.

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

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

The description explains the generic pattern for arguments (path variables, query params, body) but does not detail the specific parameters required for each operation. Since input schema coverage is 0%, the description should compensate, but it only offers a template without per-operation parameter semantics.

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

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

The description clearly states it handles orphan scan operations on qui, listing seven specific sub-operations with HTTP methods and endpoints. This distinguishes it from sibling tools by domain, though it lacks a single concise summary sentence and instead uses a 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?

It gives usage context by implying the tool is for orphan scan management and instructs how to pass operations and arguments, but does not explicitly state when to use this tool versus other qui_* tools or when not to use it. No alternatives are mentioned.

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

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

No annotations exist, so the description must carry the behavioral burden. It partially does by exposing HTTP methods (GET vs POST/PUT/DELETE), which indicate read vs mutating operations, and by showing exact endpoint templates. It does not disclose side effects, permission needs, reversibility, or error behavior for the mutations.

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 concise usage instruction followed by a clear bulleted list of 14 operations with endpoints. The list is long but necessary for a dispatcher tool, and the format is scannable. A plain-language gloss per operation would improve it, but current structure earns its place.

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

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

The tool has an output schema, so return values are covered elsewhere. The description provides a complete operation inventory, HTTP methods, and path/query/body conventions, which is substantial for a dispatcher. It is slightly incomplete due to missing per-operation purpose details or permission/error context, but adequate for basic 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%, but the description compensates somewhat by explaining the structure of the free-form arguments object, including path variables, query params, and body. It does not enumerate operation-specific parameters beyond endpoint path variables, so the agent still lacks detailed per-operation parameter semantics.

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

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

The description clearly states the tool is for "qui rss operations on qui" and enumerates all operations with HTTP endpoints, making the RSS domain and actions (add, get, remove, rename, etc.) explicit. It differentiates from sibling tools by focusing exclusively on RSS operations, though the broad dispatcher form makes it slightly less sharp than a single verb+resource description.

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

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

The description gives concrete invocation guidance: "Pass `operation` and an `arguments` object; path variables go directly in arguments, query values in arguments.params, and a JSON request body in arguments.body." However, it does not explicitly state when to prefer qui_rss over sibling tools or how to choose among the listed operations beyond their names and endpoints.

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 behavioral details are provided. The description only lists HTTP methods and paths, without explaining side effects, permissions, side effects, or what each operation does. Since no annotations are present, the description carries the full burden and fails to disclose any behavioral traits.

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

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

The description is efficient in that it avoids redundant prose and simply lists the operations with their HTTP methods. It is well-structured as a list, making it easy to scan, though the length is inherent 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?

Given the large number of operations and a generic schema, the description is severely incomplete. It does not provide per-operation inputs, outputs, or error conditions. There is no mention of return values or expected outcomes, making it impossible to understand how to use each operation effectively.

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

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

The description explains that 'arguments' contains path variables, query params, and a request body, which gives some structure to the generic arguments object. However, it does not specify which arguments each operation expects, and the schema has no per-operation parameter definitions. The explanation is generic and not very helpful for understanding required 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 simply states 'qui system operations on qui' and then lists a long series of endpoint names without explaining what the tool actually does as a whole or what each operation accomplishes. It fails to convey the purpose beyond being a generic API wrapper for many unrelated 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?

There is no guidance on when to use this tool versus the sibling tools (e.g., qui_cross_seed). The description provides no context for selecting this tool or specific operations within it, aside from the raw list of endpoints.

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 discloses the HTTP methods (POST, DELETE, GET) which imply side effects, but it doesn't state whether operations are destructive, require authentication, or have rate limits. The description adds minimal behavioral context beyond the endpoints.

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

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

The description is concise and front-loaded with the key usage pattern, followed by a clear list of operations. Each line is informative, though the list format is a bit dense but acceptable.

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 and a moderate number of operations, but the description doesn't explain return values or error handling. It covers the operation list and argument passing, but lacks details on prerequisites or side effects, making it adequate but not complete for a multi-operation 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%, and the description does not explain the parameters beyond the generic 'arguments' object. It mentions path variables, query values, and body, but doesn't detail what each operation expects (e.g., instanceID, taskID). The description fails to compensate for the lack of schema documentation.

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

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

The description clearly states the tool performs 'qui torrent creator operations' and lists four specific operations with their HTTP endpoints. It distinguishes from siblings by naming the resource (torrent-creator) and the operations, though it doesn't explicitly contrast with sibling 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 how to pass arguments (path variables, query params, body) and lists the operations, which implies when to use each. However, it doesn't provide explicit guidance on when to choose this tool over alternatives or when not to use it, leaving usage context implicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not state whether operations are read-only or mutating, what side effects occur (e.g., adding peers, renaming torrents), any authentication or permission requirements, rate limits, or error behaviors. While endpoint methods (GET, POST, PUT, DELETE) hint at mutations, this is implicit and not explicitly 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 efficiently structured with a clear introductory sentence followed by a bulleted list of operations. It is front-loaded with the key usage pattern and then lists endpoints concisely. It avoids fluff, but the list is long; however, this is necessary for the tool's 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?

Given the tool has 24 operations, a generic arguments object, no annotations, and an output schema (not described), the description is moderately complete. It explains the general argument structure and lists all operations with endpoints, but it lacks per-operation detail (required vs optional params, expected outputs, specific constraints) which is crucial for an agent to correctly invoke this tool. The output schema existence suggests detailed return types, but the description doesn't reference it.

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

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

The input schema has only two parameters: 'operation' (an enum) and 'arguments' (a generic object). Schema description coverage is 0%, meaning the description must compensate. The description explains the structure of 'arguments' (path variables, query params, body) but does not detail the required fields for each operation, leaving the agent to rely on the operation names and endpoint patterns. This is adequate but not comprehensive given the complexity of 24 operations.

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 handler for all torrent-related operations on the 'qui' system, enumerating 24 distinct operations with their HTTP endpoints. It distinguishes this tool from sibling tools by focusing exclusively on torrent operations (as opposed to system, instances, RSS, etc.), and the verb+resource pattern is explicit for each operation.

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

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

The description provides a general usage framework—requiring 'operation' and 'arguments' with path variables, query params, and body—but it does not offer specific guidance on when to choose one operation over another or when to use an alternative sibling tool. It implies usage through the operation list but lacks explicit context or exclusions.

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

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

No annotations are provided, and the description gives no information about side effects, permissions, rate limits, or other behavioral aspects. Operations like 'create', 'delete', and 'update' are clearly mutating, but the description does not disclose any potential consequences (e.g., irreversible changes, authentication requirements, or resource impacts). This leaves the agent uninformed about the tool's behavior.

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 list of operations with HTTP methods and paths, which is informative but repetitive (e.g., every operation starts with 'qui_'). The introductory sentence is ambiguous ('qui torznab operations on qui') and adds little value. While the list is fairly structured, the overall presentation could be more concise and clearer, but it is not excessively verbose.

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

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

For a tool with 20 distinct operations, varying HTTP methods, and a complex arguments object, the description is extremely incomplete. It does not explain the output schema, error handling, authentication, or any domain-specific details. The tool appears to be a comprehensive Torznab client, yet the description provides almost no context to help an agent use it effectively. This is a critical gap in completeness.

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

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

The input schema only defines two parameters: 'operation' (an enum) and 'arguments' (an object). The description explains that arguments can contain path variables, query parameters, and a request body, which provides some semantics. However, it does not detail what specific fields each operation requires in the arguments object, nor does it clarify the structure or types of these nested parameters. Parameter semantics are therefore insufficient for an agent to construct valid calls.

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 is extremely vague, stating only 'qui torznab operations on qui.' While the list of operations (create, delete, get, search, etc.) implies a Torznab API client, it does not explicitly define the tool's overall purpose or what Torznab is. This lack of a clear, high-level purpose makes it difficult for an agent to understand when to use this 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 provides a generic calling convention: 'Pass operation and an arguments object; path variables go directly in arguments, query values in arguments.params, and a JSON request body in arguments.body.' This explains the structure of arguments but offers no guidance on when to use this tool versus sibling tools (e.g., qui_system, qui_cross_seed). There is no indication of which operations are appropriate for specific scenarios, making usage guidance incomplete.

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