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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about whether the add triggers a download/search, how duplicates are handled, permission requirements, or reversibility. "Add to your library" is the only behavioral claim, leaving most of the mutation profile undisclosed.

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 tight sentences, front-loaded with the action and immediately followed by the required-parameter source; every clause carries information and nothing is redundant.

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?

A 7-parameter mutation tool (including a nested addOptions object) with no annotations and no output schema is only adequately covered: the description never mentions tags, monitored, or the immediate-search option, nor what the caller gets back or how failures appear. The rich input schema compensates partially, but the description should do more for a write operation.

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

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

Schema coverage is 86%, so the schema already documents defaults for monitored, tags, addOptions.searchForMovie and the enum values. The description merely echoes the optional root folder, quality profile, and availability parameters without adding format or interaction detail, matching the baseline of 3 when the schema does the heavy lifting.

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 a new movie to your library") and names the sibling tool (radarr_search_movies) that supplies the required tmdbId, so an agent can distinguish it from the search/get/delete siblings without opening a schema.

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?

Gives a clear prerequisite chain — obtain tmdbId from radarr_search_movies before calling — which is actionable context. It stops short of explicit when-not guidance (e.g., use radarr_edit_movie for existing entries, or how to handle duplicates already in the library).

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

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

With no annotations, the description carries the full burden, and it does disclose the critical trait: the operation is irreversible ('cannot be undone') and deleteFiles is permanent. It stops short of noting required permissions, whether Radarr unmonitors vs fully removes, or the response shape.

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 tight sentences: purpose, the optional destructive flag, then the irreversibility warning last. Nothing is wasted and the highest-risk information is unmissable.

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 three-parameter destructive tool with no annotations and no output schema, the description covers purpose and the main risk adequately. Adding a note on required permissions or what happens to existing Radarr entries would make it fully 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 100%, so the schema already documents all three parameters, establishing the baseline of 3. The description restates the deleteFiles flag as optional and permanent, which mirrors the schema text rather than adding new meaning, and it never mentions addImportExclusion.

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 ('Delete a movie from Radarr'), which cleanly separates it from the file-level sibling radarr_delete_movie_file. It does not explicitly name any sibling, but the resource noun does the disambiguation work.

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 on when to use this versus alternatives such as radarr_delete_movie_file, radarr_edit_movie, or radarr_remove_from_queue, and no prerequisites stated. The optional flags are described but that is parameter detail, not usage routing.

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 carries the full behavioral burden. It adds important value by explicitly warning that deletion is permanent, but omits other relevant traits such as required permissions, whether the file is removed from the Radarr database too, and whether the operation is reversible or requires confirmation.

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

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

Two short sentences with zero waste. The core action is front-loaded and the warning follows immediately, maximizing signal density.

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 destructive tool with no annotations and no output schema, the description covers the essential purpose and permanence warning. However, it does not mention prerequisites, side effects on the movie library, or expected outcome, so it is only minimally complete without annotations to fill those 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?

There is one parameter with full schema description coverage ('Movie file ID'), so the schema already carries the parameter semantics. The description adds no syntax, format, or sourcing guidance beyond what the schema provides; a baseline 3 is appropriate.

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 ('Delete a movie file') and adds the crucial scope qualifier 'from disk', which distinguishes it from sibling radarr_delete_movie (which removes the movie record, not the file). An agent can select this without opening the schema.

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 when-to-use, when-not, or alternative guidance is provided. The description implies the tool deletes a file, but gives no context about when this is appropriate versus deleting the movie entry or rescanning, leaving an agent to infer from the name alone.

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 key behavioral constraint that a complete movie object from radarr_get_movie is required, but doesn't state permission requirements, whether the edit is reversible, or what the response looks like.

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 sentences, front-loaded with purpose, then field enumeration, then the operational instruction. Zero waste.

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

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

Given one required nested-object parameter, no output schema, and no annotations, the description is largely complete. It covers purpose, mutable fields, and the crucial pre-fetch instruction. Minor gap: it could note the id requirement (covered by schema) or what happens to unlisted fields.

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 100%, and the schema already documents the single 'movie' parameter as requiring an 'id' field. The description's field list (monitored status, quality profile, path, tags, availability) adds marginal meaning over the schema. Baseline 3 is appropriate when the schema does the heavy lifting.

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 (edit) and resource (existing movie), and enumerates the mutable fields (monitored status, quality profile, path, tags, minimum availability). Clearly distinguished from siblings like radarr_add_movie and radarr_delete_movie.

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?

Explicitly prescribes the workflow: 'Get the full movie object first with radarr_get_movie, modify it, and pass it here.' Names the prerequisite tool and the required sequence, leaving no ambiguity about how or when to use it.

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

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

No annotations are provided, so the description carries the full burden. It mentions that the return includes metadata, file status, and ratings, which is somewhat helpful, but does not disclose pagination, rate limits, permissions, or whether it's a read-only operation. Behavior is minimally described.

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 that are front-loaded with the main purpose. No wasted words.

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

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

The tool has no parameters, no output schema, and no annotations. The description partially compensates by noting what is returned (metadata, file status, ratings), but it lacks details on pagination, filtering, and whether the list may be large. Adequate but with clear gaps for a tool that returns a complete library.

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?

Zero parameters, so baseline is 4. No additional parameter semantics 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?

States a specific verb+resource: 'Get all movies in your Radarr library'. This clearly distinguishes it from siblings like radarr_get_movie (single) and radarr_search_movies (search). However, the description does not explicitly name alternatives, so it falls short of a 5.

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

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

No guidance on when to use this tool versus alternatives like radarr_get_movie or radarr_search_movies. An agent must infer that 'all' means no filtering, but no when/when-not conditions are provided.

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

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

With no annotations, the description carries the full behavioral burden; "Get" implies a safe read, and the default date window (next week) is disclosed. However it says nothing about permissions, return shape, or how unmonitored/includeMovies change the payload beyond the schema's own text.

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 short sentences, front-loaded with the core action and its default, with no filler. Every sentence earns its place.

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

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

For a simple read-only calendar tool with no output schema and no annotations, the description is adequate but leaves the return shape (what a "calendar entry" is) and the effect of includeMovies unexplained. It is complete enough to call, not to fully anticipate results.

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 100%, so all four parameters including the start/end defaults are already documented in the schema. The description's date-range phrasing adds no format or interaction detail beyond that, so the baseline of 3 applies.

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 gives a specific verb and resource ("Get movies releasing in a date range") with a clear scope, which separates it from list/single-movie siblings like radarr_get_all_movies and radarr_get_movie. It stops short of explicitly naming the sibling it replaces, so it stays at 4 rather than 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?

"Great for seeing what's coming to theaters or digital" implies the use case (upcoming-release browsing) but gives no explicit when-to-use versus alternatives such as radarr_get_wanted, which also surfaces movies the user cares about. Usage is inferable but not routed.

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 does disclose the nature of the payload (health warnings/errors with concrete examples) and implies a non-destructive read, but says nothing about permissions, whether the check is cached/refreshed, or how empty health is represented.

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

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

Two short sentences, purpose front-loaded, and the parenthetical examples add useful signal without padding. Nothing to trim.

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 the description still tells the agent the kind of information returned, which is sufficient for a zero-arg read tool. The only shortfall is the unresolved overlap with the get_system_status sibling.

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

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

The tool takes zero parameters, so per the baseline there is nothing for the description to compensate for. No parameter meaning is missing.

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+resource ('Get system health status') and clarifies what it surfaces (warnings/errors such as disk space or download client problems). It does not differentiate itself from the sibling radarr_get_system_status, so an agent must guess which of the two to call for instance-level status.

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 a diagnostic context but gives no explicit when-to-use, when-not-to-use, or alternative routing. With radarr_get_system_status among the siblings, the absence of any disambiguation guidance is a real gap.

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 usefully explains that listed movies 'will not be imported automatically,' which conveys the semantic meaning of the returned data, but says nothing about return format, ordering, or whether the list can be empty.

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

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

Two short sentences, front-loaded with the action and resource, and the second sentence earns its place by explaining what exclusion means. 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 zero-parameter read with no output schema, the description gives enough to call it correctly and interpret the result conceptually. Additional detail about the return shape would help but is not essential.

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 takes zero parameters, so there is nothing for the schema or description to document. The baseline for a parameterless tool applies.

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 and resource ('Get movies on the import exclusion list') and clarifies the meaning of those exclusions. It does not name or contrast with the sibling radarr_remove_import_list_exclusion, so it lacks explicit sibling differentiation.

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

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

Usage is implied by the resource name - fetch the exclusion list - but there is no explicit guidance on when to call it versus alternatives such as radarr_remove_import_list_exclusion or the movie-listing tools. Adequate but leaves routing to inference.

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. The 'Get' verb and the disclosure that results include file info, ratings, and collection data give a reasonable read-only picture, but there is no mention of error behavior (unknown ID), permissions, or how complete/heavy the payload is.

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

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

Two short sentences, no filler; the key disambiguator (Radarr ID) and the return-content summary are both front-loaded and each sentence earns its place.

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

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

There is no output schema, and the description partially compensates by naming the main payload sections (file info, ratings, collection data). For a one-parameter read tool this is close to sufficient, though return shape and failure modes remain unspecified.

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 100%, so the single parameter is already fully documented, including the 'not TMDB ID' distinction. The description merely restates 'by its Radarr ID' and adds no format, range, or lookup semantics beyond the schema, so baseline 3 applies.

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 (get a movie) plus the lookup key (Radarr ID), which implicitly separates it from the sibling radarr_get_movie_by_tmdb and from radarr_get_all_movies. An agent can pick the right tool without opening the schema.

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 by 'by its Radarr ID' plus the required id parameter, but there is no explicit when-to-use statement, no mention of when to prefer radarr_get_movie_by_tmdb or radarr_search_movies, and no exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses nothing about how failures are handled (e.g., unknown TMDB ID), what fields come back, or auth/rate-limit behavior; the only behavioral hint is the read-only connotation of 'Get', which is already implied by the name.

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

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

Two short sentences, zero filler, with the core action front-loaded and the routing hint second. Nothing could be cut without losing information.

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

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

For a single-parameter read tool with no output schema, the description covers purpose and selection context well. The remaining gap is what 'movie information' actually contains and how errors surface, but that is minor for a lookup of this simplicity.

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

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

Schema coverage is 100% and the schema itself supplies the format and an example ('603 for The Matrix'), so the description adds no parameter-level detail. Baseline 3 applies when the schema does the heavy lifting.

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 ('Get movie information') plus the exact lookup key (TMDB ID), which cleanly separates it from the sibling radarr_get_movie that takes a Radarr ID.

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

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

Explicitly says when to reach for it: 'Useful when you know the TMDB ID but not the Radarr ID.' That implies the alternative (radarr_get_movie by Radarr ID) without naming it directly, so it falls just short of a fully explicit routing rule.

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 must carry the full behavioral burden. 'Get' implies a read-only operation and the description lists returned fields (quality, size, release group), but it does not explicitly state read-only safety, permission requirements, error behavior, or whether multiple files are returned.

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 sentences, front-loaded with the core purpose and followed by a concise list of return details. Every sentence earns its place with no redundancy.

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

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

For a simple one-parameter read tool with no output schema or annotations, the description adequately explains the return content. It could be more complete by specifying whether it returns a single file or a list, but it covers the essential purpose and return fields.

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 100% and the single parameter is documented as 'Radarr movie ID'. The description's phrase 'for a specific movie' aligns with this but adds no format, range, or example details beyond what the schema already provides, so the baseline score of 3 applies.

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 (Get) and resource (movie file information) scoped to a specific movie, and lists example fields. It distinguishes itself from the broader radarr_get_movie by focusing on files, but it does not explicitly name or 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?

There is no guidance on when to use this tool versus alternatives like radarr_get_movie or radarr_delete_movie_file. The description only states what the tool does, leaving the agent to infer the appropriate context.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only lookup operation, but doesn't disclose return format, pagination, permissions, or whether the list is static. For a zero-parameter read tool this is adequate but not rich.

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

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

Two short sentences, front-loaded with the action and followed by a brief clarifying purpose. No filler or redundancy.

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

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

With no annotations and no output schema, the description should ideally describe what a quality profile contains or what the response looks like. It gestures at purpose ('used when adding movies') but leaves the return content underspecified for an agent that needs to consume the output.

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 takes zero parameters, so the baseline of 4 applies. The description correctly implies no input filtering is required, consistent with the empty 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?

States a specific verb and resource ('Get all quality profiles'), making the retrieval action clear. The second sentence clarifies what a quality profile is, but doesn't distinguish it from siblings like radarr_get_root_folders or radarr_get_tags, which follow the same 'get all config items' pattern.

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

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

The description implies usage by noting quality settings are 'used when adding movies', suggesting this is a lookup tool. However, it doesn't explicitly state when to call this versus alternatives, nor does it note exclusions or call ordering relative to radarr_add_movie.

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

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

With no annotations, the description carries the full burden, and it does disclose return content (progress, status, errors), which is real behavioral value. However, it says nothing about pagination limits, snapshot semantics, or the fact that this is a non-mutating read, leaving gaps for a tool with zero annotation coverage.

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

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

Two short sentences, front-loaded with the action and followed by the return content. Nothing is wasted or redundant.

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 tool with no output schema, the description reasonably summarizes the returned fields. It is only slightly incomplete in not hinting at pagination behavior, which the paged parameters imply.

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 100%, so page, sortKey, pageSize, sortDirection, and includeUnknownMovieItems are already documented in the schema. The description adds no parameter-level meaning, so the baseline of 3 applies.

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 ('Get current download queue') and enumerates what the result contains (active downloads, progress, status, errors). No sibling performs the same read, so differentiation is implicit rather than explicit, keeping it just short of a 5.

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

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

There is no when-to-use guidance, no mention of when the queue is empty, and no reference to alternatives such as radarr_remove_from_queue for acting on items. Usage is only inferable from the name and purpose.

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 supplied, so the description carries the disclosure burden, but the operation is a trivial read with no parameters and no side effects. It implicitly conveys read-only behavior but says nothing about permissions, error behavior, or how results are ordered or presented.

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 very short sentences, front-loaded with the core action and using the remainder for useful context. Nothing is wasted and there is 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?

With no output schema and no annotations, the description should ideally hint at what a root folder record contains (e.g., path and id). 'Shows where movies can be stored' gestures at the concept but leaves the return shape unspecified.

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 takes zero parameters, so there is nothing to document and the baseline of 4 applies. No parameter meaning is required or missing.

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 ('Get all configured root folders') and adds a clarifying clause about what root folders represent. It is inherently distinct from sibling tools like radarr_get_all_movies or radarr_search_movies, though it never explicitly contrasts itself with them.

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

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

Usage is only implied: 'Get all' signals a read-only listing operation. There is no statement of when to call this versus alternatives and no mention of prerequisites, though for a unique, zero-argument listing tool the alternatives are minimal.

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 behavioral burden. It correctly implies a read-only operation and lists returned fields, but does not disclose whether authentication is required, whether it is cached, or any rate limits. For a zero-parameter diagnostic tool, more context about safety and side effects would be expected.

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

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

Two short sentences, front-loaded with the purpose and then the returned information. Every word earns its place with no redundancy.

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

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

The tool is simple (no parameters, no output schema), so the description covers the core purpose and output fields. However, without annotations or output schema, it leaves behavioral gaps such as authentication requirements, and it does not differentiate from the sibling radarr_get_health, which may confuse an agent choosing between diagnostic endpoints.

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

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

With zero parameters, the baseline is 4. The description appropriately focuses on output rather than inputs, and no parameter semantics are 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?

States a specific verb (Get) and resource (system status), and enumerates the concrete fields returned (version, OS, .NET version, database type, migration version). It is clearly distinguished from siblings like radarr_get_health or radarr_get_quality_profiles, though the description could explicitly contrast with get_health since both are diagnostic endpoints.

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 such as radarr_get_health or radarr_get_queue. The description only says what it returns, not the context or conditions that would prompt an agent to call it.

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

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

No annotations are provided, so the description carries the burden, and 'Get all tags' does convey a read-only lookup with no parameters. However it omits any indication of auth requirements, pagination, or what the returned tag objects contain, leaving real behavioral gaps.

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

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

Two short sentences, front-loaded with the action and immediately followed by the practical purpose. No filler or repetition.

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

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

For a zero-parameter read-only listing with no output schema, the description tells the agent what it gets and why it matters. Only a minor gap remains in not sketching the return shape (tag id/label), which is low-stakes here.

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 takes zero parameters, so there is nothing for the description to disambiguate; the baseline of 4 applies.

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 ('Get all tags') and adds the resource's role ('tags you can apply to movies for organization'), which clearly separates it from the movie-centric siblings. It does not explicitly name or contrast a sibling, but the distinct 'tags' resource makes the purpose unambiguous.

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

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

Usage is only implied: an agent can infer you call this to discover tags before applying them to movies. There is no explicit when-to-use, when-not-to-use, or alternative named, so it stays at the minimum-viable level.

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 usefully discloses the semantics of the returned set (monitored, missing files), but says nothing about permissions, result size, or how paging interacts with the result set, which matters for a listing endpoint with 4 paging/sorting params.

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 sentences, no waste, with the core purpose front-loaded and the disambiguating definition of 'wanted' immediately after.

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 read-only, zero-required-parameter listing tool with a fully documented schema and no output schema, the description gives enough to call it correctly; it could go further by noting that results are paged and sortable, but nothing essential 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 description coverage is 100%, so all four pagination/sort parameters are already documented in the schema; the description adds no syntax, defaults, or sorting semantics beyond that, making the baseline 3 appropriate.

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 ('Get') and resource ('wanted/missing movies') and then defines the resource in operational terms ('monitored but don't have files yet'), which lets an agent distinguish it from radarr_get_all_movies or radarr_search_movies without opening the schema.

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 only implied by the definition of the return set; there is no explicit 'use this when... instead of...' statement and no sibling is named as an alternative, even though radarr_get_all_movies and radarr_get_calendar are plausible confusions.

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

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

With no annotations, the description carries the full burden. It hints at mutation and the source of new data, but does not say whether the call is synchronous or queued, whether it overwrites manual edits, or whether it can fail when the metadata provider is unreachable.

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

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

Two short sentences, front-loaded with the action. The trailing 'etc.' is slightly vague but the entry is well within budget.

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 full schema coverage and no output schema, this is minimum viable. The main missing piece is whether the refresh is immediate or asynchronous and what state the movie ends up in.

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 100% for the single movieId parameter, so the schema already carries the semantics. The description adds no format, range, or lookup guidance beyond it, so the baseline 3 applies.

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+resource ('Refresh movie information') and the data source ('metadata sources'), which is clear on its own. It does not, however, distinguish itself from the similar sibling radarr_rescan_movie or explain what 'refresh' means relative to 'rescan'/'edit'.

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 when-to-use guidance, no prerequisites, and no mention of the competing radarr_rescan_movie sibling. The agent must infer the situation from the name alone.

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 behavioral burden for a destructive queue mutation. It does not state whether removal is irreversible, whether the download client is instructed to stop/delete the transfer, what permissions are required, or what happens if the id is invalid — only the blocklist side effect is hinted at.

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 tight sentences with the primary action front-loaded and the optional modifier second. No filler, no repetition.

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

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

For a destructive tool with no annotations and no output schema, the description omits critical side effects (file deletion, download client behavior, irreversibility) and success/failure signaling. An agent could call it, but would not understand the consequences.

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 100%, so all four parameters are already documented in the schema, including blocklist, changeCategory, and skipRedownload. The description restates the blocklist meaning but adds no semantics beyond the schema, so the baseline of 3 applies.

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 ('Remove') and resource ('an item from the download queue'), which clearly distinguishes it from read siblings like radarr_get_queue and radarr_delete_movie. It stops short of explicitly naming the counterpart tools, but the action is unambiguous.

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

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

There is no guidance on when to use this over alternatives (e.g., delete_movie or edit_movie) or prerequisites such as the item needing to be in the queue. The only contextual hook is the optional blocklist note, which is about a parameter rather than when to invoke the tool.

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

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

No annotations are provided, so the description carries full burden. It usefully discloses the post-removal effect (the movie can be imported again), but omits permissions required, whether the removal is reversible, and any side effects on related import lists. That is meaningful but incomplete behavioral context.

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

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

Two short sentences with the action front-loaded and the consequence second. Every sentence earns its place 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 removal tool with high schema coverage and no output schema, the description covers the essential purpose and outcome. The main gap is the absence of annotations, which leaves some behavioral details unstated, but overall it is nearly complete for an agent to invoke correctly.

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

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

Schema description coverage is 100%, and the parameter is documented as 'Import list exclusion ID (not movie ID)' directly in the schema. The description adds no additional parameter semantics beyond that, so the baseline of 3 applies.

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: removing a movie from the import exclusion list. It distinguishes itself from the read-only sibling radarr_get_import_list_exclusions by naming the remove action and its consequence. The effect on future imports is also clear.

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

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

The description implies usage context by saying 'Allows the movie to be imported again,' which signals when an agent would want to call it. However, it does not name alternatives, prerequisites, or when not to use it. The schema note 'Import list exclusion ID (not movie ID)' helps but is not part of the description.

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. It discloses what the scan detects (new, modified, deleted files), which implies the library is updated as a side effect, but says nothing about whether the operation is synchronous, whether it can modify files, or what the response contains.

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

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

Two short sentences, front-loaded with the action and followed by the detection scope. No filler, though the second sentence could be folded in without loss.

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 tool this is mostly adequate, but the absence of any distinction from radarr_refresh_movie leaves a real gap in correct tool selection, and there is no output schema to compensate.

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 100% and there is a single required parameter (movieId) already documented as "Radarr movie ID to rescan." The description adds no further parameter semantics, so the baseline of 3 applies.

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?

"Rescan movie folder for files" states a specific verb and resource, and the second sentence clarifies exactly what the rescan detects (new, modified, deleted files). However, it does not differentiate itself from the sibling radarr_refresh_movie, which an agent could easily confuse with a rescan.

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 when-to-use guidance, no prerequisites, and no exclusions. Most critically, it never explains when to rescan a folder versus calling radarr_refresh_movie, leaving the agent to guess between two similarly named siblings.

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

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

With no annotations, the description carries the full burden. It usefully discloses the key side effect ('This sends the movie to your download client'), which goes beyond the schema. However, it omits permissions, reversibility, rate limits, and what happens with multiple IDs, leaving significant behavioral gaps.

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

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

Three short sentences are front-loaded with purpose, then side effect, then parameter sourcing. No wasted words, though the sentence about the download client could be more precisely integrated with the search action.

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 and no annotations, the description covers the basic action and side effect. It is still incomplete: it does not explain batch behavior, response format, or failure modes, and the singular/plural mismatch between description and schema could confuse an agent.

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

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

Schema description coverage is 100%, so the schema already documents the single parameter as an array of movie IDs. The description adds only that IDs come from the library, but does not clarify array handling or formatting beyond what the schema provides. Baseline 3 is appropriate.

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 ('Search') and resource ('movie') and clarifies the effect ('to download'). However, it does not distinguish itself from the sibling 'radarr_search_movies', and the description says 'a specific movie' while the schema accepts an array of movieIds, creating mild ambiguity.

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?

Offers only 'Use the movieId from your library', which is a parameter sourcing hint rather than guidance on when to choose this tool over alternatives like radarr_search_movies or radarr_get_movie. No when-not conditions or alternative routing are provided.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that the lookup happens on TMDB (an external source, not the local library) and that results are candidate matches, but says nothing about rate limits, result caps/pagination, or whether any local state is touched.

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 short sentences, front-loaded with the action and source, then return behavior, then the motivating use case. Every sentence earns its place with 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 one-parameter search with no output schema, the description covers what it does, where it queries, and what it returns at a high level. It could be slightly more concrete about the returned fields (e.g., that tmdbId is among them), but it is nearly complete for its complexity.

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 100% and the single 'term' parameter is fully documented in the schema with examples. The description adds only the implicit notion that the term is a title, so it does not meaningfully extend the schema; baseline 3 is appropriate.

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 (search) and resource (movies by title on TMDB) and notes the return is potential matches with metadata. It is clear on its own, but it does not distinguish itself from the very similarly named sibling radarr_search_movie, which an agent could easily confuse it with.

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?

Explicitly says when to use it: 'Use this to find the tmdbId needed to add a movie,' which ties it directly to radarr_add_movie and gives a concrete downstream goal. It gives no when-not guidance or contrast with the near-duplicate radarr_search_movie sibling.

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