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

Annotations already indicate readOnlyHint=true, destructiveHint=false, idempotentHint=true. Description adds concrete behavioral details: runs locally, no external service, rate-limited (60 req/min for anonymous). 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?

Four sentences packed with essential information, no fluff. Front-loaded with core functionality, then usage distinction, then constraints and return 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 output schema exists, the description summarizes return values appropriately (converted output, decimal, steps, metadata, common bases). Covers all necessary aspects for a 3-param tool.

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

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

Schema coverage is 100% with good parameter descriptions. Description adds extra context about case-insensitivity and digit validity (e.g., base 2 allows only 0-1), surpassing the schema's 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 clearly states it converts numbers between bases 2-36 with step-by-step working, and explicitly distinguishes itself from the sibling tool conversion_number_base for character-string encodings.

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 tells when to use this tool vs conversion_number_base: for numeric base math on a single number token, not for character-string encoding conversions. Provides clear context.

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

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

Discloses 'Runs locally on the value you provide: read-only, non-destructive, offline, and rate-limited (60 requests/min anonymous).' Describes return structure. No contradiction 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?

Description is a single paragraph but well-organized; each sentence provides essential information. Slightly verbose but not excessive; could be more structured with sections.

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?

Covers conversion direction, BCD explanation, supported variants, limits, rate limits, return outputs, and sibling differentiation. Output schema exists. No 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 has 100% coverage describing all 4 parameters. Description adds context about BCD encoding and constraints beyond schema, e.g., 'maximum 16 digits' and explanation of outputFormat options.

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 'BCD Converter (Binary-Coded Decimal). Convert a decimal number to 8421 Binary-Coded Decimal (BCD), or decode BCD nibbles back to a decimal number.' with an example. It also distinguishes from sibling tools like conversion_binary_decimal and conversion_gray_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?

Explicitly says 'Use conversion_binary_decimal for whole-number pure base-2/decimal conversion, conversion_gray_code for reflected binary, or conversion_parity_bit for error-detection bits.' Also notes maximum length constraints and input format requirements.

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 annotations (readOnlyHint=true, destructiveHint=false, idempotentHint=true), the description adds important behavior: runs locally, offline, no auth, default rate limit. Also describes return value structure.

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 well-structured and concise, front-loading purpose and usage, then behavior. Every sentence adds value 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?

Despite the tool's complexity (5 parameters, multiple modes, fractional support, signed/unsigned, bit width), the description covers essential usage, behavioral traits, and return value. Paired with output schema and annotations, it's complete.

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

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

Schema coverage is 100% with good parameter descriptions. The description adds minimal per-parameter meaning beyond the schema, but includes global context. 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 tool converts a single number between binary and decimal, with specific details about direction, bit width, and fractional support. It distinguishes from siblings by naming alternative 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?

Explicitly says when to use this tool (bit-level detail for one number) and when to use alternatives (conversion_base_converter, conversion_number_base, conversion_decimal_hex). Provides clear context.

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

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

Annotations provide readOnlyHint, destructiveHint, idempotentHint, and openWorldHint. The description adds value by stating it runs locally, is read-only, non-destructive, contacts no external service, is rate-limited, and details return values (braille string, ASCII-braille, stats, reference). No contradiction 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 single paragraph with no redundant information. It front-loads the core purpose and then adds necessary details about usage, behavior, and output. Every sentence is meaningful and efficient.

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

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

Given the tool's complexity (two grades, encode/decode, output structure) and the existence of an output schema, the description fully explains what the tool does, its limitations (not certified), behavior (local, rate-limited), and return value structure. No gaps remain.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (text, operation, grade) with descriptions and examples. The description does not add additional parameter-level detail but provides context for the overall function. 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 it is a Braille Converter for Grade 1 & 2, converting between text and Unicode Braille patterns. It differentiates from sibling converters by specifying grades and use cases (preview/education aid), 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 explicitly states when to use: 'preview how labels, signage, or short copy render in braille cells' and 'read back braille into Latin text.' It also clarifies it is not for certified transcriptions (textbook/Nemeth/music), providing clear context. It does not mention alternatives among siblings but is sufficiently precise.

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?

Adds context beyond annotations: runs locally, no external service, rate limit of 60 req/min, and invalid input returns HTTP 400. No contradiction 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?

Well-structured, front-loaded with purpose. Slightly verbose but clear and provides all necessary information in a single paragraph.

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 output schema exists, description covers input format, output, behavior, alternatives, and constraints fully. No gaps for an agent to use effectively.

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 description adds parsing behavior (fallback to CSS color names), examples, and default behavior for inputFormat, enhancing understanding.

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?

Clearly states it converts a single color string between HEX, RGB, HSL, and HSV, returning all four representations. Distinguishes from siblings webdev_hex_color and webdev_color_palette with specific use cases.

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 tells when to use alternatives: webdev_hex_color for richer analysis, webdev_color_palette for harmony schemes. Also mentions it's read-only, non-destructive, and rate-limited, guiding proper usage.

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, destructiveHint=false, idempotentHint=true. The description adds that the tool runs locally, is read-only, non-destructive, offline, no auth, and has a default rate limit. It also explains the return value includes a per-step breakdown. No 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?

The description is a single paragraph that is information-dense and front-loads the main purpose. It could be slightly more structured, but it is concise and covers essential points without waste.

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

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

With 5 parameters, nested objects, and an output schema, the description adequately covers the tool's behavior and return format. It mentions the step-by-step conversion breakdown, which adds value beyond the schema. However, the description could be more structured for complex parameters.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds context about step-by-step breakdown and fixed-width handling but does not significantly enhance parameter understanding 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 explicitly states the tool converts a whole number between decimal and hexadecimal in either direction, with details on signed/unsigned, bit widths, and hex formatting. It clearly distinguishes from siblings by listing alternative tools for other 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 description provides explicit guidance on when to use this tool ('Use this when you need decimal-hex specifically with a step-by-step breakdown and fixed-width signed handling') and lists specific alternatives for other conversion 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 provide readOnlyHint, destructiveHint, and idempotentHint. The description adds value by stating it's a 'pure client-style compute over a built-in ~170-emoji database (no network, no external API); read-only and non-destructive' and mentions rate limits of 60 requests per minute for anonymous callers. This provides useful behavioral context 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?

The description is well-structured with multiple sentences, each adding value. It front-loads the main purpose and then provides usage guidelines, behavioral notes, and parameter details. Slightly verbose but no wasted words; could be a bit more concise but still effective.

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

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

Given the tool's moderate complexity and the presence of an output schema, the description covers all necessary aspects: purpose, usage, behavior (including database size and rate limits), and parameter semantics. No gaps are apparent.

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 detailed descriptions for both parameters (query and search_type). The description adds a brief summary of search types but does not significantly enhance the meaning beyond the schema. Baseline 3 is appropriate since the schema already 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's purpose: to look up emoji by glyph, name, keyword, category, or Unicode code point and return Unicode metadata plus HTML entities. It uses specific verbs like 'look up' and 'return', and distinguishes itself from sibling tools like conversion/emoji/random, encoding/unicode, and encoding/html-entities. This makes the purpose very clear.

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

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

The description explicitly tells when to use this tool: 'when you have one search term and want full Unicode/HTML detail for matching emoji'. It also provides clear alternatives: 'use conversion/emoji/random instead to sample random emoji without a query, and encoding/unicode or encoding/html-entities for escaping arbitrary text rather than looking up emoji'. This is excellent 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 annotations (readOnlyHint, destructiveHint, idempotentHint), the description adds key behavioral traits: runs locally, is offline, rate-limited (60 req/min anonymous), and returns detailed output including step-by-step XOR working. No contradiction 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?

Well-structured and front-loaded: first sentence states core purpose, then use cases, then sibling differentiation, then behavioral details. Every sentence adds value; no wasted words despite medium length.

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?

Completely covers the tool's purpose, usage guidelines, parameter meaning, behavioral traits, and output details (converted string, decimal values, explanation, XOR steps, bit properties). No gaps given the complexity and presence of 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 coverage is 100% with clear descriptions for each parameter. The description goes beyond by explaining the XOR algorithm, fixed-width padding with bitWidth, and providing example input. Adds significant meaning without redundancy.

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 converts between binary and Gray code, with clear verb ('convert') and resource ('binary number to Gray code or Gray code back to plain binary'). It distinguishes from siblings by naming conversion_binary_decimal and conversion_bcd for other 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?

Provides explicit when-to-use (Gray code conversion) and when-not-to-use ('Use conversion_binary_decimal for plain base-2/decimal conversion or conversion_bcd for binary-coded decimal'). Also notes read-only, non-destructive, offline, and rate-limited nature, guiding appropriate invocations.

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?

Describes the encoding/decoding process (inserts parity bits, computes syndrome, flips bit) and return values (codeword, syndrome, error position, etc.). Aligns with annotations (readOnlyHint=true, destructiveHint=false) and adds rate limit info. No 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?

Description is informative but slightly verbose; could be tightened. However, it is well-structured with purpose, mechanism, and usage notes in a logical order.

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?

Covers all essential aspects: purpose, parameters, behavior, return values (output schema exists), constraints, and sibling differentiation. No gaps for a tool of moderate complexity.

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

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

Schema coverage is 100%, but description adds meaningful context: explains mode options, input length constraints per mode and hammingType, and examples of valid inputs. This goes beyond 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?

Description clearly states it encodes binary data into Hamming codewords and decodes codewords to detect/correct errors. It distinguishes from sibling tools like conversion_parity_bit and conversion_gray_code by specifying alternative uses.

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

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

Explicitly says when to use this tool ('for error-correction coding demos and parity analysis') and when to use alternatives ('use conversion_parity_bit for a single parity bit, or conversion_gray_code for reflected-binary encoding'). Also notes local, read-only, offline, and rate-limited constraints.

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, destructiveHint, idempotentHint, and openWorldHint. The description adds that it runs locally, is non-destructive, contacts no external service, and has a rate limit (60 requests/minute). This extra context is valuable and consistent 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 well-organized: purpose first, then mode/precision details, then usage guidance, and finally behavioral notes. It is informative but slightly verbose; could be tightened without losing clarity.

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 complexity (4 parameters, output exists), the description covers all necessary aspects: modes, precision, input format, special-case detection, and return value (full bit breakdown). It also distinguishes from siblings, providing a complete contextual picture.

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

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

Schema coverage is 100% with detailed descriptions for all 4 parameters. The description largely restates the enums and parameters (mode, precision, inputFormat) but adds little new semantics beyond tying them to usage context. 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 tool converts between decimal and IEEE 754 binary floating-point, specifying modes (decimal-to-ieee754, ieee754-to-decimal) and precision. It also contrasts with sibling tools like conversion_base_converter and conversion_binary_decimal, making the purpose distinct and 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?

Explicitly tells when to use this tool (need exact bit layout, exponent, special cases) and when to use alternatives (conversion_base_converter for integer radix, conversion_binary_decimal for signed/unsigned integers). Also notes it runs locally and is read-only, providing clear usage context.

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

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

Beyond annotations (readOnlyHint, destructiveHint), the description adds detailed behavioral traits: encoding upper-cases input, mapping to dot/dash patterns, joining with spaces and slashes, handling unsupported characters, decoding splits on slashes and spaces, and emitting question marks for unrecognized symbols. No contradiction 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 well-structured, front-loading the purpose, then behavioral details, usage guidance, safety notes, and return value format. Every sentence adds value 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?

Given the presence of an output schema, the description still explains the return format ('converted string plus an analysis block and reference morse_info'). Covers encoding and decoding behaviors, constraints, and alternatives comprehensively.

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 baseline is 3. The description adds value by specifying that text must be non-empty and trimmed, and explains behavior for unsupported characters during encoding and decoding, which is not fully covered in the 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 clearly states it is a Morse Code Encoder and Decoder, with specific verb+resource. It distinguishes itself from sibling tools like conversion_braille and encoding_decoding_baconian by mentioning their use cases.

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?

Explicit guidance is given: 'Use this for dot-dash signalling; use conversion_braille for tactile braille cells and encoding_decoding_baconian for the A/B Baconian cipher.' It also states that it runs locally and is non-destructive.

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, destructiveHint, and idempotentHint. The description reinforces these with 'read-only, non-destructive, offline, no auth' and adds that it returns a converted string plus an analysis block. This adds context beyond the annotations without contradiction. Slight deduction because some behavioral traits (e.g., exactly what the analysis block contains) are not detailed, but the description is sufficient given annotation coverage.

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

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

The description is three sentences, front-loaded with the core purpose, followed by usage guidance and behavioral context. Every sentence earns its place with no redundancy or 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?

For a tool with 4 parameters (100% schema coverage), no nested objects, and an existing output schema, the description covers the tool's purpose, usage scope, behavioral traits, and return structure (converted string + analysis block). It is fully complete for an agent to understand how and when to use it.

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 does not add significant meaning beyond the schema; it mentions that decimal/octal values must be 0-1114111, which is already in the schema's from_format description. No additional parameter details are provided.

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 converts between five textual encodings (ASCII, binary, hex, decimal, octal) as sequences of byte/codepoint values. It distinguishes from siblings like conversion_base_converter (single integer arbitrary radix), conversion_binary_decimal (signed/unsigned with bit width), and conversion_decimal_hex (two's complement). The verb 'convert' and the specific resource (five encodings) are explicitly defined.

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 this tool ('when you need to move character data across base representations') and when not to, naming three specific alternatives. It also notes that the tool runs locally, is read-only, offline, requires no auth, and has default rate limits, helping the agent understand invocation context.

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

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

Annotations already declare readOnlyHint, destructiveHint, idempotentHint. Description adds that the tool runs locally via Node bridge, is read-only, non-destructive, contacts no external service, and is rate-limited (60 req/min). Also describes error conditions and return value (converted string + per-byte breakdown). 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?

Description is well-structured and each sentence adds unique value: purpose, use case, alternatives, local/rate-limit behavior, error handling, output summary. No unnecessary words. Front-loaded with primary function.

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 4 parameters (2 required, many enums), presence of output schema, and complexity of conversions, the description covers all necessary aspects: purpose, usage guidelines, constraints, error handling, and behavioral properties. Output schema presence reduces need to detail return 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 has 100% coverage with descriptions for all 4 parameters. Description adds meaning: explains space/newline separator, ASCII vs UTF-8 handling, and clarifies that invalid inputs cause errors. Goes beyond schema by describing usage context.

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

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

Description clearly states the tool converts between text and space/newline-separated octal byte values. It explicitly distinguishes from sibling tools by naming alternatives (conversion_number_base, encoding_decoding_hex_ascii, etc.) and specifying scenarios for use (C/assembly octal escapes, Unix dumps).

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?

Provides explicit guidance on when to use this tool (octal-specific tasks) and when to use alternatives (general radix math, hexadecimal, binary, string parsing). Lists several sibling tools with clear differentiation.

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 denote read-only and idempotent. The description adds rate-limit (60 req/min), offline execution, and details how parity computation works, enhancing transparency without contradicting 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 well-structured, starting with purpose, then modes, limitations, alternatives, and output. Every sentence adds value; no fluff.

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

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

Covers purpose, modes, limitations, alternatives, operational context (read-only, offline, rate-limited), and output details. With output schema present, the description is complete and self-contained.

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 provides additional context: constraints (e.g., input length for check mode), purpose of modes and parity types, and examples. This adds 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 computes or verifies a parity bit, and distinguishes itself from related tools like conversion_hamming_code and conversion_gray_code by noting it is for detection only, not correction.

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 tells when to use (for error detection) and when not (for correction), and suggests alternatives. It also explains the two modes (add/check) and the available parity schemes.

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, non-destructive, idempotent. The description adds valuable context: runs locally, offline, rate-limited, validates subtractive notation, rejects out-of-range/malformed input. No contradiction 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 well-structured with a clear leading sentence and subsequent details. It is slightly lengthy but every sentence adds value, with no redundancy. Could be trimmed slightly for conciseness.

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

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

Given the tool's complexity (2 params, output schema exists), the description covers all key aspects: range, validation, direction, return details (steps, breakdown, facts, alt representations). It is fully complete for accurate use.

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 parameter descriptions are clear. The description enriches them by explaining direction auto-detection, case-insensitive Roman input, trimming, and examples, adding meaning 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 converts integers to Roman numerals and vice versa within 1-3999. It specifies the exact verb 'Convert' and resource 'Roman numeral', and distinguishes from siblings by referencing conversion_number_base/conversion_base_converter for other radixes.

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 tells when to use (standard Roman conversion) and when not (binary/octal/hex, point to alternative tools). Also explains auto-detection behavior, providing clear context for 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 read-only, non-destructive, idempotent. The description adds concrete behavioral details: runs locally, offline, no auth, default rate limit. It also outlines parsing behavior and return contents, complementing annotations 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?

The description is concise (4-5 sentences) and well-structured: name, enumeration, parsing details, usage guidance, operational context, return info. Some minor redundancy but overall efficient.

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

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

Given the tool's complexity (3 params, 6 representations, parsing rules) and existing output schema, the description covers major aspects: supported types, parsing behavior, conversion constraints, and sibling distinctions. Could clarify multi-value output but schema likely covers.

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?

Despite 100% schema coverage, the description adds significant meaning: parsing rules per from_type (character-by-character vs token splitting), output format specifics (3 decimals for float, exponential for scientific, range limits for roman and words). This goes beyond enum labels.

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 as a 'String / Number Format Converter' that converts between six representations. It enumerates the types and differentiates from siblings by naming conversion_roman_numerals and conversion_number_base as alternatives.

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

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

Explicitly advises using this tool for mapping characters to/from code points or reformatting number lists, and directs users to specialized tools for Roman numerals and number base conversion. This provides clear when-to and when-not-to 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 indicate readOnlyHint=true and destructiveHint=false. The description adds behavioral details: runs locally, read-only, non-destructive, rate-limited (60 req/min for anonymous), and auto-detects formats. No 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?

The description is front-loaded and well-organized, but appears truncated at the end ('...varies between cal'). This indicates the provided text is incomplete, reducing conciseness and structure. Otherwise, it would be a 5.

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 truncation, the description covers input format auto-detection, output fields, constraints, behavioral traits, and alternative tools. Given the existence of an output schema, this is comprehensive.

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 baseline is 3. The description adds useful context: the 'input' parameter also accepts alias keys ('timestamp' or 'text'), must not be blank, and the 'now' parameter is optional for relative phrases. This exceeds 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 clearly states 'Unix Timestamp Converter' and explains it converts between Unix epoch timestamps and human-readable dates. It auto-detects input formats and distinguishes itself from sibling tools like time_iso_8601_formatter and time_date_difference.

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 tells when to use this tool vs alternatives by naming specific sibling tools and explaining differences. Also notes constraints: requires non-empty input and does not fall back to current time.

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?

Adds important behavioral context beyond annotations: fresh random salt per call (non-idempotent), server-side execution, read-only nature, no external service contact, rate limits (5/min, 30/hr, 100/day). Annotations already declare readOnlyHint=true and idempotentHint=false, but description enriches with specifics.

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?

Description is well-structured with title, purpose, usage guidance, comparisons, and behavioral notes. It packs substantial information but remains readable; minor trimming could improve conciseness.

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

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

Given the tool's complexity (5 params, output schema, annotations), the description fully covers purpose, usage, behavior, rate limits, and alternatives. 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 coverage is 100% with detailed descriptions, examples, enums, and defaults for all 5 parameters. Description adds minimal extra meaning beyond schema (e.g., 'required and non-empty' for password). 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?

Description clearly states 'Generate Argon2 Password Hash' and explains the exact function: hash a plaintext password with Argon2 KDF, returning PHC-encoded hash plus parsed parameters. It distinguishes from sibling crypto_argon2_verify and other crypto tools like crypto_bcrypt.

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 tells when to use this tool (create new hash) vs. crypto_argon2_verify (check password). Recommends Argon2 over bcrypt, scrypt, pbkdf2, providing clear alternative 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, destructiveHint, idempotentHint. Description adds critical context: runs server-side, rate limits (5/min, 30/hr, 100/day), CAPTCHA trigger, and return type (match status + parsed parameters). 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?

Three concise sentences: purpose, usage vs alternative, and behavioral details (rate limits, output). Front-loaded with key info; every sentence 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?

Given the tool's simplicity (2 required params, output schema exists), the description covers purpose, usage, behavior, rate limits, and output. Annotations and schema are rich, so no gaps remain.

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?

Input schema covers both parameters fully (100% coverage with descriptions and examples). Description adds that hash includes cost parameters, but this is already in the schema's description of 'hash'. No additional meaningful semantics beyond 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's purpose ('verify a plaintext password against an Argon2 hash') and distinguishes it from the sibling 'crypto_argon2' (generate new hash). The verb 'verify' and resource 'Argon2 hash' are specific.

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

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

Explicitly says when to use ('to verify a candidate password') and when not ('use crypto_argon2 instead to generate a new hash'). Also notes behavior: read-only, non-destructive, no external service, and rate limits.

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 annotations, the description specifies local execution, read-only and non-destructive nature, no external service contact, rate limiting, and non-idempotent behavior due to fresh salt per call. No contradiction 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?

Every sentence provides distinct value: purpose, usage, behavior, return details. Front-loaded and no redundant or vague phrasing.

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

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

Covers all necessary aspects: purpose, when to use, behavior, parameters with recommendations, and output summary (hash string, cost, salt, etc.). With output schema present, return values are adequately described.

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?

Input schema has 100% coverage with descriptions and examples, but the description adds context like recommended cost (12), valid range, and the effect of salt. This adds marginal value beyond 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 hashes a plaintext password with bcrypt for creating new stored password hashes, and differentiates it from sibling tools like crypto_bcrypt_verify and other KDFs.

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 provides when to use (create new hash) and when to use alternatives (crypto_bcrypt_verify for verification, other KDFs for different algorithms). Also mentions rate limiting for anonymous callers.

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?

Goes beyond annotations by specifying that it runs locally with PHP password_verify, is read-only, non-destructive, contacts no external service, and has rate limits. This aligns with annotations (readOnlyHint, destructiveHint, idempotentHint) and adds valuable behavioral 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 concise with two main parts: upfront purpose and usage guidance, then behavioral details. Every sentence adds value 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 two-parameter tool with output schema, the description covers purpose, usage, behavior, parameter semantics, and return details (matching, parsed fields, strength analysis). It is fully adequate for the 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?

Schema coverage is 100% with descriptions and examples for both parameters. The description adds useful context that the cost and salt are read from the hash string, eliminating the need for separate parameters, which enhances understanding 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's purpose: 'Bcrypt Password Verifier' and explains that it checks whether a plaintext password matches an existing bcrypt hash. It distinguishes itself from sibling tool crypto_bcrypt by noting that the sibling should be used for generating new hashes.

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 states when to use this tool ('verify a candidate password against a stored hash') and provides an alternative ('use crypto_bcrypt instead to generate a new hash'). Also mentions rate limits and local execution for context.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds useful context: runs locally, deterministic, rate-limited (5 req/min for anonymous), contact no external service, and details output 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 long but well-structured, front-loading purpose and usage, then behavioral details, then output. Every sentence adds information, though slightly verbose for a concise tool.

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

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

Output schema exists, and the description details the return fields (digest formats, variant, algorithm, encoding, byte length, bit count, keyed flag). No gaps for this hash 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?

Despite 100% schema coverage, the description adds significant value: explains variant optimization (64-bit vs 8-32-bit), encoding interpretation, keyed mode behavior, and return metadata (lowercase/uppercase hex, flags).

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 computes BLAKE2b or BLAKE2s digests of a text string, with explicit variant options and keyed mode. It distinguishes from siblings like crypto_blake3, crypto_hash, 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?

Explicitly provides when to use (e.g., 'when you want an RFC 7693 digest faster than SHA-2 at SHA-3-level security') and directs to alternatives for other needs (crypto_blake3 for XOF, crypto_hash for MD5/SHA, etc.).

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 annotations (readOnlyHint, etc.), the description adds key behaviors: 'Runs locally on the input you provide: read-only, non-destructive, deterministic (no random salt), contacts no external service, and is rate-limited (5 requests/min anonymous).'

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 well-structured and efficiently conveys purpose, usage guidelines, behavioral traits, and output format without redundancy. Every sentence 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?

Given the tool's complexity (7 parameters, 3 modes), the description covers purpose, usage, behavior, parameters, and output format. Return values are explicitly described as 'digest as lowercase hex, uppercase hex, and base64, plus resolved mode, encoding, length, and bit count.'

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 description adds value with context like 'The empty string is valid' and 'BLAKE3 is an XOF' for the length parameter, but most parameter details are already in 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 'BLAKE3 Hash Generator' and explains it computes a hash with configurable modes. It explicitly distinguishes from sibling tools like crypto_hash, crypto_sha3, and crypto_keccak, specifying when to use each.

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 alternatives: 'Use crypto_hash for MD5/SHA-1/SHA-256/SHA-512, crypto_sha3 for SHA-3, or crypto_keccak for pre-standard Keccak' and states when to reach for BLAKE3 (fastest modern hash, XOF, keyed MAC, KDF).

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 (readOnlyHint, idempotentHint, etc.) are reinforced and expanded by the description: 'Runs locally on the input you provide: read-only, non-destructive, contacts no external service, and is rate-limited.' The return value structure is also disclosed. 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?

Three sentences structured with title/purpose, algorithm list, usage guidance, behavioral notes, and return value summary. Front-loaded and concise; every sentence adds distinct value 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 tool with many algorithms and output format nuances, the description covers purpose, usage, behavior, and return format. Output schema exists and the description summarizes it. A minor gap: no explicit clarification of output format behavior for non-numeric algorithms, but the schema covers it. Overall sufficient 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?

Schema coverage is 100% with detailed descriptions for each parameter (text, algorithms, outputFormat). The description adds high-level context (e.g., 'non-cryptographic' though including cryptographic hashes) but does not substantially augment schema-level parameter semantics beyond reinforcing the purpose. 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 it computes non-cryptographic checksums and hashes over UTF-8 text, listing supported algorithms (CRC, Adler, Fletcher, FNV, SHA, etc.). It distinguishes from siblings by referencing crypto_hash for cryptographic digests and crypto_hash_identifier for detection, establishing a specific verb+resource with explicit differentiation.

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

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

The description provides explicit guidance: 'Use it when you need fast verification or legacy checksums; use crypto_hash for cryptographic file/text digests, or crypto_hash_identifier to detect an unknown hash's algorithm.' It also notes the tool is read-only, non-destructive, and rate-limited, giving clear context for when to invoke versus 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?

Beyond annotations (readOnlyHint, destructiveHint, idempotentHint), the description adds local execution, determinism, no external service contact, rate-limiting, and return structure, fully disclosing 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?

Three sentences covering purpose, usage, behavior, and return value with no unnecessary words, well structured and 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?

Given the presence of an output schema, the description adequately explains inputs, outputs, and behavioral context, leaving no gaps for 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?

Schema covers all parameters with descriptions, defaults, and enums. The description adds minimal meaning beyond the schema, e.g., noting hex case, but this is already in the outputFormat parameter 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 computes hash digests of a UTF-8 string, lists supported algorithms, and distinguishes from siblings like crypto_checksum, crypto_hmac, and crypto_hash_identifier.

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 tells when to use this tool vs alternatives: 'Use crypto_hash for general text digests; use crypto_checksum for...', providing clear decision 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 provide readOnlyHint, destructiveHint, and idempotentHint. The description adds valuable context: 'Runs locally on the input you provide: read-only, non-destructive, contacts no external service, and is rate-limited.' This goes beyond annotations, though the core behavioral traits are already covered.

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 four sentences, concise and front-loaded. It starts with the core purpose, then usage guidance, then behavioral traits, then return values. Every sentence adds value 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?

Given the tool's complexity (dictionary attack, multiple options), the description covers purpose, usage, behavioral traits, and explicitly lists the return fields (match found, recovered password, detected hash type, attempts, elapsed seconds). This is complete for an agent to understand 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% with detailed descriptions for each parameter (hash, type, dictionary, useCommonPasswords). The description does not add additional semantics beyond summarizing the process (dictionary + built-in list). Baseline 3 is appropriate as the schema already documents parameters well.

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: 'Hash cracker (dictionary attack). Recover the plaintext behind a password hash by testing it against a wordlist'. It distinguishes itself from sibling tools like crypto_hash_identifier and crypto_password_strength by specifying when to use them instead, 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?

Explicit guidance is given: 'Use it to audit weak hashes; run crypto_hash_identifier first if the algorithm is unknown, and crypto_password_strength to score a password you already have.' This tells the agent when to use this tool and when to use alternatives, fulfilling the dimension perfectly.

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?

Description adds behavioral context beyond annotations: runs locally, read-only, non-destructive, idempotent, rate-limited (60 req/min), contacts no external service. 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?

Description is well-structured and front-loaded with the main purpose. It is slightly verbose but every sentence adds value. Could be slightly more concise, but overall efficient.

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

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

Given the output schema existence, the description is complete. It covers rate limits, idempotency, local operation, and return content (ranked candidates, confidence scores, etc.). No 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?

Only one parameter 'hash' with 100% schema description coverage. The schema already explains stripping prefixes and recognizing special formats. Description does not add significant new semantics beyond what schema provides.

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 identifies hash algorithms by analyzing length, character set, and structural pattern, listing many specific algorithms. It explicitly distinguishes from sibling tools like crypto_hash_cracker and crypto_hash.

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 guidance: 'Use this when you have a hash and do not know its type.' It also specifies what the tool does not do (crack, reverse, lookup) and directs to crypto_hash_cracker for plaintext recovery.

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, non-destructive, idempotent. Description adds rich behavioral context: local execution, rate-limited, in-memory processing, no persistence or logging, and key handling 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?

Single paragraph with dense information, front-loaded with main action. Could be improved with bullet points for readability, but not excessive.

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?

Covers purpose, usage, behavioral notes, supported algorithms, key/output formats, and security. Output schema exists, so return details are not 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?

Schema coverage is 100% with parameter descriptions. The description adds overall context but does not significantly enhance individual parameter meaning beyond examples and return format explanation.

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 'HMAC Generator (Keyed Hash)' and explains it computes an HMAC for authentication. It explicitly distinguishes from crypto_hash for unkeyed digests.

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?

Provides explicit guidance: 'Use this when a shared secret must be involved' and 'use crypto_hash instead for an unkeyed digest with no secret', naming the alternative sibling.

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 annotations (readOnly, idempotent, non-destructive), description adds local execution, deterministic behavior, no external service contact, rate limiting, and return of variant and notes. No 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?

Description is information-dense but well-structured with clear sentences. Slightly verbose for some readers, but each sentence adds meaningful context.

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 rich annotations and expected output schema, description covers all key aspects: input formats, variants, use-case distinction, and behavioral properties. No missing information.

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 detailed parameter descriptions. Description adds minimal extra value beyond mentioning default variant, but serves as reinforcement.

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?

Clearly defines the tool as computing Keccak digests for text/hex/base64 inputs, with specific mention of Ethereum/blockchain use. Distinguishes from crypto_sha3_generator by highlighting the 0x01 vs 0x06 padding difference.

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 instructs when to use this tool (Ethereum/blockchain-compatible Keccak) versus crypto_sha3_generator (NIST-standard SHA-3), providing clear usage context.

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

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

Annotations indicate readOnlyHint=true and destructiveHint=false. The description adds that it runs locally, contacts no database or external service, is rate-limited (30 req/min), and explains deterministic vs non-deterministic behavior (SHA1-based formats are deterministic, mysql80 uses random salt). This goes 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?

Description is a single well-structured paragraph, front-loading the main purpose and use cases. It covers key points without excessive verbosity. Could be slightly more concise but overall effective.

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 complexity (2 parameters, enum, simple behavior), the description covers purpose, parameters, usage, behavior, rate limits, and output (returns hash, version, algorithm, format, salt, iterations). No output schema provided but description adequately hints at return 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 covers both parameters (password and version) with descriptions and examples. The description adds context about version-specific formats (e.g., mysql80 uses caching_sha2_password with random salt) and behavior differences, providing useful nuance beyond 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 generates MySQL password hashes for a given plaintext across versions. It specifies the exact use case (building CREATE USER/SET PASSWORD statements or test fixtures) and distinguishes from sibling tools like crypto_postgresql_password_generator and crypto_password_generator.

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 provides when to use (for MySQL password hash generation) and when not to use (for PostgreSQL, use crypto_postgresql_password_generator; for random plaintext, use crypto_password_generator). Also notes it runs locally, is read-only, non-destructive, and rate-limited.

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 annotations (readOnly, destructive, idempotent), description adds specific behavioral details: runs locally, no external service, rate-limited, and potential failure for LM hash.

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?

Description is thorough and well-structured, but somewhat lengthy. All sentences add value, but could be slightly more terse.

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 complexity (multiple hash types, algorithms, output fields), the description covers purpose, usage, behavior, parameters, and return values comprehensively.

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?

Description adds deep meaning beyond schema: explains hashing algorithms (MD4, DES), default behavior, and output fields (length, complexity, warnings), complementing the 100% 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 generates NTLM and LM hashes for Windows security testing, and explicitly distinguishes from siblings like crypto_hash_id and crypto_hash_cracker.

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?

Description provides explicit guidance on when to use this tool vs. alternatives, including when not to use it (for hash type identification or password recovery).

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 and destructiveHint=false. The description adds valuable context: uses crypto.getRandomValues, runs locally (read-only, non-destructive), contacts no external service, is rate-limited (30/min, 200/hr, 1000/day), and returns each password with length and estimated entropy. This fully informs behavior 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 appropriately sized with a clear structure: purpose, features, usage guidelines, safety, return info. Every sentence provides value; no fluff. It front-loads the core purpose and guides agent decision-making efficiently.

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 complexity (11 parameters, many interdependent options) and the existence of an output schema, the description is comprehensive. It covers all essential aspects: what the tool does, when to use it, behavior, safety, rate limits, and return format. No gaps identified.

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 parameters are well-documented. The description adds semantic value by explaining interactions: customCharset overrides include* options, noRepeating constraint, pronounceable mode limitations. This helps agents understand parameter dependencies without repeating schema details.

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 is a random password generator that generates cryptographically random passwords from configurable character classes, and distinguishes itself from sibling tools (passphrase for word-based, pin for numeric-only). The verb 'Generate' and resource 'cryptographically random passwords' are specific and 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?

Explicitly states when to use this tool ('dense mixed-character passwords') and when to use alternatives ('crypto_password_generator_passphrase' for memorable word-based, 'crypto_password_generator_pin' for numeric-only). Also notes randomness source and local execution, providing clear context.

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

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

Annotations show readOnlyHint=true and destructiveHint=false. The description adds key transparency details: local execution, crypto.getRandomValues, rate limits (30/min, 200/hr, 1000/day), and non-destructive nature. No 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?

The description is 5 sentences, well-organized, front-loading the purpose and usage, with no redundant or unnecessary 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?

Given the tool's complexity (7 parameters, optional output schema), the description covers purpose, usage, behavioral details, and links to alternatives. The mention of return structure complements the output schema, making it complete for effective agent selection.

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 good parameter descriptions; the tool description does not add additional semantic meaning beyond what the schema already provides, though it does reference the output structure.

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 purpose as generating diceware-style passphrases, specifies the verb 'generate', and distinguishes from sibling tools (crypto_password_generator, crypto_password_generator_pin) by noting their different use cases (dense passwords, numeric codes).

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 states when to use this tool ('for human-typable word passphrases') and when to use alternatives ('use crypto_password_generator for dense mixed-character passwords or crypto_password_generator_pin for numeric-only codes'), providing clear 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?

Discloses cryptographic randomness source (crypto.getRandomValues), local/non-destructive execution, and rate limits. No contradiction with annotations (readOnlyHint: true).

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?

Mostly concise and front-loaded, though some redundancy (e.g., 'read-only, non-destructive' could be tighter). Still informative without being overly long.

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?

Comprehensive given 4 parameters and output schema present. Covers purpose, use cases, behavior, and important parameter constraints.

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 description adds clamping ranges (4-20) and noRepeating length cap, providing context beyond the raw 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 it generates numeric-only PINs and explicitly distinguishes from sibling tools crypto_password_generator and crypto_password_generator_passphrase.

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?

Provides explicit when to use (numeric-only codes like device or card PINs) and when not to (mixed-character passwords or passphrases), plus mentions rate limits and local execution.

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 safe operations. Description adds valuable context: 'local, deterministic compute', 'read-only, non-destructive, never stored, password never logged'. No contradiction 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?

Four sentences, well front-loaded with purpose and scope. Every sentence adds necessary information: purpose, returned value, alternative tool, optional params, behavioral guarantees, rate limit. No fluff.

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

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

Given the tool has 3 params and an output schema, description covers all key aspects: input handling, behavioral guarantees, rate limiting, and distinction from sibling. Output schema provides return details, so completeness is high.

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 baseline is 3. Description adds explanation of how each parameter affects scoring (e.g., 'if the password contains it (case-insensitive) the score is reduced'), going beyond 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?

Clearly states 'Password Strength Checker' with specific verb 'Score the strength of one password' and resource 'returns a 0-100 score, strength label, etc.' Differentiates from sibling crypto_password_strength_bulk for bulk use.

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 tells when to use this tool (single password) and when to use sibling (bulk). Mentions optional parameters and their effect. Also discloses rate limit (30 req/min anonymous), guiding appropriate use.

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 valuable behavioral context beyond the annotations: it states that analysis is local, deterministic, read-only, non-destructive, never stored, and passwords are never logged. It also mentions rate limiting (30 requests/min anonymous). Since annotations already cover readOnlyHint, destructiveHint, and idempotentHint, the description enriches with operational 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 highly concise with no wasted words. It front-loads the key purpose in the first sentence, then efficiently covers usage, behavioral details, and rate limits. Every sentence 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?

Given the simple parameter (one array of strings) and the presence of an output schema (implied by the detailed output description), the description fully covers what the tool does, its behavior, and when to use it. No gaps for its complexity level.

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 only parameter 'passwords' has 100% schema coverage including description and examples. The description adds that results are returned in the same order and that an empty string scores 0. This provides useful but not critical extra meaning 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 it is a bulk password strength checker that scores many passwords in one call, and explicitly distinguishes it from the sibling tool crypto_password_strength for single password analysis. The verb 'Score many passwords' and resource 'Bulk Password Strength Checker' are specific and 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 explicit guidance on when to use this tool versus the alternative: 'Use it to audit a list at once; use crypto_password_strength for a single password (it also accepts a username and context words).' This gives clear context and 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 declare readOnlyHint=true and destructiveHint=false, so the description adds value by detailing non-deterministic output when no salt is supplied, local execution, and return of derived key, encoded hash, salt, and strength analysis. 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?

The description is 4-5 sentences, well-structured, and front-loaded with the tool's main purpose. Every sentence adds essential information without redundancy or fluff, making it efficient for an AI agent to parse.

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

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

Given the tool has 5 parameters, 1 required, an output schema, and annotations, the description covers purpose, usage guidelines, behavioral traits (non-determinism, local execution, rate limit), and key return fields. It is complete for an agent to decide 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?

Schema coverage is 100%, so baseline is 3. The description adds value by explaining that if no salt is supplied, a random 16-byte salt is generated, making output non-deterministic. It also mentions the salt length range (8–128 characters) aligning with schema min/max. This enriches parameter understanding beyond 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 'PBKDF2 Hash Generator' and explains it derives a hash from a plaintext password, specifying the tool's verb and resource. It distinguishes from siblings by naming crypto_pbkdf2_verify and alternative KDFs (argon2, bcrypt, scrypt).

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

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

Explicitly says 'Use this to create a new hash; use crypto_pbkdf2_verify to check a password against one.' Provides guidance on when to prefer other KDFs and mentions rate limiting (5 requests/min anonymous), giving clear context for 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?

Adds context beyond annotations: runs locally, read-only, non-destructive, contacts no external service, rate-limited (5 req/min for anonymous callers). No contradiction 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?

Three sentences covering purpose, usage, behavior, and return values. Front-loaded with key information, 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?

Complete for a PBKDF2 verification tool: explains what it does, how it works, what it returns (match status, parsed parameters, strength analysis), and has output schema for return values.

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 have detailed descriptions and examples in the schema. The description explains the hash format and that no separate fields are needed, adding meaning beyond the schema which has 100% 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 is a 'PBKDF2 Hash Verifier' and explains that it checks if a plaintext password matches an existing PBKDF2 hash, distinguishing it from the sibling tool crypto_pbkdf2 which generates new hashes.

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 states 'Use this to verify a candidate password; use crypto_pbkdf2 instead to generate a new hash,' providing clear when-to-use and when-not-to-use with an alternative tool name.

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 show readOnlyHint=true and destructiveHint=false. The description adds critical context: runs locally, contacts no database, rate-limited (30 req/min), deterministic vs non-deterministic behavior for different algorithms, and returns hash with metadata (version, algorithm, salt, etc.).

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 paragraph with front-loaded purpose, then usage, alternatives, behavioral notes, algorithm details, and return structure. Every sentence earns its place; no fluff.

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

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

Given the description, annotations, and output schema, this is highly complete. It covers purpose, when to use/avoid, behavioral traits, algorithm details, and return value structure. No obvious gaps for a deterministic input-output tool.

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

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

Schema coverage is 100% with descriptive parameter fields. The description adds little beyond schema for password and username, but clarifies version algorithm behavior (deterministic for md5, random salt for others). This adds marginal value over 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 explicitly states it hashes passwords into PostgreSQL credential formats, lists use cases (CREATE ROLE statements, pg_hba.conf, test fixtures), and distinguishes from siblings crypto_mysql_password_generator and crypto_password_generator.

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?

Provides explicit when-to-use context and alternatives: 'use crypto_mysql_password_generator for MySQL hashes instead, and crypto_password_generator to invent a new random plaintext rather than hash one.' Also notes it runs locally.

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 annotations (readOnlyHint, idempotentHint), the description adds concrete operational details: local execution, no external service contact, rate limiting (30 req/min), and return structure. No contradiction 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?

Every sentence earns its place. The description is compact but covers purpose, alternatives, behavioral constraints, and return structure. Front-loaded with the core action.

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

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

Given full schema coverage, rich annotations, and presence of output schema, the description provides all necessary context: purpose, when to use, behavior, parameter semantics, and output details. 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?

Schema coverage is 100%, so baseline is 3. The description adds significant value by explaining UTF-8 encoding, the empty string example, algorithm variant enum details, and the return format behavior (all formats always included). This goes beyond 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 clearly states the tool computes RIPEMD message digests for a UTF-8 string and returns per-variant results. It explicitly differentiates from siblings by directing users to crypto_hash for MD5/SHA and crypto_sha3 for SHA-3/Keccak.

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 guidance on when to use this tool versus alternatives, including specific references to other tools for different hash families. It also notes the Bitcoin use case for RIPEMD-160, helping the agent decide relevance.

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?

Discloses that it runs locally, is read-only and non-destructive, contacts no external service, is rate-limited, and generates random salt for non-deterministic output. Aligns with annotations (readOnlyHint, destructiveHint).

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 well-structured paragraphs: first states purpose and usage, then details behavior and output. Every sentence adds value, 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?

Output schema exists, and description lists return fields (derived key, hash string, salt, parameters, strength analysis). With 100% param coverage and clear behavior, it's fully complete.

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

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

Schema coverage is 100%, baseline 3. Description adds context on N being a power of 2, r as standard, p for independent mixing, length as derived key bytes, and salt optional with random generation, plus explains memory-hardness.

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 generates a scrypt password hash and key derivation, explicitly contrasting with siblings like crypto_argon2, crypto_bcrypt, crypto_pbkdf2, and crypto_scrypt_verify.

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 specifies when to use scrypt ('when you want memory-hardness') and provides alternatives for different use cases (argon2/bcrypt for general storage, pbkdf2 for iteration counts, scrypt_verify for checking).

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 valuable context beyond annotations: 'Runs locally on the input you provide: read-only, non-destructive, contacts no external service, and is rate-limited.' This aligns with the annotations (readOnlyHint, destructiveHint, idempotentHint) and provides additional details about execution locality and rate limiting.

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 and well-structured: it starts with the purpose, then usage guidance, then behavioral traits, and finally the return value summary. Every sentence adds value with no superfluous 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?

Given the simple tool (2 parameters) and the existence of an output schema, the description is complete. It mentions the return information (match result, parsed parameters, strength analysis), covering all necessary aspects for an agent to use 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% with descriptions and examples for both parameters. The description further explains the hash format and how N, r, p, salt are extracted from it, adding meaningful context beyond the schema's individual parameter 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 clearly states the tool's purpose: 'Check whether a plaintext password matches an existing scrypt hash.' It specifies the verb (verify) and resource (password against hash). It also distinguishes from sibling 'crypto_scrypt' by noting the alternative use case for generating new hashes.

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?

Explicit guidance is provided: 'Use this to verify a candidate password; use crypto_scrypt instead to generate a new hash.' This clearly tells the agent when to use this tool versus the sibling tool for hash generation.

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, non-destructive, idempotent. The description adds important behavioral context: runs locally, contacts no external service, rate-limited (30 req/min for anonymous). No contradiction 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 sentences plus a usage clause, all front-loaded. Every sentence adds value without redundancy. It efficiently conveys purpose, usage, and behavioral 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 complexity (3 params, enums, output schema present), the description covers all essential aspects: purpose, supported algorithms, input formats, usage guidance, safety, rate limits, and return information (hex digest, length, security level, use cases). It is complete for effective decision-making.

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% description coverage. The description adds value by explaining the algorithm parameter (choose variant, SHA3-256 default) and inputFormat (decode before hashing). It also notes empty string hashes to the fixed empty digest, which is 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 computes SHA3 hashes (SHA3-224/256/384/512) from text, hex, or Base64 input. It distinguishes itself from crypto_keccak_generator and crypto_hash, 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 explicitly tells when to use this tool (standardized SHA3) and when to use alternatives (crypto_keccak_generator for Ethereum Keccak-256, crypto_hash for legacy hashes). This provides excellent guidance for correct tool 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 provide readOnlyHint, destructiveHint, and idempotentHint. The description adds useful context: runs locally, contacts no external service, rate-limited (60/min), and is non-idempotent. 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 appropriately sized and front-loaded with the core purpose. It covers key details without excessive verbosity. Slight redundancy in mentioning formatting twice, but generally 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?

Given the presence of an output schema (implied by description mentioning return arrays), the description covers runtime behavior, rate limits, idempotency, and local execution. It is complete for a straightforward 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?

Schema coverage is 100%, with each parameter well-described in the schema. The description adds high-level context (e.g., version 1 is time-based, version 4 random) but does not significantly enhance understanding beyond the 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 clearly states it's a UUID generator for v1 and v4 with optional formatting. It specifies the verb 'Generate' and the resource 'RFC 4122 UUIDs'. This distinguishes it from the sibling tool 'data_uuid_validator' which validates/decodes UUIDs.

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 this tool ('mint fresh identifiers for databases, API keys, or test fixtures') and when not to ('use data_uuid_validator instead to validate or decode an existing UUID'). It also mentions the tool runs locally, is read-only, non-destructive, and rate-limited.

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