Jinero

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is clear. The description adds valuable behavioral detail about AA/AAA pass/fail evaluation for normal and large text, which goes beyond the basic 'check' verb. It doesn't mention return format or error handling, but the annotations lower the bar for this dimension.

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 front-loaded with the core action and outcome. There is no redundant phrasing, and every part contributes meaning.

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 simple two-parameter tool with good annotations and full schema coverage, the description adequately covers the tool's purpose and key outputs (AA/AAA for normal/large text). It does not describe the exact return structure, but no output schema exists, and the description mentions the essential result criteria.

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 fg and bg are described as color strings with acceptable formats. The description does not add extra parameter semantics beyond what the schema already provides, 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 uses a specific verb ('Check') and names the exact resource ('WCAG contrast ratio between a foreground and background color'), making the tool's purpose immediately clear. It also distinguishes itself from sibling tools like extract_colors or get_palette by focusing on contrast checking rather than color extraction or palette generation.

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 implies when to use the tool: whenever you need to evaluate contrast between two colors against WCAG standards. However, it does not explicitly mention alternatives or situations when not to use it, missing the top tier of 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?

Beyond the annotations (readOnlyHint, idempotentHint), the description adds critical context: 'never executed and never stored'. This goes beyond basic safety to clarify privacy and side-effect guarantees, which is especially valuable for a tool that processes code.

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: the first states purpose with examples, the second adds safety and usage guidance. No waste, front-loaded, and 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?

The description is adequate for a simple conversion tool. It covers purpose, safety, and how to find valid parameters. It does not describe the return format or error behavior, but given the simplicity of the operation and the absence of an output schema, this is a minor gap.

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

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

Schema coverage is 100%, but the description adds value by directing users to list_code_converters for valid format ids and converter options. This gives semantic meaning to the from/to and options parameters beyond their simple schema descriptions.

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 ('Convert') with a clear resource ('code between text formats') and concrete examples (JSON↔YAML, CSS↔SCSS). It also distinguishes itself from siblings by emphasizing 'Pure text transformation' and referencing list_code_converters, which differentiates it from other code tools like minify_code.

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 explicitly instructs to use list_code_converters for valid from/to ids and per-converter options, providing clear prerequisite guidance. It does not explicitly state when not to use the tool, but the conversion focus and the mention of text formats make the usage context clear.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, but the description adds critical context beyond that: 'Static analysis only — the snippet is never executed and never stored.' This discloses privacy and execution guarantees, which is valuable behavioral transparency not present in the structured data.

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

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

The description is two concise sentences that are front-loaded with the tool's purpose, followed by a crucial safety note. Every word earns its place, with no padding 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?

For a simple one-parameter read-only tool, the description covers purpose, input (code snippet), size limit via schema, and behavioral constraints. It omits explicit mention of the return format (the detected language/format), but that is implied by the name and description. Given no output schema, a brief note on return could improve completeness, but current info is largely sufficient.

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 already provides a description for the single 'code' parameter, and schema coverage is 100%. The tool description does not add additional parameter semantics beyond what's in the schema, so the baseline 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 uses a specific verb 'Detect' with a clear resource 'the language/format of a code snippet,' making the tool's function immediately obvious. It also distinguishes itself from sibling tools like convert_code and minify_code, which focus on transformation rather than detection.

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 implies the primary use case: identifying the language/format of a code snippet. It does not explicitly mention when not to use it or name alternatives, but the distinction from siblings (e.g., convert_code) is implicit. Context is clear without formal exclusions.

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

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

Annotations already state readOnlyHint and idempotentHint; the description adds that the image is processed in memory and never stored, plus the exact output fields (hex, rgb, hsl, share, human color name). This provides meaningful behavioral context beyond 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?

Two sentences: the first states purpose, the second covers input options and output. No filler, effectively front-loaded, every sentence provides value.

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

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

With no output schema, the description lists the return fields (hex, rgb, hsl, share, name) to set expectations. Combined with complete schema parameter descriptions, it provides sufficient context for invoking the tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds only a minor example ('e.g. a local screenshot') and the max base64 size, slightly enhancing but not substantially replacing what the schema already explains.

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

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

The description opens with 'Extract a dominant-color palette from an image' – a specific verb and resource. It further distinguishes this from sibling palette tools by mentioning the return of the closest human color name and the one-call named palette.

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?

Clear usage instructions are given: provide either a public image_url or image_base64 (with a local screenshot example). However, it does not explicitly contrast this tool with siblings like get_palette or state when not 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?

Annotations already declare readOnlyHint and idempotentHint, and the description reinforces these by stating 'writes and stores nothing.' It adds the context that the tool returns a CSS snippet, which is useful beyond 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 two sentences, with the purpose front-loaded and the side-effect clarification following. Every sentence contributes essential information with no fluff 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?

Given the schema fully describes all parameters and annotations cover safety, the description is sufficient. It communicates the core function and return type, though it does not detail output formatting, which is acceptable for a pure calculation tool without an output schema.

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?

All six parameters are fully described in the input schema (100% coverage). The description does not add parameter-specific details, but the schema already provides comprehensive descriptions for each parameter, so the baseline 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 clearly identifies the tool's function with the verb 'Calculate' and the resource 'fluid CSS clamp() expression', scoping it to responsive sizing between viewport widths. It distinguishes itself from sibling tools by emphasizing pure calculation and no storage, making its purpose unambiguous.

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

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

The description provides clear context for when to use this tool — for generating a CSS clamp() between two viewport widths — and explicitly states it is a pure calculation. It does not name alternatives or exclusions, but the context is sufficiently clear to differentiate from 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 declare readOnlyHint=true and idempotentHint=true, so the description does not need to restate safety. It adds the detail of outputting hex values and lighter/darker steps, which is useful but does not disclose nuances like default step behavior or output format. This is adequate but not rich beyond 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 a single sentence of 14 words, starts with the action verb, and avoids any fluff. Every word contributes to the core meaning, making it highly concise and well-structured.

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

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

The tool has only 3 parameters, all documented, and no output schema. The description mentions 'with hex values' but does not specify the exact return format (e.g., array, object). Given the simplicity and annotation coverage, it is acceptable but leaves some ambiguity about output structure.

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%, with each parameter (hex, step, limit) already having a clear description. The tool description does not add any extra meaning beyond what the schema provides, 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 uses a specific verb 'Generate' and clearly identifies the resource: tints and shades for a base color, with lighter/darker steps and hex values. This distinguishes it from siblings like get_palette or extract_colors, making the purpose unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention scenarios, exclusions, or that get_palette might be more suitable for full palettes. Given the sibling tools, the lack of differentiation leaves the agent to guess.

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 readOnly and idempotent; the description adds value by enumerating the returned metadata fields (styles, weights, axes, license, subsets, download/CSS URLs), giving agents concrete expectations of the response. It does not cover error behavior, but the annotations satisfy the safety profile.

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

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

One concise sentence that leads with the verb and resource, then enumerates contents efficiently. 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?

Given the tool's simplicity (one param), strong annotations, and a description that explicitly lists the return value categories, the description is complete for an agent to successfully invoke and interpret results. No output schema exists, but the description compensates adequately.

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 'slug' parameter is fully described in the schema with an example. The description reinforces 'by slug' but adds no additional syntax, constraints, or formatting details beyond what the schema already provides, 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 clearly states the tool retrieves full metadata for a single font family by slug, listing specific content areas (styles, weights, axes, license, subsets, URLs). This distinguishes it from sibling tools like get_font_files or get_font_download_url, which target narrower subsets.

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 usage context is implied: you need a font slug and want comprehensive metadata. However, it does not explicitly mention when to prefer this over search_fonts or when to use the more specific sibling tools, leaving some ambiguity.

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 and idempotentHint, and the description complements this by explicitly stating the tool does NOT download the file, only returns the URL. This adds behavioral context beyond the annotations, though it does not mention error handling or invalid slugs.

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 with no wasted words; the first sentence states the core function, and the second clarifies the non-downloading behavior. It is front-loaded with the purpose and remains highly concise.

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 tool with one parameter and strong annotations, the description covers the return value, contents of the ZIP, and the distinction between returning and downloading. It is complete enough for an agent to select and 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?

The input schema fully describes the 'slug' parameter with an example ('inter'), and the description references 'font family' but does not add extra meaning beyond the schema. Since schema coverage is 100%, 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 clearly states the tool returns a direct ZIP download URL for a font family, using a specific verb ('Return') and resource. It also distinguishes from sibling tools by noting it does not download and includes a ready fonts.css, differentiating it from get_font_files or get_fonts_css.

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

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

The description implies the tool is used when the user needs a download link rather than actual file content, advising to hand the URL to the user or fetch separately. It does not explicitly name alternatives, but the usage context is clear and actionable.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds valuable behavioral context: it lists every file (exhaustive), includes weight/italic/format details, and direct URLs. This goes beyond the annotations and helps set expectations for the returned data, despite lacking error or edge-case behavior.

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

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

The description is a single, information-dense sentence that front-loads the main action and resource, then adds the use case. Every word earns its place, with no fluff 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?

Given the tool's low complexity (one parameter, no output schema), the description is complete enough: it explains what is returned (font files with weight/italic/format and URLs) and why you'd use it (custom @font-face rules). It does not specify the response structure (e.g., JSON array), but that is a minor gap given the 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?

The schema provides 100% coverage for the single parameter 'slug' with an example 'inter'. The tool description does not add further parameter semantics beyond what the schema already states, so the baseline 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 uses the specific verb 'List' and names the resource 'every font file' for a family, including the key attributes (weight/italic/format + direct woff2/ttf URL). This clearly distinguishes it from sibling tools like get_font_download_url or get_fonts_css, which serve different purposes.

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

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

The description provides a clear use case: 'handy for building custom @font-face rules.' This implies when to use the tool (when you need all font files for a family rather than a single URL or a full CSS stylesheet). It does not explicitly list exclusions or alternatives, but the context is strong.

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

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

Annotations already declare readOnly and idempotent hints. The description adds that the tool returns CSS text and explains the family spec format, providing useful context beyond the annotations. No contradictions.

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?

Single, front-loaded sentence with examples and return type, no filler. Every element 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 2-param tool with read-only annotations, the description covers purpose, input format, and output type. Without an output schema, specifying 'Returns CSS text' provides adequate completion.

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% for both parameters. The description provides examples that mirror the schema descriptions, adding little new meaning. 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?

The description clearly states the tool generates @font-face CSS from a family spec, with specific verb 'Generate' and resource 'CSS'. It includes concrete examples distinguishing it from sibling tools that download fonts or files.

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: it's for creating CSS-ready font-face rules from a Google-Fonts-compatible spec. However, it does not explicitly mention alternatives or when not to use this tool, though the context is clear enough.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, covering safety. The description adds useful behavior: it discloses the specific palette attributes returned, including the nuance of 'name/derived title' (a fallback naming behavior). This exceeds annotation context and explains what the tool yields.

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

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

The description is a single, front-loaded sentence with actionable verb ('Get'), clear resource ('one color palette by id'), and a compact list of returned fields. 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?

For a simple get-by-id tool with one parameter and no output schema, the description adequately covers the return contract by listing all palette attributes (colors, name/derived title, mood, harmony, temperature, tags). This compensates for the absent output schema and makes the tool self-explanatory.

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 already fully documents the only parameter `id` with a description, achieving 100% schema coverage. The description adds no semantic detail beyond referencing retrieval by id, 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 states it gets one palette by ID and enumerates the exact returned fields (colors hex, name/derived title, mood, harmony, temperature, tags), making its specific purpose clear and distinct from sibling tools like search_palettes (which finds palettes) and get_color_shades (which works from a color).

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 usage context is implied: use when you have a specific palette ID and need its full details. However, it does not explicitly contrast with search_palettes or state when not to use this tool, leaving the agent to infer the distinction from the phrase 'by id'.

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 and idempotentHint, so the safety profile is covered. The description adds behavioral context by detailing exactly what the response includes (source, parameters, usage example), which is valuable given the absence of an output schema.

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 action and resource, then succinctly lists return contents. Every phrase earns its place, with no redundant or filler 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 simple read-only, single-parameter tool with robust annotations, the description is complete. It tells the agent what the tool does, what input is needed, and what output to expect, which is sufficient for selection and invocation without an output schema.

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

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

The schema fully documents the single 'id' parameter with format (kebab-case) and examples. The description only restates that lookup is by id, adding minimal meaning beyond the schema. With 100% schema coverage, a baseline 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 clearly states the action ('Get'), the resource ('SCSS mixin'), and the scope ('by id'), while also specifying the return content (full source, parameters, usage example). This distinguishes it from sibling tools like list_scss_mixins, which serve a different purpose.

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

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

The description clearly implies usage when a specific mixin id is known and details are needed, contrasting with listing all mixins via list_scss_mixins. However, it does not explicitly mention when not to use it or name alternatives, leaving the guidance slightly implicit.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds valuable context beyond the annotations by specifying that the returned list includes from/to ids and option schemas, which gives the agent an idea of the response content in the absence of an output schema.

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, concise sentence that leads with the action verb 'List' and packs essential information (resource, metadata content) without any fluff. Every word contributes to the meaning.

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 tool with no parameters and no output schema, the description provides sufficient detail about what the tool returns (from/to ids and option schemas). The annotations cover safety and idempotence, making the overall context complete.

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

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

The tool has zero parameters, so the baseline is 4. The description adds no parameter information because there are none, but it does mention per-converter option schemas, which are relevant to the converters themselves. This is acceptable given the absence of 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 ('List') and clearly identifies the resource ('available code converters') and the exact information provided (from/to ids and per-converter option schemas). This distinguishes it from sibling tools like convert_code, which performs conversions, and other list tools like list_scss_mixins, which target 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 makes the context clear: use this tool to enumerate code converters with their metadata. It does not explicitly mention when not to use it or point to alternatives, but the purpose is straightforward enough that no exclusion guidance is needed. A score of 4 is appropriate for clear context without explicit 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 indicate read-only and idempotent behavior. The description adds useful context about what the catalog contains (id, title, short description), which is not present in the schema. It does not discuss pagination or limits, but for a simple catalog list this is 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?

The description is a single sentence that is direct and front-loaded. It conveys the purpose and key options without 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?

With no output schema, the description explains the return fields (id, title, short description), which is sufficient for a simple listing tool. The optional 'fields' parameter is described in the schema, so the description need not duplicate it, but the full output details are not elaborated.

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 parameters. The description briefly mentions 'filtered by group or search' but adds no meaning beyond what the schema provides. This meets the baseline for full coverage.

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

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

The description uses a specific verb 'List' and clearly identifies the resource as the 'SCSS mixin catalog', including the output fields (id, title, short description). This distinguishes it from the sibling get_scss_mixin tool, which is likely for retrieving a single mixin.

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

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

The description provides clear context that this is for browsing the mixin catalog, optionally filtered by group or search. It does not explicitly mention when to use an alternative like get_scss_mixin, but the listing purpose is obvious and no exclusions are needed.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, side-effect-free operation. The description adds little beyond what the annotations and name convey: it says the tool lists presets and their purposes, but does not describe return structure (e.g., array of objects) or whether the list is static or dynamic. With annotations covering the safety profile, no additional context is strictly needed, so a neutral score 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, front-loaded sentence that states the action ('List'), the subject ('SVG optimization presets'), and the outcome ('what each one does'). There is zero redundancy or irrelevant detail, making it highly 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?

For a simple, parameterless list tool, the description is nearly complete. It clearly states what the tool returns. A minor gap is that it does not explicitly connect to optimize_svg (the likely consumer of these presets) or indicate the output format, but given the output schema absence and the tool's simplicity, the description is sufficiently complete.

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

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

The tool has zero parameters, and the schema is an empty object. Per the rubric, a 0-parameter tool receives a baseline of 4 because there are no parameter semantics to clarify. The description's mention of 'available' presets is a minor addition, but no parameter documentation is needed.

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

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

The description uses the specific verb 'List' and clearly identifies the resource as 'the available SVG optimization presets' plus what each does. This unambiguously distinguishes it from sibling tools like optimize_svg (which performs optimization) and other list tools (list_code_converters, list_scss_mixins), which target 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 provides no explicit guidance on when to use this tool versus alternatives. It does not mention related tools such as optimize_svg or other list_* tools, nor does it state a recommended workflow (e.g., 'use this to see available presets before optimizing'). The usage context is only implied by the tool name, not stated.

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

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

Annotations already convey read-only and idempotent behavior. The description adds valuable context by stating 'never executed and never stored,' which goes beyond the annotations, clarifying security and data-handling aspects. This is useful but not exhaustive, hence a score of 4.

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

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

The description is concise, consisting of three short sentences. It front-loads the core purpose, includes a key usage tip, and adds a safety note without any unnecessary words. 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?

The tool has four parameters, two required, and no output schema. The description covers the main behavior, usage, and safety, making it sufficiently complete for an agent to understand what the tool does. It does not explicitly mention the return format, but given the simplicity of a minifier/beautifier, this is a minor gap.

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

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

Schema description coverage is 100%, so the parameters are fully documented in the schema. The description adds no additional parameter semantics beyond what is already present (e.g., 'Set type=auto' mirrors the schema's auto option). Per rubric, baseline 3 is appropriate for high schema coverage with no extra info from the description.

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

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

The description clearly states the tool's purpose: 'Minify or beautify JS, CSS, HTML, SVG, JSON or XML text.' The verb is specific and the resource is well-defined. However, it does not explicitly differentiate from sibling tools like convert_code, so it doesn't fully meet the 5-star criterion of distinguishing from siblings.

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

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

The description provides a clear usage instruction with 'Set type=auto to sniff the language,' indicating when to use the auto-detection feature. It gives context on supported languages but does not specify exclusions or explicitly name alternative tools for other tasks, so it's a 4 rather than 5.

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

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

Annotations already declare readOnlyHint and idempotentHint, which describe the safety profile. The description adds useful behavioral context beyond annotations by specifying the return components: nearest color name, reference hex, exact-match flag, and perceptual distance. It also discloses the 'up to 100 at once' limit, which is not in the annotations. This is solid transparency, though it does not discuss error conditions or response format details.

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 that front-loads the purpose, then provides the input format, example, and output details. Every clause contributes necessary information; there is no wasted text or redundancy. It is concise yet comprehensive.

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 with no output schema, the description is complete: it explains what the tool does, how to pass input, what the output contains, and operational limits. The annotations cover safety, and the return value breakdown compensates for the lack of an output schema. No important context 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% for the single parameter 'hex', which already fully describes the format, examples, and limit. The tool description simply repeats this information without adding new semantics. Baseline 3 is correct because the schema does the heavy lifting, and the description adds no additional parameter meaning.

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

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

The description uses a specific verb and resource: 'Get the closest human-readable name for one or more colors.' It clearly distinguishes the tool's purpose from siblings like extract_colors, get_palette, or check_contrast by focusing on naming colors. The description also provides a direct input example, making the tool's function unambiguous.

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

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

The description clearly states the context for use: when you have hex colors and need their nearest human-readable names. It gives explicit input format instructions and a usage example, but it does not explicitly mention alternatives or conditions when not to use the tool. This is clear context without exclusions, so a 4 is appropriate.

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

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

Beyond the readOnly and idempotent annotations, the description discloses that nothing is executed or stored, which is a meaningful safety guarantee, and describes the return format (minified SVG plus before/after sizes). This adds value beyond the annotations.

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

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

Two compact sentences that front-load the purpose and then add safety and output information. Every word earns its place.

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

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

For a tool with a simple 2-parameter schema, rich annotations, and a clear output description, this is fully sufficient to understand what it does, its safety profile, and what it returns. The only minor gap is not explaining preset differences, but the schema 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?

Both parameters are fully described in the schema (100% coverage), so the description doesn't need to add much. It does mention the SVGO context and the before/after sizes, which indirectly relates to the svg and preset parameters, but no extra semantic depth.

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 'Optimize/clean SVG markup (SVGO)' with a clear verb and resource, distinguishing it from siblings like minify_code (general code) and svg_to_datauri (conversion).

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

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

It provides clear use context: pure markup transformation with no execution or storage, implying it's safe for static SVG optimization. However, it doesn't explicitly name alternative tools or exclusions, so it's slightly below full marks.

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 substantial behavioral context beyond the annotations: the image is 'processed in memory and deleted immediately — never stored', the underlying CNN model matches by visual shape/style, and it is fast (~200 ms). These details are not in the annotations and provide valuable privacy and performance expectations.

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

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

The description is concise yet comprehensive, covering purpose, technology, input requirements, privacy, output, and performance in five sentences. Every sentence contributes meaningful information with 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?

Despite no output schema, the description explicitly states what is returned: 'the most visually similar font families with scores.' Combined with clear input instructions and behavioral notes, the description is complete for this tool's complexity and leaves no obvious gaps for 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?

The schema already covers all parameters with 100% description coverage, meeting the baseline of 3. The description adds extra meaning by clarifying the 'tight crop' requirement and explaining the two image parameter alternatives (public URL vs. local screenshot/base64). It does not mention top_k, but the schema fully explains it.

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

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

The description clearly states the tool's function: 'Identify which font is used in an image.' It uses a specific verb and resource, and distinguishes itself from sibling tools by emphasizing the CNN embedding model and visual matching (no OCR), which separates it from text-based search tools like search_fonts.

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

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

The description provides clear context for when to use the tool: send a tight crop of one line of text via image_url or image_base64. It explains the input format and even notes supported scripts (Latin/Cyrillic). However, it does not explicitly mention alternative tools or when not to use it, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint, openWorldHint, and idempotentHint, covering safety. The description adds context about the catalog being free and the return being paginated, which is useful. However, it does not explain how filters combine across different parameters (e.g., AND vs OR) or any edge cases like pagination defaults, though some of that is in the schema descriptions. 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 two short sentences. The first sentence states the action and the search dimensions, and the second states the return type. There is no wasted wording, and the most important information (what it searches) is front-loaded.

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

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

For a complex search tool with 12 optional parameters, the description is reasonably complete given the rich schema and annotations. It states the return type (paginated families) and the catalog scope (free). It does not explicitly mention that all filters are optional and combinable, nor does it detail cross-parameter AND semantics, but these are common for search tools and partially covered by schema descriptions for langs and style.

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 each parameter has a clear description. The tool description groups parameters into logical categories (name, category, style tags, etc.) but adds no new meaning beyond what the schema already provides. The baseline of 3 applies because the schema carries the full semantic weight.

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 'Search' and names the resource 'free font catalog', then enumerates the key filter dimensions (name, category, style tags, language coverage, variable/monospace flags, style count). It clearly distinguishes this from sibling tools like search_palettes or get_font by focusing on catalog search. The return type (paginated list of families) is also stated, making the purpose unambiguous.

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

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

The description implies the tool is for searching fonts by various criteria, but it does not explicitly state when to use this tool versus alternatives like search_palettes or get_font. No exclusions or alternative tool references are provided. While the context is clear, the lack of differentiation from sibling search tools leaves the agent to infer the appropriate selection.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, covering safety and side-effect concerns. The description adds that it returns a paginated list, which is useful, but it does not elaborate on pagination behavior or result content beyond that. It adds some value but does not go far beyond the structured 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, front-loaded with the verb 'search' and the resource, and wastes no words. Every part is relevant and it remains fully readable.

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 10 parameters and no output schema, the description is on the minimal side. It notes pagination but does not explain how filters combine (e.g., AND vs OR), what fields appear in the result list, or default sorting. Schema covers parameter descriptions, so the agent can infer, but the description could compensate more for the absent output schema.

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 parameters are already documented meaningfully. The description merely lists the same search dimensions without adding extra syntax, combination logic, or defaults. It provides no additional value 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 searches the color-palette catalog by specific criteria (name, tone, temperature, mood, harmony, color count, tags). This distinguishes it from sibling tools like search_fonts (searching fonts) and get_palette (fetching a specific palette).

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 use for finding palettes by various attributes but does not explicitly mention when to prefer this over alternatives or provide exclusions. The purpose is clear enough for an agent to infer usage, but it lacks direct guidance such as 'Use for discovery, use get_palette for a known ID.'

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, openWorldHint, and idempotentHint, so the tool is known to be non-destructive, may fetch external resources, and is repeatable. The description adds context about fetching images from URLs and producing a CSS-ready data URI, but does not detail defaults or error behavior, offering only modest supplement.

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 core action and output, with no wasted words. It efficiently covers both input modes without 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 conversion tool with a detailed schema and safety annotations, the description is adequate. It explains the output format (CSS-ready data URI) and both input modes, while the schema covers parameter defaults and enums. It does not need to elaborate on return values since the output is self-evident, though it could mention edge-case behavior.

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

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

The input schema provides comprehensive descriptions for all four parameters, including mutual exclusivity and encoding defaults, so the baseline is 3. The description's 'Provide either raw svg or a url' reinforces exclusivity but adds no new syntax or formatting details 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 encodes an SVG or fetched image into a CSS-ready data URI, using a specific verb and resource. It distinguishes itself from sibling tools like optimize_svg or convert_code by focusing on data URI generation. The mention of both raw SVG and URL inputs adds 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 clear usage context: for generating a CSS-ready data URI, and tells users to provide either raw SVG or a URL. However, it does not explicitly discuss when not to use the tool or name alternatives, so it lacks full exclusionary guidance.

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