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 reveals that the tool modifies feeds.json, that this triggers qBittorrent searching, and that it fails on duplicates unless overwrite is set. It does not cover permissions or return value, but the core side effects and failure mode are transparent.

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

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

Three compact sentences, front-loaded with the main purpose and followed by the two key behavioral details. No filler or redundant restatement of the schema.

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

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

For a straightforward mutation with no output schema, the description covers the target, the side effect, parameter defaults, and the duplicate-failure condition. Minor gaps like the expected imdb_id format or behavior when a profile does not exist are not explicitly stated but are largely inferable.

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

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

Schema description coverage is 0%, so the description must compensate. It adds real meaning for indexer, describing its default resolution order, and for overwrite, describing its effect on duplicate ids. profile and imdb_id are largely self-explanatory from their names and the first sentence.

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

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

States a specific verb and resource ('Add an IMDb id to a queue profile's feeds.json') plus the intended effect ('so qBittorrent starts searching for it'). This clearly distinguishes it from siblings like remove_from_queue and list_queue.

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

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

The description gives clear context for when to use it: when an IMDb id should be queued for searching. It also explains the overwrite behavior for already-queued ids. It does not explicitly name alternatives, but the operation and failure semantics make the intended usage clear.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It transparently explains that files are moved, that selection is by extension, and that environment variables are used as fallback. However, it does not disclose potential side effects such as irreversibility, overwrite behavior, permission requirements, or what happens when no files match.

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

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

Two concise sentences with the core action front-loaded and the fallback behavior in a separate sentence. Every word earns its place, with no repetition of schema information or unnecessary detail.

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

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

For a simple two-parameter tool, the description conveys the main behavior and configuration fallback. However, the vague phrase 'by extension' and the lack of detail on collisions, missing files, or return behavior leave gaps that an agent might need to know before invoking it confidently.

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 must compensate. It does so by linking source_dirs and dest_dir to ARCHIVE_SOURCE_DIRS and ARCHIVE_DEST_DIR, clarifying that they override environment defaults. It does not describe expected path formats or how multiple source directories are handled, but it provides meaningful semantic context.

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

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

The description states a specific action ('Move finished downloads'), identifies the resource ('download client's folders'), and names the destination ('the archive'). It clearly differentiates this from the sibling tools, none of which perform archiving.

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

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

The description implies the tool is for archiving completed downloads, but it does not explicitly state when to prefer it over alternatives or describe prerequisites beyond environment fallback. The usage context is clear enough from the action, but exclusions and alternatives are left unstated.

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 explaining behavior. It transparently discloses that a timestamped file is created and that the operation is a backup, which implies the original is not modified. However, it does not state what happens when dest_dir is null, whether directories are created, or what the command returns.

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, front-loaded sentence with no unnecessary words. It efficiently communicates the action, the resource, and the output format.

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 no output schema and no annotations, so the description must be contextually sufficient on its own. It leaves important gaps: the default behavior of dest_dir is unstated, there is no indication of how to identify a valid profile, and the result or return value is not described. These are material gaps for an agent selecting and invoking the tool.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that 'profile' refers to a queue profile and that the backup target is a timestamped file, but it does not explain the semantics of the optional 'dest_dir' parameter, including what a null value means or where the backup goes by default.

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

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

The description states a specific verb ('back up'), a specific resource ('a queue profile's feeds.json'), and a concrete outcome ('to a timestamped file'). This clearly distinguishes it from the listed siblings, which cover listing, searching, and queue mutation rather than backup.

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

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

There is no guidance on when to use this tool versus alternatives, no mention of prerequisites like first listing profiles, and no warning about destructive or non-destructive usage. The description simply defines the action without situating it in a workflow.

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

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

The description explains the main behavior: splitting IDs into three categories and optionally checking a Plex XML export. Since no annotations are provided, the description carries the burden, and it does convey that this is a checking/comparison operation. However, it does not disclose whether the operation is strictly read-only, what happens to uncategorized IDs, or how the Plex XML path is interpreted.

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

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

The description is two short sentences with no filler. The main purpose is front-loaded, and the optional parameter explanation is separated cleanly. Every part of the description 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?

With no output schema and no annotations, the description should explain enough to invoke the tool correctly. It gives the high-level behavior but omits the meaning of the required profile parameter and does not describe the output shape or category representation. This leaves important context missing for a new agent.

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

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

Schema description coverage is 0%, so the description must compensate. It explains plex_export_xml and references IMDb ids for the imdb_ids parameter, but the required profile parameter is not described at all. An agent is left guessing what profile means and how it relates to the queued state, which is a meaningful gap.

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

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

The description clearly states a specific verb and resource: 'Split a list of IMDb ids into already-queued, already-in-Plex, and new.' This makes the tool's function obvious and distinguishes it from queue-mutating siblings like add_to_queue or remove_from_queue. It does not explicitly name or contrast with related siblings like find_imdb_candidates, so it stops short of 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 implies when the tool should be used: whenever you need to categorize IMDb IDs against existing queues and Plex data. It gives one concrete usage hint for the optional plex_export_xml parameter, explaining when to pass it, but it does not mention when to prefer or avoid this tool relative to its 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?

There are no annotations, so the description carries the full burden of explaining behavior. It clearly conveys a non-mutating capability check, but it does not state whether this queries a live indexer, whether it can fail, or what side effects (if any) might occur.

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

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

The description is a single sentence with no wasted words. It front-loads the core action and resource, making it easy for an agent to parse quickly.

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

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

For a one-parameter tool with no output schema or annotations, the description covers the basic purpose but omits return value semantics and any context about how to obtain a valid indexer_id. It is minimally viable but has clear 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 input schema has 0% description coverage, and the description does not explain the indexer_id parameter beyond referring to 'a Jackett indexer.' It adds minimal context but no format guidance, examples, or clarification of where the id comes from.

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

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

The description uses a specific verb and resource: 'Check whether a Jackett indexer supports searching by IMDb id.' This clearly states the tool's function and is distinct from siblings like check_candidates or find_imdb_candidates, which have different purposes.

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

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

The description gives no guidance on when to use this tool versus alternatives, and it does not mention any prerequisites or exclusions. The only implied usage is the obvious one: use it when you need to know about IMDb id search support.

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

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

There are no annotations, so the description carries the behavioral burden. It explicitly discloses a read-only one-way diff and the direction of comparison. It doesn't mention file formats or error behavior, but the core behavior is transparent enough for an agent to understand the operation.

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

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

A single sentence with no filler; the action, resource, and comparison criterion are all present and front-loaded. Every word earns its place.

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

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

For a two-path diff tool with an output schema, the description gives enough context to invoke it correctly: inputs are paths to two exports and the result is the set of URLs missing from the newer one. Minor gaps around export format and output ordering remain but are not blocking for selection or invocation.

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

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

The description maps old_export_path to the old library export and new_export_path to the newer one, and adds that the content involves IMDb title URLs. However, schema description coverage is 0%, and the description does not explain expected file format, URL representation, or path semantics beyond the parameter names.

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

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

Uses a specific verb and resource: 'List IMDb title URLs' with a precise comparison condition (present in old export, missing from newer). This clearly distinguishes it from sibling tools like find_duplicate_filenames, which compare filenames, and the queue/indexer tools, which operate on different resources.

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?

Clearly implies when to use it: when you have an old and a new library export and want to find IMDb title URLs that disappeared between them. It does not name alternatives or state when not to use it, but no sibling offers the same diff behavior, so the context is sufficiently clear.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does reveal a heuristic matching behavior ('likely') and extension-insensitive comparison via the example, but it does not disclose whether the operation is read-only, how matching is performed, or how results are grouped.

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, front-loaded sentence with a useful parenthetical example. Every word earns its place, and there is no redundant language or restatement of the tool name.

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

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

With no annotations and no parameter descriptions, the description must provide most of the context, but it leaves threshold semantics and behavioral expectations undefined. Although an output schema exists, the description alone is not complete enough for an agent to confidently invoke the tool with correct parameters.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It only indirectly explains 'directory' via 'media directory' and gives an example of duplicate filenames, but it never explains the 'threshold' parameter or how it influences duplicate detection.

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

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

The description states a specific action ('Find'), a clear resource ('likely-duplicate filenames'), and a context ('media directory'). The example 'movie.avi vs movie.mp4' makes the matching concept concrete and distinguishes it from sibling tools like find_largest_torrent or find_imdb_candidates.

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

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

The description implies when to use the tool: when checking a media directory for files that may represent the same content under different names. However, it does not explicitly state when to prefer it over alternatives or provide exclusion criteria, so usage guidance is only 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?

No annotations are provided, so the description carries the full burden. It discloses that the tool scrapes an external IMDb page, which implies a network read, but it does not mention whether the operation is read-only, potential rate-limit or page-block risks, error behavior, or any side effects. For a scrape operation, this is a significant disclosure gap.

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?

One sentence, front-loaded with the action verb, includes a clarifying example, and contains no redundant filler. Every word contributes to understanding the tool's 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?

The tool is simple with a single parameter and has an output schema to define return values, so the description need not explain output. However, it omits usage boundaries and behavioral caveats that would help an agent select and invoke it safely. It is adequate for a simple tool but not complete.

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

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

The schema only defines list_url as a required string with no description (0% coverage). The description compensates by specifying that it must be an IMDb list page and offers a concrete example, so the agent knows the expected URL shape. However, it leaves ambiguity about URL format and supported list types, so compensation is only partial.

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

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

The description clearly states the action (scrape), the target resource (IMDb list page), and the outcome (title ids). The example ('coming this year' list) makes the function immediately understandable. It does not explicitly name sibling tools, but the operation is clearly distinct from the title-search and queue-management siblings.

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

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

The example 'coming this year list' implies when to use the tool, but there is no explicit statement of when to prefer it over alternatives like search_title, lookup_title, or check_candidates. No exclusions are given, so guidance is inferred 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 present, so the description must carry the burden of behavioral disclosure. It reveals the search/find nature and the size-based heuristic, but does not explicitly state that the operation is read-only, what happens with no matches, or whether it queries the indexer directly. The basic behavior is clear but not deeply transparent.

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

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

A single front-loaded sentence with no redundant words. The verb and target come first, and the parenthetical adds the key heuristic without bloating the description.

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

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

The tool is simple and has an output schema, so return values are covered. However, the description omits usage guidance and any mention of related tools or prerequisites (e.g., where indexer_id comes from), leaving the agent with an adequate but incomplete picture.

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 zero description coverage, and the description only restates the two parameter names in prose ('IMDb id' and 'one indexer') without providing formats, acceptable values, or how to obtain an indexer_id. For a low-coverage schema, the description does not meaningfully compensate beyond the property names.

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

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

The description specifies a concrete action (find), a precise target (largest-sized search result), and scoping (for an IMDb id on one indexer). The parenthetical clarifies the selection heuristic, making it easy to distinguish from generic siblings like search_torrents or find_imdb_candidates.

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

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

No explicit when-to-use or alternatives are provided; the description only implies the tool is for selecting the single largest result on one indexer. It does not mention when not to use it or contrast it with search_torrents, so guidance is only 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, the description carries the full behavioral burden. The words 'Guess' and 'via OMDb' convey approximation and an external dependency, but there is no disclosure of failure modes, rate limits, required keys, or whether this is a read-only network call.

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?

A single front-loaded sentence contains the action, target, input example, and data source with no filler. Every phrase earns its place.

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

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

The tool is simple and has an output schema, but it lacks context that matters for an external fuzzy lookup: what year is for, what happens on no match, network/API considerations, and when to choose a sibling instead. The description is too sparse for an annotation-free tool.

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

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

Schema description coverage is 0%, so the description must compensate. It maps title_hint to 'messy title', but it never explains the optional year parameter, its disambiguation purpose, or expected formats, leaving part of the schema unexplained.

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

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

The description uses the specific verb 'Guess' with a concrete resource, 'the IMDb id/title for a messy title,' and adds a clarifying example ('cleaned-up filename'). It clearly indicates what the tool does, though it does not explicitly name or contrast sibling search/lookup tools.

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

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

It implies the tool is appropriate for messy, non-canonical inputs and clarifies the source is OMDb. However, it gives no explicit guidance about when to prefer this over sibling tools like lookup_title or search_title, and no 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?

With no annotations, the description carries the burden of indicating behavior, and 'List' makes the read-only nature apparent. However, it does not disclose that the default configured_only=true limits the result to configured indexers, which is material to interpreting the returned data.

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

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

The description is one short, front-loaded sentence with no filler words. Every word contributes to identifying the tool's action and object.

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

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

For a simple read-only list with one optional boolean and an output schema, the description is close to sufficient. It is incomplete because it does not clarify the effect of the configured_only parameter or reconcile 'known to the server' with the default configured-only behavior.

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

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

Schema description coverage is 0% and the description does not mention configured_only or explain that it filters the listed indexers. The schema's title and default provide some meaning, but the description adds nothing beyond the tool's overall subject.

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

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

The description uses a specific verb and resource: 'List Jackett indexers known to the server.' It clearly identifies the tool as a listing operation for indexers and is not a tautology. It does not explicitly differentiate from sibling listing tools such as list_profiles, but the resource is sufficiently 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 provides no guidance on when to use this tool instead of a sibling such as switch_indexer or search_torrents, and it never mentions the configured_only parameter or when to toggle it. Usage context is entirely 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?

With no annotations provided, the description carries the full burden. 'List' clearly implies a read-only, non-mutating operation, and 'configured' indicates it reads existing configuration. However, it does not mention ordering, empty results, errors, or any prerequisites, though for a simple list tool these gaps are minor.

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?

A single, front-loaded sentence states the action, the resource, and illustrative examples without any wasted words. Every element contributes to understanding the tool.

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

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

This is a simple zero-parameter read-only listing tool with an output schema available. The description fully covers what the tool does and what kind of results to expect, so an agent has enough information to invoke it correctly.

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

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

The tool has zero parameters, so the schema provides no semantics to clarify. The description is not required to explain parameters, and the baseline of 4 applies. The examples add useful context about the kind of values that will be returned.

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

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

The description uses a specific verb ('List') with a precise resource ('configured queue profile names') and provides concrete examples ('movies', 'series'). This clearly distinguishes it from sibling tools like list_queue and list_indexers.

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

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

Usage is implied: call this when you need the set of known queue profile names. However, the description does not explicitly state when to use it versus alternatives, nor does it mention any related workflow such as using the returned names as valid inputs to other queue-related 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 provided, the description is the only source of behavioral information. It does disclose the listing behavior and the OMDb enrichment tradeoff, and 'List' strongly implies a read operation. It does not mention pagination, ordering, error behavior, or authentication, though the existence of an output schema mitigates some of this.

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

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

A single concise sentence front-loads the core action, then adds the only optional behavior worth knowing. No repeated schema information and no filler.

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

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

For a simple two-parameter list operation with an output schema, the description covers the essential action and the one behavioral option that affects output and speed. It leaves out edge cases like invalid profile handling, but the low complexity and output schema make the description sufficiently complete for selecting and invoking the tool.

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

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

Schema coverage is 0%, so the description carries the parameter-semantics burden. It clearly explains resolve_titles beyond the schema, noting both the effect (include title/year) and the performance cost (slower). The profile parameter is given meaning through the phrase 'a queue profile's entries,' though its accepted values are not specified.

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

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

The description names a specific verb ('List') and a specific resource ('a queue profile's entries'), which clearly distinguishes it from sibling tools like list_profiles (which lists profiles) and add_to_queue/remove_from_queue (which modify the queue). The optional resolve_titles behavior further cements what the tool does.

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

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

The description implies when to use the tool—whenever you need the entries of a queue profile—and its optional resolve_titles flag provides context for a performance tradeoff. However, it does not explicitly contrast it with list_profiles or other sibling tools, or state when the enriched resolve_titles mode should be chosen.

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 burden. It discloses the core behavior and output fields, and 'via OMDb' implies an external lookup. However, it does not mention failure behavior for invalid or missing IDs, potential rate limits, or whether the call can return null/no result.

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?

A single, well-structured sentence that front-loads the verb and resource, then lists the output fields. Every word contributes meaning, and there is no redundancy or filler.

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

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

For a simple one-parameter lookup without output schema or annotations, the description covers the essential input and expected output fields. However, it omits practical details like IMDb id format, behavior on unresolved IDs, and any external API constraints, leaving some gaps for an agent to discover at runtime.

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

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

The input schema has 0% description coverage; the bare property name 'imdb_id' carries little meaning. The description adds that the parameter is an IMDb id and that it maps to title/year/type. It does not specify the expected format, such as whether 'tt' prefix is required, which would improve clarity.

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 specific and action-oriented: 'Resolve an IMDb id to its title/year/type via OMDb.' It clearly identifies the input, the operation, and the expected output fields. It does not explicitly differentiate from siblings like identify_title or search_title, but the IMDb-id-to-metadata mapping is distinctive 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 implies when to use the tool: when you have an IMDb id and need its title, year, or type. However, it provides no explicit guidance about when not to use it or which sibling tools to prefer, such as search_title for title-based lookup or identify_title for other identification needs.

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 state that the operation modifies feeds.json, which implies mutation, but it does not mention side effects, idempotency, error behavior, permissions, or whether the operation is reversible.

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 focused sentence that front-loads the verb and resource. Every word earns its place, and there is no redundant filler.

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

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

The operation is simple and both required parameters are addressed in the description, so an agent can likely make a correct call. However, with no annotations or output schema, the description should also clarify behavior on missing IDs or non-existent profiles, which it does not.

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 parameter names and types. The description adds useful meaning by identifying imdb_id as an IMDb id and associating profile with a queue profile's feeds.json. However, it does not specify expected formats, valid values, or how the profile is referenced.

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

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

The description clearly states the action: remove an IMDb id from a specific resource (a queue profile's feeds.json). This distinguishes it from siblings like add_to_queue and list_queue without requiring the agent to infer behavior from the tool name alone.

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

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

No guidance is given about when to use this tool versus alternatives. It is implicitly the inverse of add_to_queue, but the description does not say this explicitly, nor does it mention prerequisites such as the profile needing to exist or the IMDb id needing to be present.

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 behavioral disclosure burden. It does reveal that matching is fuzzy and that year narrows results, which is useful. However, it does not mention whether results are returned in a particular order, any rate limits, or whether the search can fail on ambiguous titles.

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 focused sentence that front-loads the core behavior and the optional modifier. There is no redundant filler or repetition of the tool name.

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

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

For a simple two-parameter search tool with an output schema, the description covers the essential call semantics: what to search and an optional filter. It is slightly incomplete in not explaining expected year formatting or how this differs from related title lookup tools, but overall it provides enough context for a basic correct invocation.

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

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

Schema description coverage is 0%, but the description adds meaningful semantics by labeling the title search as fuzzy and the year as an optional narrowing filter. It does not provide detailed format expectations for the year string or clarify how fuzzy matching behaves at boundaries.

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 a fuzzy search on OMDb by title, with an optional year filter. It identifies the resource (OMDb) and the operation (fuzzy-search), but it does not explicitly distinguish itself from sibling tools such as lookup_title or search_torrents.

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

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

The description gives no guidance on when to prefer this tool over alternatives like lookup_title, identify_title, or search_torrents. The only usage hint is the optional year narrowing, which implies filtering but does not explain when this search should be chosen.

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 reveals the scoping behavior (one indexer or 'all'), but it leaves out rate limits, failure behavior for unsupported indexers, and any statement about side effects, though a search operation is inherently read-only.

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?

A single sentence conveys the operation, scope, and key parameter semantics with no filler. The most important scoping detail ('one Jackett indexer (or "all")') is front-loaded.

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

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

The tool has only two required scalars, an output schema exists to cover return values, and the description supplies the critical 'all' behavior. The main remaining gap is error behavior when an indexer lacks IMDb search support, which is a minor edge case.

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

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

Schema coverage is 0%, so the description must compensate. It maps both required parameters to their roles and notably reveals that indexer_id accepts the special value 'all', which is not visible in the schema. It does not specify the IMDb ID format, but the semantic meaning is clear.

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

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

The description uses a specific verb ('Search') with a precise object ('one Jackett indexer (or "all")') and a clear filter ('torrents matching an IMDb id'). This makes it easy to distinguish from title-based siblings like search_title and lookup_title.

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 clearly states the trigger condition: an IMDb ID and either a specific Jackett indexer or 'all'. It does not explicitly enumerate when to prefer sibling tools like check_imdb_search_support, but the search-by-IMDb context is unambiguous.

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 behavioral disclosure burden. It does this well by explaining the optional restart side effect and the server requirement (DOCKER_RESTART_ENABLED=true), which are non-obvious behavioral details. It does not mention whether the operation is reversible or what happens if restart is false, but the core mutation and its side effect are clearly 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 two short sentences with no filler. The core purpose is front-loaded in the first sentence, and the second sentence adds only the necessary detail about the restart flag. Every word earns its place.

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

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

For a straightforward mutation tool with no annotations and no output schema, the description covers the essential context: the operation, all three required parameters, an optional parameter, and a server-side prerequisite. It does not describe the return value or failure modes, but it provides enough for an agent to invoke the tool correctly and understand the restart caveat.

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 must explain each parameter. It does: 'queue profile' maps to profile, 'from one Jackett indexer' maps to old_indexer, 'to another' maps to new_indexer, and the second sentence explains restart's behavior and prerequisite. It stops short of providing allowed value formats or examples, but it adds enough meaning beyond the bare schema.

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

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

The description opens with a specific verb and resource: 'Repoint every feed URL in a queue profile from one Jackett indexer to another.' This clearly identifies the operation and its scope, and it is distinct enough from sibling tools like add_to_queue or list_queue that an agent can infer this is a bulk indexer-switching mutation.

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

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

Usage context is implied by the purpose: you use this when you need to switch indexers across an entire queue profile. However, the description does not explicitly compare against alternatives or state when not to use it, nor does it mention prerequisite steps like checking candidates or listing indexers first.

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