Cleanor

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

Annotations already declare readOnlyHint and idempotentHint, lowering the bar. The description adds valuable context beyond annotations: 'UTF-8 safe' and 'Supports URL-safe alphabet' disclose encoding behavior that is not present in the annotations or schema. 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 concise sentences: the first states purpose and key features, the second gives usage guidance. Every word earns its place, with no fluff or repetition of schema fields.

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 encode/decode tool with a complete output schema and strong annotations, the description is fully adequate. It covers purpose, usage context, and key behaviors without needing to explain return values or edge cases.

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%, so the schema fully documents each parameter (mode, input, url_safe). The description does not add further parameter-level details beyond the schema, meeting the baseline of 3.

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 immediately states the core function ('Encode text to Base64 or decode Base64 back to text') with specific details like UTF-8 safety and URL-safe alphabet support. It clearly differentiates from sibling tools by naming the encode/decode operation, making the purpose unmistakable.

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 explicit use cases: 'Use whenever you need to encode/decode data URIs, tokens, or config values instead of guessing the bytes.' This gives clear context for when to apply the tool, though it does not exclude alternatives by name, which would warrant 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 and idempotentHint, so safety behavior is covered. The description adds meaningful context beyond those annotations: 'Arbitrary precision via BigInt, so large values stay exact' and the integer-only constraint. This enriches the behavioral model without contradicting the structured metadata.

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

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

Three sentences total, front-loaded with a clear purpose statement followed by precision detail and a usage directive. No wasted 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 is simple, annotations confirm it is read-only and idempotent, and an output schema exists (so return format is already covered). The description covers scope, precision, examples, and usage guidance, making it complete for an AI agent to select and invoke the tool confidently.

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

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

Schema description coverage is 100%, with each parameter fully described (value as string, from_base with default 10, to_base with default 16). The description reinforces this with examples but does not add syntax or format details beyond what the schema already provides. The arbitrary precision note about large values adds a small layer of contextual 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 opens with a specific verb ('Convert') and resource ('integer between number bases 2–36'), then gives concrete examples (hex to binary, decimal to base-36). This clearly distinguishes it from sibling tools like unit_convert, which handle physical unit conversions rather than radix conversions.

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 final sentence, 'Use for radix conversions instead of doing them by hand,' explicitly states when to use the tool. It provides context through the base range and integer scope, though it does not explicitly mention when not to use it or name alternatives, which keeps it from 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 and idempotentHint. The description adds behavioral value by stating that it returns all three representations at once, which clarifies the output shape and the fact that no side effects occur. It does not cover error behavior or edge cases, but this is acceptable given 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 sentences: the first explains exactly what the tool does, the second gives the common use cases. Every word earns its place 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 single-parameter conversion tool, the description covers input formats, output format, and use context. An output schema exists, so return values are documented elsewhere. It could mention handling of alpha channels or invalid inputs, but these gaps are minor.

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%, as the 'value' parameter already includes examples of each format. The tool description repeats the accepted formats but adds no semantic detail beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the verb 'convert' and resource 'a color', specifies accepted input formats (hex, rgb(), hsl()) and the output (hex, RGB, and HSL representations). This distinguishes it from sibling tools like unit_convert or base_convert.

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 an explicit use case: 'Use when picking or translating colors for CSS, design tokens or themes.' It doesn't name alternatives or exclusions, but for a simple conversion tool this context is sufficient.

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, idempotentHint, and openWorldHint=false, covering safety and determinism. The description adds some context about output (hex and HSL) and mentions color-theory rules, but these are largely echoed in the output schema and parameter enum. No behavior beyond what annotations and schema already convey is disclosed.

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

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

Two sentences deliver the core action, examples of harmony rules, output format, and a use case. Every phrase earns its place 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?

For a 2-parameter, read-only, idempotent tool with a full output schema, the description is complete. It explains what the tool does, its inputs, output format, and typical use, leaving no significant gaps.

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

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

Schema description coverage is 100%: both 'color' and 'harmony' have clear descriptions, and harmony's enum and default are documented. The description repeats the harmony examples and adds 'hex and HSL' as output, but does not enrich parameter meaning beyond the schema. Baseline 3 for high coverage 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 a specific action: 'Build a harmonious color palette from a base color using color-theory rules', listing all supported harmony types. This distinctly separates it from sibling tools like 'color', which likely handles single color conversions, and the title reinforces the 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?

It provides a clear use case: 'Use to derive a theme or design tokens from one brand color.' While it doesn't explicitly mention alternatives or exclusions, the context is sufficient to decide when to invoke it. A more explicit pointer to sibling 'color' for single-color operations would have made it 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=true and idempotentHint=true, so the safety profile is covered. The description adds context about what is counted (Unicode code points vs UTF-16 units vs UTF-8 bytes), which is useful behavioral detail beyond the annotations. It does not describe return format or edge cases, but given the annotations cover the main risks, a score of 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 two sentences, both earning their place. The first lists the countable units, the second gives a compelling usage guideline. No filler or redundant phrasing. It is well-structured and front-loaded with the core functionality.

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

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

The tool is simple with one parameter, full schema coverage, and an output schema present (as indicated by context signals). The description covers the purpose, usage context, and accuracy guarantees. It is complete for a tool of this complexity.

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

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

Schema description coverage is 100%: the input parameter has the description 'Text to measure.' which fully explains its purpose. The tool description adds no additional parameter-level detail beyond what the schema provides, so the baseline score of 3 is retained.

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 what the tool does: 'Accurately count characters (Unicode code points), UTF-16 units, words, lines and UTF-8 bytes in text.' It uses a specific verb ('count') and a specific resource (text), and enumerates the exact metrics. This distinguishes it from sibling utility tools like base64 or json_format, 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 explicit guidance on when to use the tool: 'LLMs are notoriously bad at counting, so always use this tool for "how many characters/words" questions.' This clearly communicates the intended use case. However, it does not explicitly mention when not to use it or name alternative tools, though the sibling set makes alternatives obvious.

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 declare readOnlyHint=true, and the description adds that the output is a plain-English breakdown and next run times in UTC. It does not explicitly state that 'next few' are relative to the current time, but with readOnly hint and output schema present, this is adequate.

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

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

Two sentences, front-loaded with the core action and then the usage rationale. No redundant words; every clause adds value.

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

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

The tool has a single parameter and an output schema, so the description does not need to explain return structures. It covers the input format, output nature, and timezone, which is complete for this simple utility.

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

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

Schema coverage is 100% and includes an example, but the description further clarifies the field order ('minute hour day-of-month month day-of-week'), which is not in the schema's brief '5-field cron expression' text. This adds meaningful semantics 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 uses a specific verb ('Parse') and identifies the exact resource (standard 5-field cron expression) and the two outputs (plain-English breakdown and next run times). It clearly distinguishes this from sibling tools, none of which relate to cron parsing.

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

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

Explicitly suggests when to use it ('Use to sanity-check a schedule instead of guessing what the fields mean'), which tells the agent the intended context. It doesn't mention exclusions or alternatives, but no sibling tool overlaps, so the guidance is sufficient.

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. The description adds meaningful behavior: it accepts Unix seconds/ms or ISO strings, omitting input means 'now', and output includes ISO, Unix, and human-readable forms. It does not contradict annotations and provides useful context beyond the structured fields.

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 filler. It front-loads the primary purpose and then efficiently explains input handling and rationale. 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 is simple, and a full output schema exists. The description covers purpose, input formats, timezone behavior, and usage rationale. No significant gaps remain for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description repeats that input can be a Unix timestamp or ISO string and mentions the IANA timezone, but it does not add meaning beyond what the schema already provides for each parameter.

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 gets the current date/time or converts a given timestamp into a target IANA timezone, with ISO, Unix, and human-readable forms. It uses specific verbs ('get', 'convert') and specifies the resource (date/time, timestamp, timezone), making it distinct from all sibling tools.

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

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

The description explicitly says 'LLMs cannot know the real current time, so use this instead of guessing', giving a clear when-to-use scenario. It does not name alternatives or exclusions, but no sibling tool offers similar date/time functionality, so the context is sufficient.

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 annotations already declare readOnlyHint and idempotentHint, so the description adds valuable behavioral details beyond them: the exact prefix notation for diff lines and the line cap. This gives the agent a better sense of the output format and limits without needing to invoke the tool.

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 three concise sentences, front-loaded with the primary action and output format. Every sentence earns its place: what it does, the marking style and count, the use case, and the line cap. There is no wasted wording.

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 covers the core purpose, the exact output format, a practical usage motivation, and a critical limit. With an output schema present to detail the return structure and complete schema descriptions for both parameters, the description is comprehensive for this moderate-complexity 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?

Both parameters ('a' and 'b') have descriptions in the schema ('original (before)' and 'updated (after)'), achieving 100% schema coverage. The description's mention of 'two texts' adds no new semantic detail beyond what the schema already provides, 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 states the tool's function with a specific verb ('Compute') and resource ('line-by-line diff between two texts'), and details the output format (marking removed/added/unchanged lines plus a change count). It stands out distinctly from unrelated siblings such as base64, color, or count.

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 context ('Use to see exactly what changed instead of comparing by eye') and mentions a constraint (capped at 1000 lines per side). However, it does not explicitly name alternative tools or provide when-not-to-use conditions beyond the cap, so it falls short of the highest bar.

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 read-only and idempotent hints. The description adds useful context: MD5 is excluded because it is broken and unavailable in Web Crypto, and LLMs cannot compute hashes reliably, making tool use necessary. This goes beyond the annotations without contradicting them.

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 three sentences: it states the action, lists use cases, and explains the MD5 exclusion and LLM limitation. Every sentence adds value, and the key action 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?

With an output schema present and annotations providing safety profile, the description covers purpose, use cases, limitations, and parameter behavior. There are no significant gaps for this simple hashing 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?

The input schema already covers both parameters with descriptions and an enum (100% coverage). The description reiterates the algorithm list but adds no new parameter-level detail, so it meets the baseline for high schema 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 clearly states it computes a cryptographic hash of text using SHA algorithms and returns a hex digest. It is specific about the resource and action, but does not explicitly differentiate from the sibling hmac tool, so it falls short of a 5.

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

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

The description gives explicit use cases ('checksums, cache keys, or verifying content') and states that MD5 is intentionally not offered. It does not mention alternatives like hmac or explicitly say when not to use this tool, so it is good but not fully explicit.

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, covering safety. The description adds valuable context with 'LLMs cannot compute this by hand,' explaining why the tool exists and warning the agent not to attempt manual calculation. It also reinforces the keyed-hash behavior (needing a secret), going beyond the annotation-only baseline.

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

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

Three concise sentences: the first says what it does, the second when to use it, and the third why it is necessary. Every sentence earns its place, with no fluff or repetition. The most critical information 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 utility tool with a full schema, an output schema, and safety annotations, the description is complete. It covers the function, the use case, and the limitation (LLM hand-computation). The absence of return-value details is acceptable since an output schema exists. No gaps remain for the agent to invoke it correctly.

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

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

Schema description coverage is 100%, with each parameter (secret, message, encoding, algorithm) already fully described. The tool description does not add any meaning beyond the schema—it merely restates algorithm and encoding options. Baseline 3 applies when the schema carries the load.

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

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

The description opens with a specific verb 'Compute' and names the exact resource: 'an HMAC (keyed hash) of a message with a secret'. It lists supported algorithms (SHA-1/256/384/512) and output formats (hex/Base64), immediately distinguishing it from the sibling 'hash' tool by emphasizing the keyed nature and its signing/verification use case.

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 states when to use the tool: 'Use to sign webhook payloads or verify a signature instead of guessing.' This gives clear context for invocation. However, it does not explicitly name an alternative tool (e.g., 'use hash for unkeyed digests'), so it stops short of the highest score.

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

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

With readOnlyHint=true, the description adds useful context beyond the annotation: the benchmark source ('Cleanor Labs’ controlled benchmark') and the additional HEIC conversion tax output. It does not contradict annotations and provides a clear behavioral picture without needing to describe side effects.

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

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

Two sentences, front-loaded with the core value proposition, then the extra HEIC detail, and finally the use case. Every sentence earns its place; no filler or repetition of schema 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?

The tool has only 2 parameters with full schema descriptions, an output schema, and a clear description covering purpose, use case, and additional output. The agent has all necessary context to select and invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning by explaining the 'matched perceptual quality' concept, which directly relates to the quality parameter. It also ties the format parameter to the comparison against JPEG, going beyond the schema's enum list.

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 specifies the tool's function: it quantifies storage savings of WebP, AVIF, and JPEG XL over JPEG at matched quality. It also mentions the HEIC conversion tax and explicitly states the intended use ('justify a format choice'), distinguishing it from sibling tools like optimize_image or placeholder_image.

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

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

The description gives an explicit use case: 'Use to justify a format choice when building a site or app.' It clearly indicates when to use the tool. It doesn't name alternatives or exclusion criteria, but the context is sufficient for an agent to decide between this and other image-related tools.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so safety is covered. The description adds valuable behavioral detail: it returns a precise parse error with position if invalid, which informs the agent of failure behavior. This is beyond what annotations provide and is useful for handling errors.

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 fluff. The first sentence states core functionality, the second adds error behavior and usage guidance. Information is front-loaded and every clause 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 covers validation, formatting modes, optional key sorting, and error reporting. Given the tool's moderate complexity, full schema coverage, and presence of an output schema, the description is complete enough for an agent to invoke it correctly.

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

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

Schema coverage is 100% with each parameter fully described (input, mode with enum, sort_keys with default). The description repeats the mode and sort behavior without adding new meaning, so it does not elevate beyond the baseline of 3. It confirms the intended use but doesn't offer extra insight.

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 validates JSON and can pretty-print or minify it, with optional key sorting. This is a specific verb + resource ('Format / validate JSON') and differentiates from sibling tools by focusing on JSON processing rather than encoding, hashing, or 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 provides context: 'Use to check and clean JSON instead of eyeballing it.' This indicates when the tool is appropriate, though it does not explicitly mention when not to use it or alternatives. The guidance is clear enough for an agent to select it for JSON validation/formatting needs.

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

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

Annotations already declare readOnlyHint and idempotentHint, but the description adds critical behavioral context: 'The signature is NOT verified and no secret is required or stored.' This goes beyond the structured annotations by clarifying security implications and output content (header and payload).

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

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

Three sentences with zero filler. The first sentence states purpose and output, the second highlights the critical caveat, and the third gives a direct use case. Information is 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?

For a simple single-parameter tool with an output schema declared, the description fully covers the purpose, behavior, output, and use case. It also addresses security-relevant aspects (no verification, no secret storage), making it complete for both selection and invocation.

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

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

The input schema has 100% coverage with a description for the token parameter ('The JWT (three dot-separated segments)'). The tool description adds some context about what the decoded result contains, but it doesn't elaborate on the parameter beyond what the schema already states, so it meets the baseline without exceeding 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 action: 'Decode a JSON Web Token into its header and payload' and the purpose 'so you can inspect claims.' It distinguishes itself from sibling tools by specifically targeting JWT decoding, with the title also adding 'no verification.'

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

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

The description gives explicit usage context: 'Use to read a token during debugging.' It also implies a when-not by stating 'The signature is NOT verified,' signaling this is not for validation. However, it doesn't name alternative tools for verification, so it falls short of full exclusion 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 declare readOnlyHint=true and openWorldHint=true, and the description aligns with these, adding context beyond them. It discloses the key behavior: fetching from a public URL, re-encoding to a smaller size, and returning before/after byte sizes. This is useful contextual info beyond the annotations, though it does not reveal potential edge cases like URL accessibility or size limits, which are not required given the openWorldHint and schema coverage.

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

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

The description is two sentences long, front-loaded with the main action, and the second sentence justifies usage. Every word earns its place, with no redundant phrases or filler. It is concise, structured, and easy to scan.

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 complete for a tool with 4 parameters (1 required) and an output schema. It explains the core function, the optional resizing, and the return type (optimized image with before/after sizes). The use case is also stated. Given the output schema exists, it does not need to detail return values further. A minor gap is the lack of mention of potential input constraints (e.g., must be publicly accessible), but the schema's URI format already hints at this, so 4 is fair.

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 mentions 'optionally resizing to a target width' and lists formats, but these mirror the schema descriptions rather than adding new meaning. No additional parameter semantics beyond the schema are provided, so a 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 tool's function: 'Fetch an image from a public URL and re-encode it smaller (WebP/AVIF/JPEG), optionally resizing to a target width.' This uses a specific verb (fetch and re-encode) with clear resources and output. It distinguishes itself from siblings like placeholder_image (which generates placeholders) and image_format_savings (which likely estimates savings without performing conversion) by focusing on actual conversion/optimization.

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 an explicit use case: 'Use this when an AI-generated or dropped-in asset (hero image, screenshot, illustration) is too large to ship.' This gives clear guidance on when to use the tool. However, it does not explicitly mention when not to use it or name alternative tools like image_format_savings for comparative analysis, 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=true and idempotentHint=true, covering safety and determinism. The description adds meaningful behavioral context: the SVG is lightweight, dependency-free, and pastes directly into a page or mockup, implying the output is inline SVG markup. It does not contradict annotations and enriches them with output-format 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?

Two efficiently crafted sentences: the first states the core function and customization, the second adds dependency-free integration and a use case. Every word earns its place; no redundancy or repetition of schema details.

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, full schema coverage, output schema presence, and strong annotations, the description is complete. It covers purpose, output shape (SVG, paste-ready), and usage scenario. The output schema handles return-value details, so no further explanation is needed.

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 100% coverage of all five parameters, complete with descriptions and defaults. The description's references to 'optional label' and 'custom background/text colors' simply mirror the schema fields without adding new meaning. Per the rubric, high schema coverage warrants a baseline 3, which is appropriate 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 opens with a specific verb ('Generate') and identifies the resource ('lightweight SVG placeholder image') plus customization options (label, colors). It clearly distinguishes from sibling image tools like image_format_savings and optimize_image, which deal with format analysis rather than creation. The phrase 'instead of hotlinking a placeholder service' further narrows its unique role.

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 an explicit use case ('wireframes and design stubs') and an alternative to avoid ('hotlinking a placeholder service'), giving clear context. It stops short of listing when not to use the tool (e.g., when a raster PNG is required), so it lacks full exclusion criteria but still offers actionable 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?

The description adds context beyond the readOnlyHint annotation by specifying the output is a crisp, dependency-free SVG that can be pasted directly. This clarifies the return format and quality, which is useful behavioral information. No contradictions with 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?

A single, well-structured sentence that immediately states the action, input, and output. It is concise with no wasted words, and the key information is front-loaded.

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

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

The description adequately covers the tool's purpose, input, and output format, and the presence of an output schema reduces the need to explain return values. It could mention error-correction or size limits, but those are already in the schema, so overall it is complete enough for a simple generation 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?

The schema already provides full descriptions for all three parameters (text, ecc, size), covering their meanings and defaults. The description adds no additional parameter-specific semantics beyond confirming that text or a URL is encoded, so a 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 clearly states the tool encodes text or a URL into a QR code and returns an SVG. It uses a specific verb (encode) and resource (QR code), and distinguishes itself from sibling tools by its unique output format and dependency-free nature.

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 primary use case—generating a QR code for embedding in pages, decks, or docs—but does not explicitly exclude alternative tools. Since no sibling tool overlaps with QR generation, the context is clear enough, though not as explicit as naming 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?

The description adds the JavaScript flavor detail and notes length caps (input and pattern) to keep it fast and safe, supplementing annotations that already signal read-only and idempotent behavior. It also states output includes matches with groups and ideas, which goes beyond annotation info.

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 three sentences: purpose, usage, and safety constraint. Each sentence adds distinct value and is front-loaded with the core functionality, with no redundant wording.

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 regex testing tool with full schema coverage and an output schema, the description covers purpose, usage, and constraints. The presence of an output schema means the description doesn't need to enumerate return value structures, and annotations cover side-effect safety.

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 coverage, each parameter is already well-described in the schema. The description adds only a general note about length caps, which is already reflected in maxLength properties, so it provides minimal additional parameter semantics beyond 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 explicitly states the tool tests a JavaScript regular expression against sample text and returns match status, every match, captured groups, and indices. This specific verb+resource combination clearly distinguishes it from all sibling utility tools, none of which relate to regex testing.

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 guidance to use this tool to verify a pattern instead of reasoning about it mentally, which implies the appropriate use case. It does not explicitly exclude any scenarios or name alternative tools, so it falls slightly short of fully explicit when/when-not 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 readOnlyHint=true and idempotentHint=true, and the description adds useful behavioral context: 'lowercase, hyphenated, accents stripped' and 'URL-safe'. This goes beyond the annotations to describe the transformation behavior. 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 a concise two-sentence structure with the primary action front-loaded and the use cases clearly stated. No filler words or redundant information—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?

Given the low complexity, strong annotations, and presence of an output schema, the description fully covers what an agent needs to understand the tool's purpose, behaviors, and applicable scenarios. Nothing 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?

The input schema covers 100% of parameters with descriptions, so the baseline is 3. The description does not add significant parameter-specific meaning beyond noting the transformations; it restates the separator concept implicitly via 'hyphenated' but does not explicitly discuss the separator parameter. Schema descriptions carry the load.

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 with a specific verb ('Turn') and resource ('title or phrase into a clean, URL-safe slug'), and explicitly lists the transformations applied (lowercase, hyphenated, accents stripped). This distinguishes it from sibling utility tools like base64, hash, or url_parse.

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 explicit use cases ('page paths, filenames or anchor IDs'), which clearly signals when to use the tool. However, it does not mention any exclusions or alternatives, so it falls short of a full 5 per the rubric.

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 the description adds meaningful behavioral context: it corrects for OS/filesystem overhead and is backed by Cleanor Labs measured per-item sizes. This clarifies data provenance and the calculator's accuracy, going beyond the safety annotation without contradiction.

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

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

Three sentences, each earning its place: the core function, the data source, and concrete use cases. No fluff, front-loaded with the main question it answers.

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

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

For a simple two-parameter tool with an output schema, the description fully covers the tool's purpose, key corrections, and typical applications. The annotations cover safety, and the schema covers parameters and output, so no critical 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 coverage is 100%, but the description adds semantic value by explaining that the storage size is interpreted as advertised capacity and the result is corrected for real overhead. It also explicitly mentions 'photos or minutes of video', aligning with the content enum and clarifying the meaning of the output.

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: calculating how many photos or minutes of video fit in a storage size, with a specific verb ('fit') and resource ('storage size'). It also distinguishes itself from siblings by focusing on corrected/realistic capacity rather than generic conversion tools.

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

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

The description gives explicit use cases: 'Use for realistic sample copy, dashboards, or "how many photos fit in 128 GB" answers.' It doesn't mention alternatives or exclusions, but given no sibling tool overlaps significantly, the guidance is clear and practical.

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 adds value beyond that by listing the complete set of supported units and the exactness conditional. No contradictions with annotations; this is a pure, side-effect-free conversion operation.

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

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

The description is mostly a single purposeful sentence with a necessary unit list. It is front-loaded with the action and categories, and the trailing usage hint is concise. The long unit list is justified by the need to enumerate accepted values, so it earns a high but not perfect score.

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 3 required parameters and an output schema, the description covers the unit inventory and use case, making it functionally complete. It does not explain error behavior for incompatible units, but the schema's 'from'/'to' descriptions already convey the constraint. Overall, the agent has enough context to use it correctly.

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

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

Although the schema describes all parameters, it lacks enums for 'from' and 'to'. The description compensates by providing an exhaustive list of valid units, which is essential for correct invocation. This goes beyond the minimal schema descriptions and adds significant 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?

Description states a specific action ('Convert a value between units') and enumerates the categories (length, mass, data size, time, speed, temperature), distinguishing it from sibling conversion tools like base_convert or color. The title 'Convert between units' is reinforced by the detailed scope.

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

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

The instruction 'Use for exact conversions instead of approximating' provides clear usage context, implying this tool should be chosen when precise conversion is needed. It does not explicitly name alternatives or exclusions, but the context is sufficient for an agent to decide 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, covering the safety profile. The description adds value by specifying that query parameters are 'decoded' and by enumerating the output components. It does not discuss error behavior for invalid URLs, but the annotations lower the bar, and the added decode detail justifies a 4 rather than a 3.

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 tight sentences. The first sentence front-loads the action and output components; the second gives practical usage context. No wasted words.

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

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

This is a simple one-parameter, read-only tool with an output schema and supportive annotations. The description covers purpose, usage context, and the nature of the result (decoded query parameters). Nothing essential is missing for an agent to select and invoke it correctly.

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

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

Parameter schema coverage is 100%: the 'url' parameter is described as 'absolute, with scheme,' which aligns with the description's use of 'URL.' The description does not add any new parameter-level meaning beyond what the schema provides. 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 ('Break') and resource ('a URL'), and explicitly lists the output components (scheme, host, port, path, decoded query parameters, fragment). This clearly distinguishes the tool from sibling utilities, which are entirely different (base64, datetime, etc.).

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

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

The description gives explicit context for when to use the tool: 'Use to inspect or debug a URL instead of parsing it by eye.' It doesn't name an alternative tool, but among the siblings there is no obvious conflicting URL parser, so this guidance is sufficient. A dedicated 'when not to use' clause is absent, which prevents 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=true, so the tool is known to be safe. The description adds behavioral context by explaining randomness (v4) vs. time-sortability (v7), which is useful beyond the annotation's binary safety signal. It also notes the guarantee of correctly formatted output.

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 three concise sentences, front-loading the core purpose and then adding practical usage details. No wasted words; every sentence contributes to understanding the tool's function and selection criteria.

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, an output schema that documents return values, and clear annotations, the description fully covers the essential context: what it does, why it's needed, and how to choose the version. It is complete without being verbose.

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 covers both parameters with clear descriptions and default values, so the description does not need to restate them. The description adds semantic context for the version parameter by explaining when to choose v7, but this is mostly redundant with the schema's enum description. Baseline of 3 is appropriate given full schema 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 clearly states the tool generates UUIDs, a specific and distinct function among the sibling utility tools. It also elaborates on UUID versions (v4 and v7), adding meaningful specificity beyond a simple verb+resource statement.

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 recommends v7 for database keys and stresses that LLMs cannot produce valid UUIDs, so this tool should always be used. This provides clear when-to-use guidance and effectively excludes manual generation as an alternative.

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