Hopi

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

Annotations already declare the operation as read-only, idempotent, and non-destructive. The description adds valuable behavioral context beyond those annotations, including the Monday-to-Friday definition, the 2026-2027 bank holiday data limitation, and the fallback to weekends-only outside those years.

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 compact and front-loaded with the core operation, followed by format, scope, and source information. Every sentence contributes useful information with no filler or restatement of schema fields.

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

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

Given full schema descriptions, helpful annotations, an output schema, and the description's caveat about bank holiday coverage, the tool is fully documented for correct invocation. Nothing critical is missing.

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

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

The input schema already describes all parameters with 100% coverage, giving a baseline of 3. The description adds meaningful context by explaining the bank holiday limitation and how the tool behaves outside 2026-2027, which directly clarifies the bankHolidays parameter's real-world effect.

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 names a specific operation: add or subtract a number of working days from a start date, optionally skipping bank holidays. It also states the date format and the holiday coverage period, making the tool's purpose unambiguous and distinguishable from related date calculators.

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

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

The description clearly states the tool's context: modifying a start date by working days, optionally with England and Wales bank holidays. It does not explicitly name alternatives or exclusions, but the purpose is precise enough for an agent to select it among the many sibling date tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is clear. The description adds behavioral context: it specifies the date format (YYYY-MM-DD), the optional 'as of' date defaulting to today, and the exact return values (years, months, days, total days, next birthday). This goes beyond the annotations and helps the agent understand what the tool computes and returns.

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

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

The description is two sentences with no fluff. It front-loads the core purpose, then provides format and output details, and ends with a source citation. Every sentence earns its place, and the structure is easy to scan.

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

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

The tool is simple (2 params, 1 required, no nested objects) and has an output schema, so the description doesn't need to explain return structure. It covers the input format, the optional date, and the computed outputs. It could mention edge cases (e.g., leap years, future dates) but these are minor for a calculator tool with an output schema. Overall, it's complete enough for an agent to call it correctly.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (dob and asOf) with formats and defaults. The description reinforces the date format and the optional 'as of' date, but doesn't add significant new meaning beyond the schema. Baseline 3 is appropriate because the schema does the heavy lifting.

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

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

The description clearly states the tool's function: 'Work out an exact age from a date of birth, as of today or an optional 'as of' date.' It specifies the resource (date of birth) and the output (age in years, months, days, total days lived, next birthday). This distinguishes it from sibling date-related tools like hopi_date_calculator or hopi_days_between_dates by focusing on age calculation from a DOB.

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

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

The description implies when to use it: when you need an exact age from a date of birth, optionally at a specific date. It doesn't explicitly exclude alternatives like hopi_date_calculator or hopi_days_between_dates, but the specific mention of 'age from a date of birth' and the output details provide clear context. It lacks explicit 'use this instead of X' guidance, but the context is sufficient for an agent to select it correctly.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds behavioral context by specifying the calculation formula and the NHS guideline comparison, which goes beyond the schema and annotations, though it doesn't discuss edge cases or return format (which output schema covers).

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 tightly packed sentences that state the core purpose, formula, optional parameter, and guideline in a front-loaded manner. The source URL is the only extra element, but it's a single token and doesn't detract. 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?

For a simple calculator with an output schema and complete parameter documentation, the description appropriately covers the calculation methodached, optional weekly comparison, and the relevant guideline. An agent has everything needed to decide to call it and understand what it does.

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

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

Schema description coverage is 100%, so all three parameters are already well-documented in the schema. The description repeats the meaning of abv and ml in prose and mentions drinksPerWeek, but it does not add new semantic information beyond the schema. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Work out') with a precise resource ('UK alcohol units in a drink') and includes the exact formula, making the tool's function unmistakable. It also mentions the optional weekly total, adding further specificity. No ambiguity.

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

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

The description gives clear context for when to use the tool: calculating UK alcohol units from ABV and volume, with an optional weekly comparison. However, it does not explicitly mention when not to use it or name alternative tools (e.g., hopi_event_wine_calculator), so it stops short of an explicit when-not/alternative statement.

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

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

Annotations already provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description adds valuable extra behavior: blank lines are dropped, natural en-GB ordering is used, and numbers within lines sort sensibly. It also covers ascending/descending and case-insensitive modes. 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 four short sentences with the main action front-loaded. It avoids filler and includes only relevant behaviors, though the source URL contributes little to tool selection or invocation.

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 full input schema, rich annotations, and the presence of an output schema, the description covers the essential invocation details: line-based input, dropped blank lines, sort direction, case handling, and locale-aware ordering. Minor omissions like duplicate-line behavior are not critical for correct 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 coverage is 100%, and the schema already documents text, direction, and caseInsensitive with clear descriptions and defaults. The description mostly restates direction and case-insensitivity rather than adding new parameter-level meaning. The natural-ordering note is useful context but is more behavioral than parameter-specific.

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

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

The description opens with a specific verb and resource: 'Sort the lines of a block of text into alphabetical order.' It clearly distinguishes this tool from text-manipulation siblings like hopi_reverse_text, hopi_remove_duplicate_lines, and hopi_case_converter by naming the sorting behavior precisely.

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

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

The description implies the use case — alphabetically sorting lines of text — but it never explicitly names alternatives or says when not to use this tool. There is a clear context for usage, but no routing or exclusions relative to sibling tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no behavioral context beyond the unit list—no mention of precision, rounding, error handling, or any edge cases. Since annotations carry the safety information and the description adds nothing extra, a score of 2 is appropriate.

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

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

The description is two concise sentences with no fluff. The purpose is front-loaded, the units are listed compactly, and the source URL is a useful addition. Every sentence earns its place; there is no redundancy or unnecessary detail.

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

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

For a simple, well-annotated tool with a complete input schema and an output schema present, the description covers the essential information: what it does, the units involved, and the source. It doesn't explain the return format, but that's already handled by the output schema. The only minor gap is the lack of any note on precision or edge cases, but for a basic converter this is not a significant omission.

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

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

The schema covers all three parameters with descriptions, so the baseline is 3. The description adds meaningful semantic context by explaining the unit abbreviations: deg (degrees), rad (radians), grad (gradians), turn (full turns). This clarifies the enum values beyond what the schema provides, making the parameters more self-explanatory.

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

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

The description clearly states the verb and resource: 'Convert an angle from one unit to another.' It lists the supported units (deg, rad, grad, turn), which makes the tool's scope unambiguous. It naturally distinguishes itself from sibling converters (e.g., length, area) by being angle-specific, so no confusion arises.

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

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

The description implies usage for any angle conversion but does not explicitly mention when not to use it or point to alternative tools (e.g., length_converter). Given the tool's narrow scope, the usage is self-evident, but there is no explicit guidance or exclusion, so it falls short of a 4.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds only the supported units and a source URL, not additional behavioral traits such as rounding or conversion precision. This is acceptable but not notably enriching.

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 compact and front-loaded with the action and resource. The unit list is directly relevant and expands abbreviated enum values, and the source URL is a single unobtrusive addition. No filler or repeated schema details beyond useful clarification.

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

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

For a simple, deterministic conversion tool, the description plus the complete input schema, output schema, and read-only annotations cover everything an agent needs. The supported units are documented both in the description and the schema, and the output schema eliminates any need to describe 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?

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds value by expanding the abbreviations (e.g., sqm is square metres, sqyd is square yards), which helps an agent understand the enum values beyond the bare abbreviations 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 states a specific verb ('convert') and resource ('an area'), then lists the supported units. This clearly distinguishes it from sibling converters such as length_converter, volume_converter, and weight_converter.

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 phrase 'Convert an area from one unit to another' provides clear context for when to use this tool, and the unit list reinforces its scope. It does not explicitly name alternatives or state when not to use it, but the area focus makes the intended use obvious.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, covering safety. The description adds behavior beyond that by explaining the two modes and their outputs (simplified ratio, decimal ratio, nearest common ratio, missing side). It does not contradict annotations and provides useful contextual detail.

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

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

The description is two concise sentences that front-load the core purpose and immediately explain both modes. It includes a source link without unnecessary fluff. Every sentence earns its place.

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

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

With an output schema present and annotations covering safety, the description is complete for an agent to select and invoke the tool correctly. It explains both modes, the inputs needed, and the outputs expected. No critical information is missing.

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

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

Schema description coverage is 100%, but the description adds meaning by tying parameters to modes (e.g., width/height for simplify, ratio plus one known side for solve). It clarifies a subtle requirement not fully captured in the schema's conditional required arrays, so it 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 it is an 'Aspect ratio helper' and explains the two modes ('simplify' and 'solve') with specific functions. It distinguishes itself by name and function, but does not explicitly contrast with sibling tools like hopi_ratio_calculator, so a slight dock for lack of 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?

There is no guidance on when to use this tool versus alternative siblings (e.g., hopi_ratio_calculator) or when not to use it. The description explains the modes but does not mention any exclusions or prerequisites, leaving the agent to infer from the name alone.

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

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

Annotations already declare the tool safe, read-only, and idempotent. The description adds meaningful behavioral detail beyond annotations, particularly the parsing rule that commas act as separators, so users should type 1200 instead of 1,200. It also cites the source, providing provenance.

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

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

Two concise sentences front-load the tool's purpose, then immediately provide input formatting guidance and source attribution. Every sentence earns its place with no redundancy or filler.

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

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

For a simple single-parameter calculator with an output schema and comprehensive safety annotations, the description covers all necessary aspects: what it computes, how to format input, and a key parsing caveat. Nothing essential is missing.

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

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

Schema coverage is 100%, so the schema already documents the numbers parameter. The description adds value beyond the schema by emphasizing the comma-separator pitfall and reinforcing accepted delimiters, which helps agents format input correctly.

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

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

The description uses a specific verb 'Work out' and clearly enumerates the outputs (mean, median, mode, sum, count, minimum, maximum) for a 'list of numbers'. This clearly distinguishes it from the many sibling calculators by specifying exactly which statistical measures are returned.

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

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

The description provides clear context on how to use the tool, listing accepted separators and warning about comma-treated-as-separator behavior. It does not explicitly mention when not to use it or name alternatives, but the input guidance is sufficiently explicit for a single-parameter calculator.

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

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

Beyond the readOnly and idempotent annotations, it discloses the exact encoding algorithm (UTF-8 bytes into 5-bit groups, A-Z then 2-7, padding to multiples of 8 with equals signs) and decoding edge cases (lowercase tolerance, missing padding, invalid characters as errors). This is rich behavioral context an agent needs to predict results.

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 dense sentences plus a source link, with the core purpose first, then encoding details, then decoding tolerances. No wasted words; every sentence adds technical precision.

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

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

The description fully covers the tool's operation for both modes, including format rules and error behavior. An output schema exists, so return values need no explanation, and the safety profile is already covered by annotations.

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% since both mode and text have descriptions, so the baseline is 3. The description adds extra meaning by clarifying that input is UTF-8 text and decode tolerates imperfect Base32 input, which helps the agent understand what values to pass for the text parameter.

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

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

The description opens with 'Encode text to RFC 4648 Base32 or decode Base32 back to text,' giving a specific verb, resource, and direction. It clearly distinguishes this from the sibling hopi_base64 tool by naming the exact standard and alphabet.

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 clear functional context: use this tool for RFC 4648 Base32 encoding/decoding of text. It does not explicitly mention hopi_base64 as an alternative or state when not to use it, so it stops short of full routing guidance.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=trueher. The description adds valuable behavioral context: 'UTF-8 safe, so accents and emoji survive the round trip' and 'Returns the converted text or a clear error.' This goes beyond the annotations and gives the agent insight into output behavior and encoding handling.

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: two sentences cover the core functionebb, UTF-8 safety, and return behavior, with the source URL appended. Every sentence earns its place, and the main action is front-loaded. Slightly more detail than strictly needed, but 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's simplicity (2 required params, no nested objects, output schema present), the description covers the essential aspects: what it does, UTF-8 handling, and error behavior. The output schema handles return values, so no need to elaborate. Minor gaps like edge-case handling or size limits are absent but not critical for a conversion utility.

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

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

Schema description coverage is 100%, and both parameters (mode with enum, and text) are clearly described in the input schema. The description does not add any parameter-level semantics beyond what the schema provides; the UTF-8 note is about overall behavior, not parameter meaning.

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

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

The description clearly states 'Encode text to Base64, or decode a Base64 string back to text' – a specific verb and resource. It doesn't explicitly distinguish from sibling tools like base32 or URL encoders, but the tool name and title already disambiguate the purpose, so confusion is unlikely.

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

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

Usage is implied: if an agent needs to Base64-encode or decode, this is the tool. However, there is no explicit guidance about when not to use it or alternatives (e.g., 'use hopi_base32_encoder for Base32'). The absence of exclusions is acceptable for a simple utility, but the guidance is not explicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context beyond the schema by explaining that tip and service charge are 'both percentages applied to each person's own share', clarifying that percentages are not applied to the whole bill. It also notes that amounts are in GBP, which is a meaningful addition.

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 compact and front-loaded, starting with the core purpose, then covering both modes, then the currency, and finally the source. No sentence is wasted, and the structure makes it easy to scan for the key decision between itemised and even modes.

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 a conditional schema, 100% parameter coverage, an output schema, and full annotation coverage, the description covers the remaining essential context: mode selection, optional percentages applied per person, currency, and source. An agent has everything needed to invoke the tool correctly without further inference.

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, but the description adds meaning beyond the field names by explaining mode-specific behavior: itemised mode maps to items with sharing, even mode maps to a total and people count, and tip/service are applied per person. The schema's field descriptions are mechanical, while the description ties them together into a workflow.

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

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

The description opens with a specific verb and resource: 'Split a restaurant bill between people.' It then clearly distinguishes the two operating modes, 'itemised' and 'even', and the currency, which separates it from vague calculator siblings. An agent can tell exactly what this tool does and roughly how it differs from other calculator tools.

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

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

The description gives clear contextual usage for each mode: use 'itemised' for per-item attribution with optional tip and service charge, and use 'even' for splitting a single total equally. It does not explicitly name alternatives like hopi_tip_calculator or state when not to use this tool, but the mode guidance is enough for correct selection in most cases.

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, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context beyond those hints: it specifies the card layout, that blank squares are null, and the exact decade ranges per column. This is useful for parsing the output and does not contradict any annotation.

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

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

Three sentences with no waste: the main action is front-loaded, the structural details are relevant and help define output, and the source URL adds provenance. The source line is optional but not distracting, making this efficiently concise rather than over-specified.

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

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

The tool is simple with a single parameter and an output schema already present. The description thoroughly explains the card format (grid dimensions, number counts, column ranges, null handling), which is the main contextual information an agent needs. No critical gaps.

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

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

Schema description coverage is 100% for the count parameter, so the schema already fully documents its range and default. The description only restates 'one or more' and explains card structure, adding no extra meaning to the count parameter beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Generate'), a specific resource ('UK 90-ball bingo cards'), and provides a detailed structural definition (3-row x 9-column grid, 15 numbers, 5 per row, column decades). This clearly distinguishes it from sibling generators like lottery_number_generator or random_number_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?

The description implies usage for bingo-card generation but gives no explicit when-to-use or when-not-to-use guidance, nor does it name alternative sibling tools. The UK 90-ball qualifier is useful context, but the agent is left to infer when this tool should be chosen over other random generators.

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

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

Annotations already mark the tool as read-only, idempotent, and non-destructive. The description adds useful behavioral context beyond that: it validates checksum/structure, supports multiple address standards and networks, and explicitly avoids blockchain queries or balance checks. No annotation contradiction exists.

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

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

Three tight sentences: core purpose first, then supported formats/networks, then limitations and source. Every sentence contributes useful information 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 single-parameter, read-only tool with a documented output schema and clear annotations, the description is fully sufficient. It covers validation method, accepted formats, network scope, and exclusions, so an agent can 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?

The schema covers the single 'address' parameter at 100%, so baseline is 3. The description adds meaning by specifying which address formats and networks are accepted, helping the agent understand valid input beyond the schema's generic 'The Bitcoin address to validate'.

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

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

The description uses a specific verb and resource: 'Check whether a Bitcoin address is valid by verifying its checksum and structure.' It distinguishes itself from sibling validators by being explicitly Bitcoin-focused and enumerating supported address formats and networks.

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

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

The description makes the tool's use case clear: validate a Bitcoin address. It also clarifies what it does not do ('Does not query the blockchain or check balances'), which prevents misuse. However, it does not explicitly name alternative sibling tools for non-Bitcoin address validation.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds meaningful behavioral detail by exposing the exact formula and the NHS weight category output, making the computation transparent. 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 compact and front-loaded, stating the purpose first, then unit usage, then the formula, and finally the source. Every sentence contributes useful information without redundancy.

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

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

For a simple calculator with a complete input schema and an output schema available, the description covers the core calculation, the supported unit systems, the expected output category, and a source reference. Nothing essential is missing for correct 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 coverage is 100%, so the baseline is 3, but the description adds real value by explicitly pairing units with their corresponding parameters and providing the formula that ties them together. This goes beyond the schema's per-parameter 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 states a specific verb and resource: 'Work out body mass index (BMI) from height and weight' and adds the distinctive 'NHS weight category' output. It is clearly distinguishable from related sibling calculators like hopi_body_fat_calculator or hopi_tdee_calculator.

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

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

The description clearly implies when to use the tool: whenever a BMI calculation is needed based on height and weight. It provides concrete context about the two unit systems and how to select them, though it does not explicitly mention alternatives or 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, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds behavioral context by explaining the method (US Navy tape), the conditional requirement of hip for females, and the optional weight that yields fat and lean mass. It does not describe the return format, but the output schema presumably covers that. 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 concise and front-loaded. It opens with the main purpose, then gives practical usage details, and ends with a source link. Every sentence contributes value; there is no redundancy or fluff. It is appropriately sized for a tool with 7 parameters.

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 a full output schema, the description does not need to explain return values. It covers the essential inputs, sex-specific requirements, unit options, and optional weight for additional outputs. The source link adds credibility and context. The description is complete for an agent to invoke the tool correctly without further research.

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

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

The schema provides 100% coverage with descriptions for every parameter, including units and the conditional requirement for hip. The description largely reiterates this information (e.g., 'for females give height, neck, waist and hip' and 'units metric or imperial'). It adds the US Navy method context, but that is not parameter-specific. The description adds little beyond what the schema already communicates.

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

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

The description clearly states the tool's function: estimating body fat percentage using the US Navy tape method. It is specific and unambiguous, and it stands apart from the many other calculators in the sibling list. The verb 'estimate' plus the resource 'body fat percentage' makes the purpose immediately 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 provides explicit usage instructions: it specifies which measurements are needed for males vs females, which units to use, and the optional weight parameter for additional outputs. It does not explicitly mention alternatives or when not to use it, but given its specialized nature, the guidance is sufficient. The sex-specific requirements are clearly stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral detail beyond that: only A-Z letters are changed, everything else is left as-is, and decoding applies the opposite shift. This informs the agent exactly what transformations occur, with no contradiction to 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 four sentences, front-loaded with the core purpose, and every sentence adds value: algorithm, alphabet handling, decode behavior, and a source reference. There is no fluff or redundant repetition of schema fields. It is appropriately concise for a simple utility.

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 straightforward transformation tool with a rich schema and annotations, the description covers all essential aspects: what it does, how it handles non-letters, how decoding works, and the ROT13 special case. The output schema exists (though not shown), so return format need not be described. Nothing critical is missing for correct 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 coverage is 100%, so all three parameters already have descriptions. The description adds extra meaning for 'shift' by stating 'a shift of 13 is ROT13' and clarifying that each letter moves along the alphabet. This provides context beyond the schema's terse 'How many places to shift each letter', enhancing the agent's understanding of valid values.

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

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

The description states a specific verb ('Encode or decode') and resource ('text') with a clear algorithm ('Caesar shift cipher'), and it names the ROT13 special case, distinguishing it from sibling ciphers like Vigenère. This is unambiguous and easily separable from other tools.

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

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

The description gives clear context for when to use the tool: when a Caesar shift or ROT13 is needed, and explains the behavior (shift letters, leave others). It does not explicitly name alternatives or exclusions, but the tool name and description make the intended use obvious, so it meets the 'clear context, no exclusions' bar.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is known. The description adds the output details (annual rate, total growth, growth multiple), which is useful context beyond the annotations. It does not contradict any annotation.

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

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

Two sentences, front-loaded with the core purpose and returns. The source link is extra but not harmful. No fluff or redundancy.

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

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

The tool is simple (3 parameters, no nested objects, output schema present). The description covers what it does and what it returns, and annotations cover safety. Nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 100%, so all parameters are already documented. The description loosely maps to the parameters ('starting value', 'ending value', 'number of years') but adds no extra meaning or edge-case guidance beyond what the schema provides. Baseline 3 applies.

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

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

The description states a specific verb ('Work out') and a precise resource ('compound annual growth rate (CAGR)'), along with the inputs and outputs. Although it does not explicitly differentiate from siblings, the purpose is unambiguous and the name reinforces it.

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

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

Usage is implied: an agent would use this when a CAGR calculation is needed. However, there is no explicit guidance on when not to use it or mention of alternatives (e.g., compound interest calculator). No exclusions are stated, so it stops at implied 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 already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds meaningful behavioral details beyond annotations: the exact conversion factor and the fact that both converted values are returned. The source URL also adds provenance. This goes beyond what annotations alone convey.

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

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

Three short sentences with no filler: purpose and factor first, then usage and return behavior, then source. Every clause earns its place and the most decision-relevant information is front-loaded.

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

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

For a simple two-parameter converter with an output schema present and annotations covering safety, the description covers the factor, input units, return behavior, and source. Nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 100%, with both 'amount' and 'unit' already described. The description's mention of valid unit values ('kcal' or 'kj') repeats the schema enum and adds no new param-level meaning, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Convert') and a precise resource ('food energy between kilocalories (kcal) and kilojoules (kJ)'). It also states the exact conversion factor (1 kcal = 4.184 kJ), which unambiguously distinguishes this from other unit converters in the sibling list.

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

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

The description clearly tells the agent what input to provide ('Give an amount and its unit') and what to expect ('returns both values'). It does not explicitly name alternatives or exclusions, but for a standalone converter with no near-identical sibling, this context is sufficient.

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

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

Annotations already declare readOnly, idempotent, openWorld=false, and non-destructive, so the safety profile is fully covered. The description adds useful behavioral detail by defining exactly what 'title' and 'sentence' mean, which is not obvious from the schema alone.

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 short, front-loaded with the main action, and uses a compact second sentence to define modes. The trailing source URL is not useful for invocation and slightly weakens conciseness, but it does not harm 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?

For a two-parameter pure transformation with an output schema and rich annotations, the description is complete. It defines both required parameters implicitly and covers the full enum semantics; no additional guidance is needed for an agent to call it correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description goes beyond the schema by explaining each enum value with examples ('upper' is UPPERCASE, 'title' capitalises the first letter of each word), which materially helps an agent choose the correct mode.

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

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

The description opens with a specific verb and resource: 'Convert text to a different letter case.' It then enumerates the four supported modes, making the tool's scope precise and clearly separating it from text-transform siblings like reverse_text or slug_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?

The purpose is stated plainly enough that an agent can infer when to use it: whenever text needs upper, lower, title, or sentence casing. It does not explicitly name alternatives or exclusions, but for a simple utility this is clear, non-misleading 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 cover the safe, read-only, idempotent behavior. The description adds meaningful non-annotation details: the exact conversion chart ('15, 24, then 4 a year'), the approximate nature of the result, and what outputs are returned. This goes beyond the structured metadata and is consistent with it.

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 dense sentences plus a source link. The action, method, and outputs are all front-loaded, with no filler or irrelevant detail.

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 deterministic one-parameter calculator with a full input schema, annotations, and an output schema, the description is complete: it states the input unit, the calculation rule, and what the tool returns. Nothing critical for calling it correctly is missing.

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

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

Schema coverage is 100% because the sole parameter catAge has its own description with units and bounds. The description repeats 'age in years' but does not add significantly more parameter-specific meaning, 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 uses a specific verb and resource: 'Convert a cat's age in years to an approximate human age.' It clearly identifies the domain, distinguishes this from dog/human age tools, and states what the tool returns (human-equivalent age and life stage).

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

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

The description clearly identifies the intended use case: cat-age conversion. It does not explicitly name alternatives like hopi_dog_age_calculator or hopi_age_calculator, but the cat-specific wording supplies enough routing context for an agent to select it correctly.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds a meaningful behavioral detail beyond the schema: 'Also returns Kelvin,' which tells the agent the output includes this extra unit. This goes beyond what the input schema states and enriches the behavioral model 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 three short sentences with no filler. The main action is front-loaded, the direction instructions are clear, and the source URL is the only extra element, which adds credibility without bloat. Every sentence earns its place.

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

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

For a simple two-parameter converter with a full input schema and an output schema present, the description is complete. It conveys the conversion direction options, the extra Kelvin return, and a source reference. Nothing an agent needs to invoke this tool correctly is missing, and the output schema covers return details.

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 input schema fully documents both value and direction. The description reiterates the direction values ('c-to-f' and 'f-to-c') but adds no new semantic meaning beyond the schema. This matches the baseline for high schema coverage.

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

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

The description opens with a specific verb-resource pair ('Convert a temperature between Celsius and Fahrenheit') and immediately clarifies the two supported directions. The added detail that it also returns Kelvin and the explicit direction values distinguish it from generic temperature converters and any sibling such as the oven temperature converter.

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 clear parameter-level instructions ('Set direction to 'c-to-f' or 'f-to-c') but does not explicitly discuss when to use this tool versus alternatives or when not to use it. Among the many sibling converters, there is no named alternative or exclusion, so usage guidance is implied rather than explicit.

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

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

Annotations already declare readOnlyHint, idempotentHint, and no destructive behavior. The description adds meaningful behavioral detail by specifying exactly which derived metrics will be returned (spaces removed, word count, SMS count, Twitter/X remaining) and the source URL. This goes beyond the annotations without contradicting them.

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

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

One efficient sentence front-loads the primary action and then lists the key outputs without waste. The source URL is useful provenance and takes minimal space. Every element earns its place.

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

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

The tool has one simple parameter, a rich output schema, and annotations covering safety and idempotence. The description's enumeration of outputs plus the source link makes it complete for an agent to decide and call correctly; no critical usage detail is missing.

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

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

Schema description coverage is 100%, with the single parameter 'text' already described as 'The text to measure.' The tool description does not add any additional parameter-level meaning beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Count') tied to a clear resource ('a block of text') and enumerates the exact outputs: character count, count without spaces, word count, SMS message count, and Twitter/X remaining out of 280. This fully differentiates it from sibling tools like hopi_word_counter and hopi_word_frequency_counter.

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

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

No explicit when-to-use or when-not-to-use statements are given, but the detailed output list makes the tool's purpose unmistakable against similar text-measurement siblings. The context is clear enough for an agent to select it for character-centric counting, though alternatives are not named.

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

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

Beyond the read-only and idempotent annotations, the description reveals important behavior: it returns ranked candidates with confidence scores, provides a decoded preview, and auto-decodes nested layers up to 8 deep while a step is at least 60% confident. It also discloses its limitation with keyed encryption, giving the agent accurate expectations.

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

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

The description is front-loaded with the core purpose, then states output behavior, auto-decoding rules, limitations, and source. The list of supported encodings is long but useful, and the entire description remains dense without fluff or repetition.

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

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

Given the tool's moderate complexity, the description covers the input, recognized categories, output behavior, confidence threshold, nesting limit, and cryptographic limitation. The presence of an output schema means return-value details do not need to be spelled out, so nothing essential is missing.

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

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

There is only one parameter and the schema already describes it well ('The unknown text to identify and decode'), so the description does not need to add much. The prose clarifies that the input is a piece of text, which is consistent with the schema but does not add substantive new meaning beyond it.

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

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

The description names a specific verb ('Identify'), a specific resource ('a piece of text'), and enumerates the exact encodings, ciphers, and data types it can recognize. It also clearly differentiates itself from sibling converters by framing itself as an identifier and auto-decoder rather than a straightforward encoder/decoder.

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

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

The usage context is clear: use this when you have unknown text and want to identify its encoding or cipher. It also provides an explicit exclusion ('Cannot break keyed encryption such as AES'). However, it does not name specific alternatives like hopi_base64 or hopi_hash_identifier for cases where the encoding is already known.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds the bidirectional behavior and the source URL, but does not disclose details like rounding behavior, precision, or how inches are handled when zero. This is acceptable given the annotations, but not rich.

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

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

Three sentences with no filler. The first sentence states the core function, the second explains both directions, and the third provides a source reference. Every sentence earns its place and the key behavior is front-loaded.

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

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

For a simple bidirectional converter with a full schema, an output schema, and complete annotations, the description covers the essential behavior. The only minor gap is not stating output format details (e.g., whether inches are always included), but the output schema likely covers that, and the tool is simple enough that this is not a significant omission.

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 four parameters and their conditional requirements. The description adds the relationship between direction and which parameters are needed, but this is also encoded in the schema's allOf conditional. The description does not add meaningful detail 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 between centimetres and feet/inches, names both directions explicitly, and specifies what each direction takes and returns. It is easily distinguished from sibling converters like hopi_length_converter or hopi_celsius_to_fahrenheit because it names the exact units and bidirectional behavior.

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 explains both conversion directions and which parameters are used for each, giving clear context for when to use this tool. It does not explicitly name alternatives or exclusions, but the bidirectional direction guidance is sufficient for an agent to select it correctly among many converter siblings.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds useful context by specifying that a 'standard device-independent conversion' is used and provides a source URL, giving the agent confidence in the algorithm's provenance and output semantics.

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

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

Two sentences carry all essential information: direction, ranges, output formats, conversion standard, and source. Front-loaded with the action, no filler or repetition of schema details.

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

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

For a deterministic conversion tool with a rich input schema, complete output schema, and clear annotations, the description covers everything an agent needs: both modes, valid input ranges, output formats, and the conversion approach. Nothing critical is missing.

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

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

Schema description coverage is 100%, with each parameter already documented with range and mode context. The description restates ranges ('each 0 to 100', 'each 0 to 255') and the two directions, but doesn't meaningfully add beyond what the schema already 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 states a specific verb ('Convert'), the resource (CMYK/RGB color values), and the exact bidirectional behavior, including output formats (RGB, hex, CMYK). It distinguishes itself from sibling color tools like hopi_hex_to_rgb by clearly framing CMYK and RGB conversion with mode-specific ranges.

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 clear decision context: if you have print CMYK values, convert to on-screen RGB/hex; if you have RGB values, convert to CMYK. It doesn't explicitly name alternatives or exclusion cases, but for a bidirectional pure conversion tool, the intended usage is unambiguous.

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 useful behavioral context beyond the annotations: it explicitly says the coin is fair, supports multiple flips, and returns a tally. Annotations already declare read-only and non-destructive behavior. There is no direct contradiction, though the idempotent hint sits oddly with a random process; the description itself does not conflict with any annotation.

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

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

The description is two short sentences, front-loads the main action, and contains no filler. The source URL is the only extra element, but it is unobtrusive and does not detract from 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?

For a simple one-parameter tool with a full output schema, complete annotations, and a straightforward behavior, the description provides enough information for an agent to select and invoke it correctly. Nothing about invocation requirements or expected behavior is missing.

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

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

The schema already fully documents the count parameter with range, default, and a clear description. The tool description only echoes 'one or more times' and adds no deeper semantic detail beyond what the schema provides, so the schema-coverage baseline of 3 applies.

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

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

The description states a specific verb and resource: 'Flip a fair coin one or more times.' It also describes the return shape ('each result plus a tally of heads and tails'), making the tool's purpose unmistakable and distinguishing it from random generators like dice rollers and number generators.

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

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

The description makes the use case obvious for anyone needing coin flips, but it does not explicitly mention when to prefer this tool over alternatives or when not to use it. Sibling tools such as hopi_dice_roller and hopi_random_number_generator are not referenced, so guidance is implied rather than explicit.

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

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

Annotations already mark the tool as read-only, idempotent, and non-destructive. The description adds useful behavioral detail beyond that: matching uses straight-line distance in RGB space and only considers 148 named CSS colours. This gives the agent a solid model of how the result is computed.

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

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

One sentence delivers the action, scope, algorithm, and source with no filler. The most important information is front-loaded and every clause earns its place.

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

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

For a single-parameter lookup tool with full schema coverage, a rich output schema, and safety annotations, the description is complete. The algorithm and colour set are specified, and the output schema can be relied on for return-value details.

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

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

Schema coverage is 100% and the single parameter already has a clear pattern and examples. The description mentions 'hex code' but does not add additional meaning beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description states a specific action ('Find the named CSS colour'), a precise resource ('148 named CSS colours'), and the matching rule ('exactly or most closely matches'). This clearly differentiates it from related siblings like hopi_hex_to_rgb or hopi_colour_palette_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?

The description makes the context clear: use this when you have a hex code and need the corresponding CSS colour name. It does not explicitly name alternative tools or state when not to use it, so it misses the top bar, but the usage intent is unambiguous.

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 states 'results vary slightly each call' due to random variation, which directly contradicts the annotation idempotentHint: true. An idempotent tool should return identical results for identical inputs, and the description claims the opposite, making it impossible for an agent to trust the annotation metadata.

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

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

The description is concise, front-loaded with the core action, and contains no wasted words. It includes essential behavioral caveats (random variation, number of swatches) and a source link, all in three sentences without repeating schema details.

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

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

The description covers inputs, output swatch count, scheme options, and the random-variation caveat, and an output schema exists for the return shape. However, the idempotence contradiction undermines the agent's ability to form an accurate model of call outcomes, making the definition incomplete as a whole.

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

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

The input schema already documents both hex and scheme, including the pattern, enum, and default, so schema description coverage is 100%. The description reinforces that hex is a base colour and lists the schemes, but adds no new parameter-level meaning beyond what the schema provides, so a baseline of 3 is appropriate.

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

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

The description states a specific verb ('Generate'), a concrete deliverable ('five-swatch colour palette'), and the required input ('base hex colour'). It also enumerates the four possible schemes, making the tool's function unmistakable and distinguishing it from sibling colour tools such as hopi_colour_shades_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?

The description implies usage by clearly defining the input->output transformation, but it does not explicitly state when to prefer this tool over alternatives like hopi_colour_shades_generator or hopi_random_colour_generator. It offers no exclusions or 'when not to use' guidance, leaving selection to inference.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so no additional safety disclosure is needed. The description confirms a pure input-to-output transformation and includes a source, but does not add behavioral details such as error handling or normalization behavior.

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

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

The description is a single front-loaded sentence covering input and outputs, followed by a source attribution. There is no redundant prose.

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

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

For a one-parameter, stateless, read-only converter with a full output schema and annotations, nothing essential is missing. The simple description is adequate for correct 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 coverage is 100% and the pattern already encodes the optional leading # and six hex digits. The description restates this in plain language but adds minimal semantic detail 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?

States a specific verb ('return'), a clear input ('six-digit hex colour code'), and a precise output set ('hex, RGB and HSL values'). This differentiates it from siblings like hopi_hex_to_rgb by the combined output, so an agent can identify the right conversion tool.

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 input condition is explicit and the output set makes it clear when this tool is the right choice for a full hex conversion. It does not explicitly name alternatives or exclusions, so it stops short of 5.

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

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

Beyond the readOnly/idempotent/destructive annotations, the description discloses the exact mixing behavior: five equal steps of one sixth, mixed towards white for tints and black for shades. It also cites a source URL, adding credibility and context beyond what annotations provide.

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

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

One tightly packed sentence that front-loads the key action and output, then adds precise step details and attribution. No wasted words; the source URL earns its place as provenance.

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 a single simple parameter, an output schema present, and annotations covering safety/idempotency, the description is complete. It states the input, the number of outputs, the mixing direction, the step size, and the source, leaving nothing essential unknown.

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

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

Schema coverage is 100% and the only parameter 'hex' already has a pattern and example in the schema. The description adds no new parameter-level detail beyond referring to it as a 'base hex colour', so the baseline of 3 applies.

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

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

The description states a specific verb ('generate') and a specific resource ('five progressively lighter tints' and 'five progressively darker shades' from a base hex colour). It precisely distinguishes this from siblings like hopi_random_colour_generator or hopi_colour_palette_generator by specifying the exact output structure.

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 use case is clearly implied: 'From a base hex colour, generate...' an agent can infer when to use it. However, it does not explicitly mention alternatives or give exclusions, such as 'for a random colour use hopi_random_colour_generator' or 'for a palette use hopi_colour_palette_generator'.

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 cover read-only, idempotent, and non-destructive behavior. The description adds meaningful behavioral detail by stating that it 'Returns the total count and the combinations themselves (the first 5000),' which discloses output truncation. This is useful context beyond the annotations, though it does not mention edge cases such as when r exceeds the list size.

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 compact and front-loaded: the core purpose is stated in the first clause, followed by return behavior and a source link. Every element contributes directly to understanding what the tool does and what to expect, with no filler or redundant restatement of the title.

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, read-only tool with a full input schema and an output schema present, the description is largely complete. It explains the main operation, the meaning of r, and the output truncation limit. Minor gaps remain around duplicate items or behavior when r is greater than the number of items, but these are not critical for typical invocation.

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

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

Schema description coverage is 100%: the schema already defines 'items' and 'choose' clearly, including the meaning of r. The description reinforces that r is the number of items to choose, but adds no substantial new semantics beyond the schema. The baseline of 3 is appropriate because the schema carries the parameter documentation burden.

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

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

The description states a specific verb and resource: 'List every way to choose r items from a list, ignoring order (combinations).' This clearly identifies the tool's function and distinguishes it from sibling tools by focusing on exhaustive combination generation rather than random selection or other calculators. It also clarifies the 'ignoring order' scope, which separates it from permutation-style tools.

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

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

The description implies usage: use this when you need all unordered combinations of r items from a list. However, it does not explicitly state when not to use it, nor does it name any alternative sibling tool for related tasks like permutations or random sampling. The guidance is contextual but relies on inference.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description goes beyond this by disclosing the calculation methodology—compounding monthly, contributions added at end of month—and by stating the exact return values. This provides useful behavioral context without contradicting 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 three sentences with no wasted words. It front-loads the core action and mechanics, then states the outputs, then units and source. Every sentence contributes to understanding what the tool does, its inputs, and its provenance.

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 and the input schema fully documents parameters, the description provides sufficient methodology, output summary, and units for an agent to invoke the tool correctly. It also credits the source. No critical information for correct invocation is missing.

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

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

Schema description coverage is 100%, so all parameters are already documented with units and defaults. The description adds meaning beyond the schema by clarifying that contributions are added at the end of each month, which affects how the 'monthly' parameter is applied in compounding. It also reinforces currency and rate units, though these are largely present 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 the tool projects savings growth from a starting deposit plus regular monthly contributions, with monthly compounding and end-of-month contributions. It specifies the outputs (final balance, total paid in, interest earned) and units (GBP). It does not explicitly name sibling tools, so it stops short of full differentiation, but the mechanics are specific enough to distinguish it from simple interest or other savings calculators.

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

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

The description implies usage for savings growth projection with contributions, but it gives no explicit when-to-use guidance, no exclusions, and no pointers to alternative sibling tools like savings_goal_calculator or loan_calculator. The agent can infer the intended use case from the phrasing, but there is no direct comparison or routing.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context: it reports AA and AAA for normal and large text, and it cites the source (hopi.co.uk). It does not mention edge cases (e.g., invalid hex handling) but the schema pattern already constrains inputs. This is solid value beyond annotations.

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

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

Two sentences, no fluff. The core function is front-loaded, the output criteria are stated, and the source URL is a useful addition. Every sentence earns its place.

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

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

For a simple two-parameter read-only calculator with a full output schema, the description is nearly complete. It explains what the tool computes, what it reports, and where the logic comes from. It doesn't describe the exact output format, but the output schema exists, so that burden is covered. A 4 is appropriate; a 5 would require explicit mention of edge cases or 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 description coverage is 100%, so the schema already documents both parameters with examples. The description adds the semantic context that foreground is 'text colour' and background is 'background colour', which is already in the schema descriptions. Baseline 3 is appropriate because the schema carries the parameter documentation burden.

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

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

The description states a specific verb ('Work out'), a specific resource (WCAG contrast ratio between foreground and background hex colours), and the exact output (AA/AAA pass/fail for normal and large text). It is clearly distinguishable from the many sibling colour tools (e.g., hopi_colour_name_finder, hopi_hex_to_rgb) because it names the WCAG standard and the pass/fail reporting.

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

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

The description clearly implies when to use this tool: whenever an agent needs to check WCAG contrast between two hex colours. It does not explicitly name alternatives or exclusions, but the context of a large sibling list of colour/calculator tools makes the use case clear. A small deduction for not explicitly saying 'use this instead of X'.

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 establish read-only, idempotent, and non-destructive behavior, lowering the burden on the description. The description adds useful behavioral context by detailing accepted input constructs (stars, steps, ranges, lists, names, shortcuts), giving agents a clearer sense of valid expressions beyond the schema example.

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

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

The description is two tight sentences plus a source URL, with the core action front-loaded. No filler or redundancy; every phrase adds information about scope, supported syntax, or provenance.

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

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

For a single-string-input translator with output schema, annotations, and a feature-rich description, nothing critical is missing for an agent to select and invoke it correctly. The description covers input shape, accepted syntax, shortcuts, and even cites the source for verification.

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

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

Schema description coverage is 100% with a strong parameter description and example. The tool description further enriches parameter semantics by listing supported syntax elements like steps, ranges, and shortcuts, adding value beyond the schema's example.

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

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

The description uses a specific verb ('Translate'), names the exact resource ('standard five-field cron expression'), and states the output ('plain English'). It also enumerates supported syntax features and shortcuts, making the tool's function unmistakable and distinct from other translators/parsers in the sibling list.

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 clear context: use this tool when you need a cron expression rendered in plain English. It implicitly excludes non-five-field formats by specifying 'standard five-field', but it does not explicitly name alternative tools or when-not-to-use conditions.

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, idempotentHint=true, and destructiveHint=false. The description adds useful behavioral context beyond that: breakeven price is always returned, profit/return percentage/total fees appear once a sell price is given, and all figures are in GBP. This clarifies output behavior and currency assumptions.

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

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

The description is two tight sentences with no filler. The primary purpose and inputs are front-loaded, followed by output behavior and the currency note. The source link is the only extraneous element but is a reasonable attribution.

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 calculator nature, full schema coverage, and presence of an output schema, the description covers everything an agent needs: inputs, optional behavior, return values, and currency. No critical usage context is missing.

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

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

Schema description coverage is 100%, so each parameter is already documented in the input schema. The description briefly mentions buy price, quantity, optional per-side fee percentage, and sell price, but adds little semantic detail beyond what the schema already 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 states a specific verb and resource: 'Work out profit or loss on a crypto trade' with explicit inputs (buy price, quantity, optional per-side fee). It clearly distinguishes this tool from the many sibling calculators by naming the crypto trading domain and the exact outputs.

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 clear context for when to use the tool: any crypto trade profit/loss calculation. It explains the optional sell price behavior ('omit to see breakeven only'), which guides usage, but it does not explicitly name alternatives or state when not to use this tool.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false. The description adds useful behavioral detail beyond that: it discloses the operation produces a 'ready-to-use' value and specifically returns 'the gradient value and a full background declaration', plus a source 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?

Three short sentences, each earning its place: purpose, mode options, and return value/source. Information is front-loaded with the main capability and no filler.

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

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

For a moderate-complexity tool, the description plus schema and annotations cover the essentials: what it does, the choices (linear/radial, angle), and what it returns. The output schema handles return structure. Minor gaps like colour format expectations are already addressed in the parameter descriptions.

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 each parameter already has a clear description including defaults and examples. The description only lightly reinforces that two colours and an angle are involved, adding no new semantic detail 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 states a specific verb ('Build') and resource ('a ready-to-use CSS gradient from two colours'), and spells out the two modes (linear with angle, radial). This clearly distinguishes it from the many colour-related siblings such as hopi_colour_palette_generator or hopi_colour_shades_generator, none of which generate gradients.

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

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

It gives clear context for when to use the tool: whenever a CSS gradient is needed from two colours. It does not explicitly name alternatives or exclusions, but the described scope is enough for an agent to route to this tool correctly.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, which cover the safety profile. The description adds meaningful behavioral detail beyond annotations: it preserves quoted strings and calc() spaces, and it reports before and after byte sizes. This gives the agent useful expectations about the result.

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

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

The description is two sentences with no redundant wording. It front-loads the action, states key transformation rules, and notes the return format. The source attribution is extra but does not bloat the description.

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

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

For a one-parameter, pure transformation tool with an output schema and safety annotations, the description covers purpose, transformation behavior, preserved edge cases, and return value. Nothing needed for correct invocation is missing.

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

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

Schema coverage is 100% and the single parameter already has a clear description ('The CSS source to minify'). The tool description adds broader behavioral context but no additional parameter syntax, format, or edge-case instructions, so the 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 opens with a specific verb and resource: 'Minify CSS by removing comments and needless whitespace.' It clearly differentiates the tool from potential sibling utilities like css_gradient_generator by describing the exact transformation and its preserved edge 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?

The description clearly implies when to use the tool: whenever the agent needs to minify CSS. However, it does not explicitly name alternatives or state when not to use it, relying on the tool name and purpose rather than offering routing guidance against sibling tools.

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

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

Beyond the readOnly/idempotent/non-destructive annotations, the description adds meaningful behavior: standard CSV quoting rules for embedded commas, quotes, and line breaks, plus the exact treatment of the first row in both header modes. This tells the agent how conversion behaves rather than merely asserting safety.

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 focused sentences: the conversion action plus the key header-dependent behavior, followed by a source link for reference. Every sentence earns its place and the most important information is front-loaded.

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

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

For a simple two-parameter converter, the description covers input format, quoting behavior, header modes, output shape, and points to source documentation. With an output schema and safety annotations present, nothing essential is missing for an agent to select and invoke this tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description repeats the firstRowHeaders semantics but adds little beyond the schema's own wording, so the baseline of 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Convert CSV text into a JSON array'. It further refines the purpose by explaining header behavior, which makes it clearly distinguishable from the opposite sibling hopi_json_to_csv and other conversion tools.

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

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

The description gives clear context: use this tool when CSV text needs to become JSON, including both header and no-header cases. It does not explicitly mention alternatives or state when not to use it, but the purpose and sibling set make the appropriate use obvious.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description usefully adds that results are 'approximate' and that cups are US cups, and it cites a source for the conversion factors, but it does not describe edge cases such as rounding or precision of the returned value.

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

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

The description is one compact paragraph: a front-loaded conversion sentence, a parenthetical list of ingredients, and a source URL. There is no repeated information and no filler.

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

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

For a two-parameter conversion tool, this is complete: input units, ingredient choices, approximate nature, and provenance are all covered, while the output schema and read-only annotations remove the need to describe return values or side effects.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value beyond the bare enum labels by clarifying 'caster' = caster sugar, 'brown' = packed brown sugar, 'rice' = uncooked rice, and so on, making the accepted values meaningful to an agent.

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

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

The description opens with a specific verb and resource: 'Convert US cups of a common baking ingredient to grams (approximate).' It lists all eight accepted ingredient keys with their real-world equivalents, so the tool's scope is unambiguous and it cannot be confused with the many generic converters among the siblings.

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

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

The use case is strongly implied by the conversion statement and the ingredient list, but there is no explicit mention of when to choose this over another converter or any exclusions (e.g., 'for liquid volumes use volume_converter'). For a simple calculator sibling, the implied context is probably sufficient but not expressly stated.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds genuinely useful behavioral context beyond that: rates are live mid-market, updated hourly, and cover 150+ currencies, with a source URL for verification. This gives the agent a realistic expectation of data freshness and scope.

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

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

Three tight sentences with no filler. The core action is front-loaded, followed by precise usage details and a source reference. Every sentence earns its place.

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

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

For a simple three-parameter converter with full schema documentation, an output schema, and annotations covering safety, the description is complete. It supplies the key contextual facts—live rates, update frequency, currency-code format, and source—so an agent can invoke the tool correctly without further research.

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

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

Schema coverage is 100%, so the schema already documents all three parameters well. The description adds marginal value by providing a richer set of example ISO codes and naming the rate type, but it does not materially deepen understanding of amount, from, or to beyond what the schema states.

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

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

The description opens with a specific verb and resource: 'Convert an amount of money from one currency to another using Hopi's live mid-market exchange rates.' This clearly distinguishes it from the many unit converters among sibling tools, leaving no ambiguity that this is a currency-conversion tool.

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 practical usage guidance by requiring ISO 4217 codes and providing examples (GBP, EUR, USD, JPY). However, it does not explicitly state when to prefer this tool over alternatives or mention any exclusions, leaving the usage context largely implied.

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, idempotent, and non-destructive behavior. The description adds useful behavioral nuance beyond annotations, especially the default decimal interpretation of KB/MB/GB/TB and the optional binary mode, plus a source link for verification.

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 compact and front-loaded: it states the purpose first, lists the units, explains the binary distinction, and ends with the source. Every sentence earns its place without redundancy.

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

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

For a simple, self-contained conversion tool, the description covers all essentials: purpose, units, default behavior, and the optional binary mode. With comprehensive schema documentation, annotations, and an output schema, nothing an agent needs to invoke it correctly is missing.

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

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

Schema coverage is 100%, with each parameter already described in the input schema. The description adds helpful context for the binary flag and unit conventions, but this largely restates and slightly elaborates on what the schema already documents.

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

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

The description uses a specific verb ('Convert') with a clear resource ('digital storage size') and explicitly lists the units involved. It clearly distinguishes itself from the many other converter tools in the sibling list by scoping to data/storage sizes.

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

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

The description provides clear context for when to use the tool, including the decimal-versus-binary distinction and real-world framing ('as storage is sold', 'as Windows reports drive sizes'). It does not explicitly name alternative tools, but the domain is precise enough that an agent can route correctly.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so safety is covered. The description adds valuable non-obvious behavior: the clamping rule for months and years to the last day of the target month, plus the expected return of the resulting date. This goes beyond what annotations alone provide.

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 short sentences, each earning its place: the operation, the date format, the edge-case behavior, and the return value. The source URL is a minor but acceptable addition. The description is front-loaded and free of filler.

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

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

For a pure read-only calculator with a complete input schema, rich annotations, and an output schema, the description covers everything needed: what it does, the format to use, the tricky clamping behavior, and what is returned. No critical information is missing.

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

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

Schema description coverage is 100%, so the schema already explains date, amount, unit, and direction. The description adds useful context around date format and month/year clamping behavior, but it does not substantially deepen understanding of individual parameters 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 opens with a precise verb and resource: 'Add or subtract a number of days, weeks, months or years from a date.' It clearly defines the core operation and differentiates it from sibling tools like hopi_add_working_days or hopi_days_between_dates, even without naming them.

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

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

The operation is clearly stated, so an agent can infer this tool is for calendar date arithmetic. However, it does not explicitly mention when not to use it or point to alternatives such as hopi_add_working_days for business-day calculations. The guidance is functional but implicit rather than explicit.

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

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

Annotations already carry readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds value by disclosing the extra current-year weekday behavior and citing the source URL. Nothing in the description contradicts 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 short and front-loaded: primary purpose first, then input format, then the extra behavior, then source. Each component is useful and there is no filler or repetition of the tool name.

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

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

For a single-parameter read-only calculator with an output schema, the description covers everything an agent needs: what it computes, how the date should be formatted, and the additional current-year report. No critical operational detail is missing.

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

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

Schema coverage is 100%, and the schema already documents the date parameter with format 'date' and a clear YYYY-MM-DD description. The description repeats the format but does not add new semantic meaning beyond the schema. This matches the baseline for high schema coverage.

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

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

The description opens with a specific verb and resource: 'Find which day of the week a given date falls on.' It also names the non-obvious secondary behavior ('Also reports which weekday that same day and month falls on in the current year'), which distinguishes it from generic date calculators. This is specific enough to separate it from siblings like hopi_date_calculator.

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 intended use is implied clearly: call it when you need the weekday of a given date. However, it does not explicitly mention alternatives or exclusions, even though sibling tools like hopi_date_calculator and hopi_days_between_dates overlap in the date-tool space. No routing guidance beyond the core purpose is provided.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful behavioral context beyond that: outputs are gross GBP amounts before tax, the default is 220 billable days, and the produced figures include yearly/monthly/weekly values. 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 compact, front-loaded sentences: the core conversion, the mode behavior, and the gross-GBP caveat. The source URL is the only minor extra but it's useful provenance and doesn't bloat the description.

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 and annotations, the description fully covers what an agent needs to call this tool correctly: the two modes, the default parameter, the currency/tax context, and the conversion direction. Nothing important is missing.

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

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

Schema coverage is 100%, so every parameter is already documented. The description adds meaningful semantic detail over the schema by explaining what each mode produces (yearly, monthly, weekly figures versus a day rate) and confirming the workingDays default of 220. It doesn't give the exact formula, but that's not necessary for correct invocation.

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

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

States a specific verb ('Convert') and resource (contractor day rate to annual salary equivalent), explains both modes, and differentiates it from other salary-related siblings like hourly_to_salary by focusing on day rates. The purpose is unambiguous and self-contained.

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?

Clearly tells the agent when to use each mode ('to_salary' turns a day rate into yearly, monthly and weekly figures; 'to_rate' turns a salary into a day rate) and mentions the default working days. It doesn't explicitly name alternative tools or exclusions, but the context is clear enough for correct selection.

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