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

Annotations already declare readOnlyHint=true, openWorldHint=false, idempotentHint=true, destructiveHint=false, covering the safety profile. The description adds context about the data used ('verdicts and measured harness results') but doesn't disclose details like response format or limitations. This aligns with annotations and adds some value, so a 3 is appropriate.

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 that is direct and jargon-free. Every word adds meaning (verb, resource, comparison criteria), with 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?

For a low-complexity read-only tool with a single parameter, annotations, and an output schema, the description is adequately complete. It could be slightly more explicit about what 'compare' returns (e.g., ranking or differences), but the existing output schema likely covers that.

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 100% coverage with a clear description of the 'name' parameter ('Exact component name or slug'). The tool description adds context about comparing 'same-pattern' candidates but doesn't add param-specific syntax or format details, so it stays at the baseline.

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 'Compare' with the resource 'same-pattern candidates' and clarifies the method ('using their verdicts and measured harness results'). It clearly distinguishes from sibling tools like find_component or check_component, though it doesn't explicitly state 'rank' as the title 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 usage when same-pattern candidates need comparison, which is a clear context. However, it provides no explicit exclusions or alternatives among sibling tools, so it gets a mid-range score for implied rather than explicit guidance.

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

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

Annotations already declare the tool as read-only, idempotent, and non-destructive. The description adds value by specifying the exact fields returned (verdict, skip conditions, render/accessibility/bundle/bare/provider facts), which informs the agent about output structure beyond the annotation hints.

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 that front-loads the primary output ('full verdict') and lists the supported fact types. It is reasonably concise, though the list of facts is somewhat dense.

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

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

Given the tool's simplicity (one parameter, output schema exists, rich annotations), the description adequately explains what the tool returns. However, in the context of eight sibling tools, some usage guidance would improve completeness.

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

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

Schema coverage is 100% (the single parameter 'name' is fully described in the schema). The description does not add any parameter-level details, so the baseline score of 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?

The description states what the tool returns (full verdict, skip conditions, and various facts), but it does not explicitly differentiate from sibling tools like 'check_template' or 'find_component'. The verb 'check' is generic, but the listed outputs provide specificity.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, exclusions, or context for selection among the eight sibling tools.

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

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

Annotations already mark the tool as read-only, idempotent, and non-destructive. The description adds valuable behavioral context by enumerating exactly what data the tool returns (preview, source, download, palette variants). No contradictions with annotations.

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

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

The description is one sentence that lists all returned items concisely. It is front-loaded with the 'Return' verb and avoids fluff. However, the long list could be more readable with bullet points or structured phrasing.

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

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

Given an output schema exists and annotations cover safety, the description sufficiently describes the tool's purpose for a single-parameter tool. It lists all expected return elements, making it complete for the agent to understand what to expect. No mention of related siblings, but that is covered by usage guidelines dimension.

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% (one parameter 'name' with a clear description). The tool description does not add any additional meaning about the parameter beyond what the schema already provides, so 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 clearly states the tool returns a template summary with multiple specific data points (stack, license, accessibility status, etc.). It distinguishes from siblings like 'find_template' (which likely searches) and 'check_component' (component-specific), but does not explicitly name alternatives.

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

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

The description provides no guidance on when to use this tool versus siblings (e.g., find_template, check_component, alternatives). No prerequisites or exclusion criteria are mentioned, leaving the agent to infer usage 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?

Annotations already indicate readOnlyHint, idempotentHint, and non-destructive. The description adds meaningful behavior: it ranks up to three items, includes only verified/rendering components, and excludes failure warnings. This goes beyond annotations. However, it does not explain what 'verified' means or how 'measured harness results' affect ranking.

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 sentences and relatively concise. No superfluous words. However, the first sentence is dense and could be restructured for clarity. It front-loads the core action but the phrasing 'using prose, pattern, style, and measured harness results' is somewhat run-on.

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

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

Given the tool has four parameters (one required), three optional filters, and an output schema exists, the description provides basic operational context. It explains the return count and filtering of failures. However, it omits important context like what 'measured harness results' are, why 'failure warnings' are excluded, and how the ranking works. The description is adequate but leaves gaps for an agent to infer.

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 100% schema description coverage, the baseline is 3. The description references 'prose, pattern, style, and measured harness results' but 'prose' does not directly map to any parameter (likely 'task'). It adds some context but also introduces ambiguity. The palette parameter is not mentioned, so the description doesn't fully compensate or clarify parameter roles beyond the schema.

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

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

The description clearly states the tool ranks up to three verified React components for a UI task using specific criteria. The verb 'rank' and resource 'components' are explicit. While it doesn't explicitly distinguish from siblings like 'find_template', the mention of 'measured harness results' hints at the differentiator. However, 'prose' is ambiguous and could be clearer.

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 provided on when to use this tool versus alternatives like 'find_template' or 'check_component'. There is no mention of prerequisites, exclusions, or context where this tool is preferred. The description assumes the agent knows when to invoke 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?

The description adds behavioral context beyond annotations: it ranks templates, limits to three, and excludes failed accessibility audits. Annotations already declare readOnlyHint, idempotentHint, and no destructive action, which the description supports without contradiction. More detail on the ranking algorithm could be added, but it's sufficient.

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 filler, front-loaded with the core action. Every sentence adds value: what it does, how many results, and an exclusion rule. Excellent conciseness.

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

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

Given the tool's moderate complexity (3 parameters, 1 required, output schema exists), the description covers the essential behavior: ranking, count, exclusion. The output schema handles return values, so no need to detail them. Slight gap: no mention of ordering for ranking, but acceptable.

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

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

Schema description coverage is 100%, so the baseline is 3. The description repeats the 'task' parameter's purpose ('product or business task') but does not add new meaning beyond what the schema already provides for 'style' and 'category'. No additional semantic value is introduced.

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 finds and ranks up to three complete React page templates for a given task, with a specific exclusion criterion (failed accessibility audits). This is a specific verb-resource pair that distinguishes it from siblings like find_component.

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 provided on when to use this tool versus alternatives (e.g., find_component, check_template). The description only states what it does, leaving the agent to infer appropriate usage contexts without explicit when-to-use or when-not-to-use instructions.

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

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

Annotations already declare it read-only, idempotent, non-destructive, and not open-world. The description adds value by clarifying that it returns a structured plan with dependencies and provider needs, which supplements the annotations. No contradiction exists.

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

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

The description is a single, front-loaded sentence that lists all meaningful outputs without waste. It could be improved with minor structural breaks (e.g., bullet points) for readability, but the information density is high and efficient.

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 simple parameter, 100% schema coverage, and annotations covering safety/read-only behavior, the description adequately completes the picture by detailing the return value. The presence of an output schema further lessens the burden. Minor gap: no mention if component must already exist or how errors are handled.

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% (one param, 'name', with a clear description). The description does not repeat the schema but adds context about the output (what the plan includes). Since coverage is perfect, a baseline of 3 is appropriate; the extra description of what the name parameter yields justifies a 4.

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 ('List') and enumerates the exact resources returned (dependencies, gaps, requirements, notes, license, URLs, command). This distinguishes it well from siblings like find_component (search) and check_component (validate), by focusing on a detailed installation/planning report.

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 this should be used to get a comprehensive plan before installing, but does not explicitly state when to use it versus siblings like skip_list or alternatives. It lacks guidance on prerequisites or when NOT to use this tool (e.g., if you only need a quick availability check).

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 adds behavioral context beyond the annotations: it specifies the return count (1-3), curation, four-color structure, and output format (hex roles, CSS variables). Annotations already indicate read-only, idempotent, non-destructive nature, so the description complements rather than repeats. It does not contradict any annotation.

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, well-structured sentence of 18 words. It front-loads the action ('Return') and packs all essential information (count, curation, palette size, filter, output format) without redundancy or fluff.

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

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

Given the tool's simplicity (one optional parameter, no required params, output schema present, annotations covering safety), the description is complete. It explains what the tool returns, how it filters, and the output structure. The output schema can handle the detailed return format, so the description doesn't need to repeat that.

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 single parameter 'mood' is fully described in the input schema (100% coverage). The description mentions 'by mood' but does not add new meaning beyond the schema's 'Optional mood, palette slug, or tags such as dark, pastel, warm, or cold.' With full schema coverage, the description adds minimal value here.

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 returns 1-3 curated four-color palettes by mood, with hex roles and CSS variables. This is a specific verb-resource combination that distinguishes palette_pick from sibling tools like find_component or alternatives, which deal with different domains.

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

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

The description does not provide any guidance on when to use this tool versus its siblings. It does not mention prerequisites, exclusion criteria, or scenarios where another tool would be more appropriate. The sibling tools cover components, templates, and plans, so some context about when to pick a palette vs. those would help.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, establishing a safe, read-only behavioral profile. The description adds valuable context by specifying the tool surfaces failure warnings and worst measured offenders, which clarifies the kind of data returned. No contradictions with annotations.

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

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

A single sentence that is well-front-loaded with the key purpose ('Show failure warnings and the worst measured offenders') and mentions the optional filter. No unnecessary words; every part earns its place.

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

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

Given the tool's simplicity (2 string params, no enums, no nested objects) and the presence of annotations and an output schema, the description is largely complete. It explains what the tool returns (failure warnings and worst offenders). A minor gap is not explaining what 'measured' refers to (e.g., performance metrics), but overall adequate.

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% with both parameters documented ('Exact component pattern.' and 'Optional exact visual style.'). The description reiterates the style filter but adds no new constraints or format details. Baseline is 3 because schema already covers parameter meaning adequately.

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 shows failure warnings and worst measured offenders in a pattern, with optional style filtering. This distinguishes it from sibling tools like 'find_component' (general search) and 'check_component' (validation), as it focuses on problematic items. However, it could be more explicit about how it differs from 'alternatives' or 'check_component'.

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

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

No explicit guidance on when to use this tool versus siblings is provided. The description implies its use for identifying failures and worst offenders, but does not mention exclusions or alternatives. For example, there is no note like 'use check_component for detailed validation' or 'this does not provide alternatives'.

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

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

Annotations already provide readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is clear. The description adds that it 'returns an exact clone and setup plan', implying it is a safe, read-only operation. It doesn't go beyond annotations by detailing what happens if the template doesn't exist or other edge cases, so it's adequate but not enriched.

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, clear sentence with no wasted words. It is front-loaded with the key action and resource, and the optional variant is appended concisely.

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

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

Given the tool has a simple 2-parameter input, a clear output schema (implied by 'exact clone...plan'), and robust annotations, the description is nearly complete. It could elaborate on the return format or edge cases (e.g., missing template) but current info suffices for selection and basic 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 100% (both parameters are documented in the schema). The description mentions 'name' and 'built palette variant slug' in general terms, but adds no new meaning beyond what the schema provides (e.g., no format, constraints, or examples). Baseline 3 is correct when schema covers all parameters.

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

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

The description uses a specific verb ('Return') and resource ('clone and setup plan for a complete template'), and distinguishes itself from siblings like 'find_component' or 'install_plan' by focusing on producing a plan from a template name, not executing or searching.

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

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

The description clearly states what it does (clone and plan setup) and includes an optional palette variant. However, it does not explicitly say when to use this tool vs. siblings like 'find_template' (for finding) or 'install_plan' (for installation), nor does it mention when not to use it. The context is clear but lacks exclusions or alternatives.

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