Hopi

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so safety is covered; the description adds genuinely useful behavioral context by explaining that bank holiday data is only for 2026 and 2027 and that outside those years only weekends are skipped. It does not contradict 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 main behavior is front-loaded and the description is compact; the source URL is marginally unnecessary for selection/invocation but does not add meaningful clutter. Overall, every substantive sentence earns its place.

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

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

The description, together with rich schema descriptions and output schema, covers most selection and invocation needs, including the important 2026/2027 bank-holiday limitation. It is slightly incomplete on edge-case behavior, such as how a weekend or holiday start date is treated when adding/subtracting.

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

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

With 100% schema coverage, the baseline is 3, but the description adds value by fixing date format ('YYYY-MM-DD') and, more importantly, the bank-holiday data limitation that directly affects the bankHolidays parameter. The add/subtract wording maps cleanly to the days and direction parameters.

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

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

The description names a specific operation—'Add or subtract a number of working days (Monday to Friday) from a start date'—with a clear resource and optional bank-holiday behavior. This also differentiates it from sibling hopi_working_days_calculator, which implies counting days between dates rather than shifting a date.

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 implied by the verb phrase and the 'optionally skipping... bank holidays' option, but there is no explicit mention of when not to use it or a named alternative such as hopi_working_days_calculator for counting working days between two dates. Clear context, but no explicit routing/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 non-destructive behavior. The description adds meaningful behavioral detail by listing the computed outputs (years, months, days, total days lived, next birthday) and clarifying the optional as-of date behavior beyond the structured annotations.

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

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

Three short sentences deliver purpose, input format, optional parameter behavior, and output enumeration with no filler. The most important usage detail is front-loaded, and the source URL adds provenance without bloating 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 simple read-only calculator with rich annotations and a complete schema, the description covers what the tool does, what inputs it accepts, what it returns, and how dates should be formatted. 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 description coverage is 100%, and both parameters already have clear descriptions and date formats. The description adds only minor value by restating the optional as-of date and YYYY-MM-DD format, 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 ('work out an exact age') and names the precise resource (a date of birth) with optional as-of-date semantics. It clearly differentiates this from date-related siblings like days_between_dates or working_days_calculator by focusing on exact age breakdown and next birthday.

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: computing an exact age from a DOB, either today or at a chosen date. It does not explicitly name alternative tools or exclusions, but the use case is unambiguous enough for an agent to select it correctly among the many sibling calculators.

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 context: the formula, the optional weekly comparison against the NHS guideline, and a source URL – none 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?

Two sentences pack the formula, optional behavior, guideline reference, and source without redundancy. Front-loaded with the core action and formula, all information 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 calculator tool, the description provides the calculation formula, optional weekly variant, health guideline comparison, and source. The output schema exists, so no need to describe return format. 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 covers all parameters with examples (100% coverage), so baseline is 3. The description adds value by explicitly linking abv and ml to the formula and explaining drinksPerWeek's purpose, going 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?

Describes a specific calculation ('work out UK alcohol units') with the exact formula, distinguishing it from generic calculators. The optional weekly total further clarifies scope and differentiates from similar tools like event wine 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?

Clearly implies when to use (when needing UK alcohol units from ABV and volume), and the optional weekly parameter adds a use case. No explicit alternatives or exclusions, but the context is strong enough 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?

Beyond the readOnlyHint and idempotentHint annotations, the description reveals important behavioral traits: blank lines are dropped, natural en-GB ordering makes numbers sort sensibly, and both ascending/descending and case-insensitive modes are available. This gives the agent useful expectations that annotations alone do not 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?

The description is tight and front-loaded: the core action appears first, followed by high-value behavioral details and options. The source URL is a minor but acceptable addition, and 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 sorting utility with a low parameter count and an output schema present, the description covers the inputs, key edge-case behavior, and available options. There is nothing essential missing for an agent to invoke the tool correctly.

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

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

The input schema already provides 100% coverage with clear descriptions for text, direction, and caseInsensitive. The description mostly restates these options ('ascending', 'descending', 'ignore case') and adds the natural-ordering nuance, but it does not provide substantial new per-parameter meaning beyond the schema.

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

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

The description opens with a specific verb and resource: 'Sort the lines of a block of text into alphabetical order.' It clearly distinguishes this from the many sibling text utilities by specifying line-level alphabetical sorting, and it names the exact operation without 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 makes the use case clear: sorting lines of text alphabetically, with optional direction and case sensitivity. It does not explicitly name alternatives or when-not-to-use conditions, but among the sibling tools no direct sorting alternative exists, so 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, covering safety and idempotency. The description adds the source URL and the unit list, which are useful but not strictly behavioral traits. It does not disclose any potential edge cases, rounding behavior, or error handling, but given the simple nature of a converter and the annotation coverage, a mid-range score is appropriate.

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

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

The description is two concise sentences with zero fluff. The purpose is front-loaded, followed by the unit list and a source reference. Every sentence adds value, and the structure is clean and immediately readable.

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

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

For a simple, read-only converter with a complete schema, output schema present, and annotations covering safety and idempotency, the description is fully adequate. It lists the units, provides the source, and states the core function. Nothing essential is missing for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, with all three parameters (value, from, to) described. The description lists the allowed units, which mirrors the enums in the schema but adds no new meaning beyond what the schema already provides. Per the rubric, baseline 3 is correct when 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 converts angles between units, specifying the exact verb and resource. It lists the four supported units (deg, rad, grad, turn), which differentiates it from sibling converters like length, weight, or volume. The purpose is unambiguous and specific.

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

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

The description clearly implies when to use this tool: whenever an angle needs unit conversion. It doesn't explicitly mention alternatives or exclusions, but the tool name and description are self-explanatory. Since there are many converter siblings, the description's focus on angles is sufficient context for selection.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds no behavioral detail beyond the conversion action itself, such as precision, rounding, or handling of zero values; the source URL is non-behavioral context.

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, front-loading the action and listing units. The source URL is a minor addition that does not significantly bloat the description, but it's not essential for tool 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?

For a simple conversion tool with all parameters documented and an output schema present, the description covers the necessary info: the operation, the unit set, and source. Missing details like rounding behavior are not critical given the tool's simplicity.

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

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

Schema coverage is 100% with descriptions for value, from, and to. The description adds the full unit names (e.g., square metres, square feet) that map to the abbreviated enum codes, which helps an agent interpret parameters 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 states 'Convert an area from one unit to another' with a specific verb and resource, and lists the seven supported units. However, it does not explicitly distinguish itself from sibling converters like length_converter or weight_converter, relying on the tool name for that differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives, and no exclusions or prerequisites. It only states what it does, leaving the agent to infer applicability.

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, and the description adds useful behavioral context by describing the outputs produced in each mode and including the source URL. There is no contradiction with the annotations.

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

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

The description is concise and front-loaded with the tool's purpose, then splits into two clearly labelled modes. Every sentence adds value, and the source URL is placed at the end without cluttering the guidance.

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 stateless calculator with rich schema descriptions, read-only annotations, and an output schema, the description covers all necessary calling information: modes, input requirements, output types, and source. 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?

The schema already documents all parameters, but the description adds meaningful mappings for how parameters are used in each mode, including the important detail that solve mode requires ratioW:ratioH plus one of width or height. It also clarifies the intended ratio format. This goes beyond the flat property descriptions.

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

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

The description clearly identifies the tool as an aspect ratio helper and immediately explains its two modes: simplify width/height into W:H ratio, decimal ratio and nearest common ratio, or solve for a missing side from a ratio plus one known side. It is specific enough to distinguish this from sibling calculators like hopi_ratio_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 gives explicit mode-based instructions: use 'simplify' with width and height, and use 'solve' with ratioW:ratioH plus one known side. It does not explicitly name alternatives or state when not to use the tool, but the mode guidance is clear and actionable.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering safety. The description adds a valuable behavioral quirk: commas are treated as separators, so users must type 1200 instead of 1,200. This goes beyond the schema and annotations, giving agents critical parsing behavior. No contradictions.

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

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

Two sentences with no wasted words. The purpose is front-loaded, followed by input format and a practical gotcha. The source URL is extra but not distracting. The description is efficient and well-structured.

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

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

For a simple one-parameter read-only tool with an output schema and full annotations, the description covers purpose, input format, and a parsing pitfall. Nothing an agent needs to invoke it correctly is missing. The output schema handles return values, so no need to describe them.

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 describes the parameter as 'A list of numbers separated by spaces, commas, semicolons or new lines'. The description repeats this but adds a crucial caveat about thousand separators, which prevents misinterpretation. This adds meaning beyond the schema, so it exceeds the baseline of 3.

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

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

The description states a specific verb ('Work out') and a clear resource (a list of numbers) and enumerates the exact outputs: mean, median, mode, sum, count, minimum and maximum. This is unambiguous and distinguishes it from other calculators like standard_deviation_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 (when you need central tendency and summary statistics) but does not explicitly mention alternatives or exclusions. It provides input formatting guidance, which is helpful for parameter usage, but no when-not-to-use criteria. The context is clear, but no explicit 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?

Even with readOnly, idempotent, and non-destructive annotations, the description adds substantial behavioral detail: UTF-8 byte handling, 5-bit grouping, the A-Z/2-7 alphabet, padding rules, lowercase tolerance, missing-padding tolerance, and error reporting for invalid characters. This goes well beyond the annotations.

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

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

The description is compact and front-loaded: the main purpose is in the first sentence, followed by useful encoding/decoding specifics. The source URL is a minor addition and does not bloat the entry.

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

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

For a two-parameter tool with a full output schema, the description covers the algorithm, padding, supported input variants, and failure behavior. Nothing critical is missing for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100%, with both 'mode' and 'text' described in the schema itself. The description reinforces parameter meaning but does not add significant parameter-level semantics 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 opens with a precise statement: 'Encode text to RFC 4648 Base32 or decode Base32 back to text.' It names the exact resource (Base32), the standard (RFC 4648), and both directions of operation. This clearly distinguishes it from siblings like hopi_base64.

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 usage context clear: it is for converting text to Base32 or Base32 back to text, including decode tolerances and error behavior. It does not explicitly name alternatives or state when not to use this tool, but the Base32 versus Base64 distinction is evident from the resource name.

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

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

Annotations already mark it read-only, idempotent, and non-destructive. The description adds valuable behavioral context: UTF-8 safety for accents and emoji, and a clear error return. These details go beyond the annotations and help an agent anticipate edge cases.

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 plus a source URL. It is front-loaded with the core action and includes only essential details. 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 two-parameter tool with rich annotations and full schema coverage, the description covers all necessary behavior: what it does, UTF-8 safety, return type, and error handling. The provided schema and annotations fill any remaining 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%, so the parameters are already well documented. The description adds minimal extra meaning, mostly reinforcing that 'text' is the content to convert. It does not introduce any new parameter-level insight beyond the schema.

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

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

The description clearly states the tool's function with specific verbs: 'Encode text to Base64, or decode a Base64 string back to text.' It names the exact resource (Base64) and distinguishes from similar tools like base32_encoder. 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 makes the usage context obvious: use it when you need Base64 encoding or decoding. The dual-mode nature is explicitly stated. It does not mention alternatives, but for a standard encoding tool the context is clear enough.

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

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

Discloses non-obvious behavior: tip and service percentages are applied to each person's own share, amounts are in GBP, and service charge only appears in itemised mode. Annotations already convey read-only and idempotent behavior, so the description adds useful context beyond 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?

Three concise sentences with the core purpose front-loaded and the source URL at the end. No filler or redundancy; 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 two-mode tool with conditional parameter requirements, the description covers both modes, optional tip/service, currency, and source. The output schema exists to describe return values, so their omission here is not a gap.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaning by clarifying that percentages apply per-person and that amounts are in GBP, which supplements the schema without repeating 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?

States a specific verb ('Split'), resource ('restaurant bill'), and clearly explains the two modes ('itemised' and 'even'). It is easy to distinguish this tool from generic tip or VAT calculators based on the description alone.

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

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

Provides clear context for when to use itemised mode versus even mode, including what each mode requires. It does not explicitly name sibling alternatives or state when not to use this tool, but the internal mode guidance is strong.

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

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

Beyond the annotations (readOnly, idempotent, non-destructive), the description reveals meaningful output behavior: the exact grid dimensions, the per-decade column constraints, the blank squares represented as null, and the source URL. This gives an agent precise expectations for the result format.

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 front-loaded sentence covering purpose and key structural specifics, followed by a source reference. No redundant words, and every detail contributes to call correctness.

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 generator with an output schema, the description covers all necessary context: card format, number layout, column constraints, and null representation. The existing output schema handles return-value details, so 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 schema already fully documents the 'count' parameter (1-100, default 1). The description's phrase 'one or more' merely restates the schema and adds no new semantic detail. With 100% schema coverage, the baseline of 3 applies.

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

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

The description clearly states the tool generates 'one or more UK 90-ball bingo cards' with a specific verb and resource. It details the card structure (3x9 grid, 15 numbers, 5 per row, decade columns), making it highly distinct from sibling generators like lottery or random number 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 context is explicit: it's for generating UK 90-ball bingo cards. While no alternative tools are referenced or exclusion criteria mentioned, the unique domain (bingo) makes it obvious when to use. This meets the 'clear context, no exclusions' level.

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

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

Beyond the annotations (readOnlyHint=true, destructiveHint=false, idempotentHint=true), the description discloses meaningful behavioral boundaries: it verifies checksum and structure without querying the blockchain or checking balances. This gives an agent a precise model of what the tool can and cannot do, with no contradiction.

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

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

The description is three dense sentences with the core purpose front-loaded. Every sentence adds distinct value: what the tool does, what inputs it supports, and what it explicitly avoids. The source URL is supplemental but not bloated.

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, a single-parameter schema, and rich annotations plus an output schema, the description covers all necessary invocation details: purpose, accepted formats, networks, and limitations. An agent has enough context to select and call the tool correctly.

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

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

The schema already describes the single 'address' parameter at 100% coverage, establishing baseline 3. The description goes further by enumerating valid address variants (legacy Base58Check, Bech32/Bech32m, SegWit, Taproot, mainnet/testnet), which materially helps an agent construct a valid parameter value.

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

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

The description uses a specific verb ('Check whether') and resource ('a Bitcoin address is valid') and clearly distinguishes this tool from sibling validators like hopi_iban_validator and hopi_eth_address_checksum. It further narrows scope by naming supported address formats, networks, and what it does not do.

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 context clear: it is for Bitcoin address validation only, covering specific formats and networks. It also includes a when-not-to-use signal ('Does not query the blockchain or check balances'), though it does not explicitly name an alternative tool for balance lookups.

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 the formula (BMI = weight in kg / (height in metres squared)) and the NHS category output, which are useful behavioral details beyond the schema. It does not mention edge cases like invalid height/weight values, but the schema's exclusiveMinimum covers basic validation.

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 core purpose is front-loaded, the unit instructions are compact, and the formula and source are included without bloating 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?

The description covers purpose, unit selection, formula, and output category. The output schema exists, so return values need not be explained. Minor gap: it doesn't state what happens with invalid inputs (e.g., zero or negative values), but the schema's exclusiveMinimum and the simple nature of the tool make this a small 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 five parameters. The description adds the unit-system mapping (metric vs imperial) and the formula, but it does not add meaning beyond what the schema's conditional requirements and parameter descriptions already provide. 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 ('Work out'), a clear resource ('body mass index (BMI) from height and weight'), and the distinctive output ('with the NHS weight category'). It also names the two unit systems, which distinguishes it from sibling calculators like hopi_body_fat_calculator or hopi_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 description gives explicit usage instructions: use 'metric' with heightCm and weightKg, or 'imperial' with heightInches and weightPounds. It does not explicitly state when not to use it or name alternatives, but the unit-specific guidance is clear enough for an agent to select and invoke 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, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful behavioral context beyond annotations: it explains the estimation method, sex-dependent input requirements, unit handling, and the optional weight parameter that enables fat mass and lean mass calculation.

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 purpose in the first sentence and supporting usage details in the next two. Every sentence adds value: method, sex-specific inputs, unit options, optional weight behavior, and source 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?

For a calculator with 7 parameters and an output schema, the description is complete: it covers the method, required versus optional inputs, sex differences, unit conventions, and what the optional parameter enables. The output schema handles return value details, 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?

Schema coverage is 100% with meaningful parameter descriptions, so the baseline is 3. The description goes beyond the schema by explaining the sex-specific conditional requirement for hip, clarifying how units map to parameters, and stating the purpose of the optional weight parameter in producing additional outputs.

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 starts with a specific verb and resource: 'Estimate body fat percentage using the US Navy tape method.' It distinguishes this calculator from sibling health calculators like BMI or TDEE by naming the exact measurement method and the output it produces.

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 usage context by specifying which measurements are needed for males versus females, and which unit system to use. It does not explicitly name alternatives or when not to use this tool, but the scope is clear enough for an agent to select it appropriately.

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, covering the safety profile. The description goes beyond by specifying the transformation behavior: only A-Z letters are changed, others remain, and decoding reverses the shift. It does not explicitly address case preservation, but it does not contradict annotations. This adds meaningful behavioral context beyond the structured hints.

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

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

The description is three sentences with no wasted words. The core purpose is front-loaded, followed by the key mechanics and a source link. It is efficiently structured and each 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 transformation tool with a rich input schema and an output schema (per context signals), the description covers everything an agent needs to call it correctly: what it does, how the shift works, and edge cases like non-letters. There is no missing information that would prevent 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 description coverage is 100%, so all three parameters (text, shift, mode) are documented. The description reinforces the shift meaning by noting that 13 equals ROT13, which adds a useful reference. However, it does not add new semantics beyond what the schema already conveys; the baseline of 3 is appropriate because the schema handles 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 opens with a precise verb and resource: 'Encode or decode text with a Caesar shift cipher.' It immediately clarifies the operation (encode/decode) and the specific cipher type. The mention of ROT13 as shift 13 differentiates it from sibling ciphers like hopi_vigenere_cipher, and the explanation of only A-Z letters being altered gives a concrete scope.

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

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

The description clearly states what the tool does and the mechanics (shift amount, ROT13 equivalence, non-letter handling). It does not explicitly name alternatives or conditions when not to use it, but given the self-evident name and the context of a simple utility, the intended usage is clear. No exclusions are mentioned, but the description is adequate for typical 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 mark the tool as read-only, idempotent, and non-destructive, so side-effect disclosure is not needed. The description adds useful context about the three outputs and includes the authoritative source URL, though it does not mention edge-case handling such as zero ending values or numeric formatting.

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: the first states the core operation, the second lists outputs, and the third provides the source. 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 calculator tool, the description plus full schema descriptions, output schema, and safe annotations cover everything an agent needs to invoke it correctly. No critical information about inputs, outputs, or safety 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 documents all three parameters. The description reinforces the relationship between start, end, and years, but adds no new parameter-level meaning such as units, examples, or formula details 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 names the specific operation ('Work out the compound annual growth rate') and the resource relationship ('starting value to an ending value over a number of years'), and enumerates the returned values (annual rate, total growth, growth multiple). This makes it readily distinguishable from related calculators like compound_interest_calculator or percentage_change_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 usage context is implied by the CAGR definition, but there is no explicit when-to-use/when-not-to-use guidance or reference to sibling alternatives. An agent must infer that this is the right tool for CAGR rather than the closely related compound interest or inflation calculators.

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 it read-only and idempotent; the description adds the exact conversion factor and that both values are returned, which is meaningful behavioral detail beyond schema and annotations. No contradiction is present.

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 the operation and factor first and the ancillary source URL last. No redundant phrasing 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?

With a complete input schema, an output schema, and annotations covering read-only and idempotence, the description covers the remaining needed context: what to pass, the factor, and that both values come back. Nothing important is missing for a simple converter.

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

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

Both parameters are fully described in the schema, including the enum for the unit, so the description's restatement of 'amount and unit' adds little. It reinforces the flow but does not meaningfully enrich parameter semantics beyond the schema.

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

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

States a specific conversion operation (kcal ↔ kJ) with the exact factor, immediately differentiating it from the many other converter siblings. The resource and direction are unambiguous.

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

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

The description tells the agent to supply an amount and a unit, and frames the tool as the food-energy converter, which makes the intended context clear. It doesn't explicitly discuss alternatives or exclusion cases, but none are material for such a unique unit pairing.

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 source URL and explains the case conversion semantics, but doesn't disclose details like how 'title' handles edge cases (e.g., articles, hyphenated words) or how 'sentence' detects sentence boundaries. For a pure text transformation, this is adequate 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?

The description is a single compact sentence that front-loads the core purpose, then defines all four modes in a scannable list, and ends with a source attribution. Every element earns its place with 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 two-parameter text transformation with an output schema, the description covers the essential semantics. The mode definitions are the only real ambiguity, and they are fully explained. The source URL is a minor bonus. It doesn't discuss edge cases, but for this tool's simplicity, the description is complete enough for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, so both parameters ('text' and 'mode') are already documented in the schema. The description adds value by explaining what each enum value does, which goes slightly beyond the schema's terse 'The target case' description. However, the schema already carries the parameter definitions, so the description's contribution is marginal.

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 text to a different letter case, and explicitly defines each of the four modes ('upper', 'lower', 'title', 'sentence') with examples. This is a specific verb+resource that distinguishes it from the many other text-manipulation siblings like hopi_reverse_text or hopi_remove_extra_spaces.

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 what each mode does, which effectively tells the agent when to use this tool and which mode to select. It doesn't explicitly name alternatives or exclusions, but the mode definitions provide clear context for choosing this tool over other text utilities. The sibling list contains many text tools, but the description's mode breakdown is sufficient guidance for this simple utility.

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 the specific conversion formula and the fact that it returns both the human-equivalent age and life stage, which is useful behavioral context beyond the annotations. It doesn't mention edge cases like age 0 or 40, but the schema already constrains those.

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 with no filler. The core action and formula are front-loaded, and the source URL is appended without disrupting the main content. Every sentence earns its place.

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

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

The description is complete for a simple, single-parameter, read-only calculator. It explains the conversion method and return values. The output schema exists, so return values are further documented. The only minor gap is not explicitly stating the life stage categories, but that's not necessary for calling the tool correctly.

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

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

Schema description coverage is 100%, so the schema fully documents the catAge parameter (type, range, description). The description adds the conversion chart context but doesn't add new parameter-level semantics 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 clearly states the tool converts a cat's age in years to an approximate human age, specifies the exact conversion chart (15, 24, then 4 a year), and mentions the return values (human-equivalent age and life stage). This distinguishes it from the sibling hopi_dog_age_calculator and hopi_age_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 implies when to use it: when you need to convert a cat's age to human years. It doesn't explicitly state when not to use it or name alternatives like hopi_dog_age_calculator, but the specificity of 'cat' and the conversion chart makes the usage context clear. A small gap is not mentioning that this is for cats only, not dogs or other pets.

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 readOnlyHint, idempotentHint, and destructiveHint, so the description's job is light. It adds useful behavioral context beyond the annotations by noting that Kelvin is also returned and by clarifying the direction values. There is no contradiction with the annotations.

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

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

The description is compact and front-loaded: the main action is stated first, followed by the Kelvin behavior, the direction instruction, and a source link. Every sentence contributes useful information and there is no redundancy.

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

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

For a simple read-only conversion tool, the annotations cover the safety profile, the schema fully documents both required parameters, and an output schema exists. The description adds the only missing detail—Kelvin is returned—so an agent has everything needed to call the tool correctly.

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

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

The schema has 100% parameter description coverage, including enum values with a full explanation. The description merely restates the direction values ('c-to-f' or 'f-to-c') without adding new meaning about the value's range, format, or units, so it stays at the high-coverage baseline.

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

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

The description states a specific action—'Convert a temperature between Celsius and Fahrenheit'—and adds the extra Kelvin return, which clearly distinguishes it from generic temperature converters like hopi_oven_temperature_converter. It is not a tautology and fully explains the tool's primary function.

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 offers the 'how' by telling the agent to set direction to 'c-to-f' or 'f-to-c', but it does not specify when to prefer this tool over sibling converters or when not to use it. Usage context is only implied by the explicit units, not stated as a decision rule.

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 cover read-only, idempotent, non-destructive behavior, so the description only needs to add algorithmic detail. It adds meaningful behavior by listing exactly which counts are computed (with/without spaces, words, SMS, Twitter remaining), reducing ambiguity about what 'count characters' means.

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 information-dense sentence presents the action and all output variants, followed by a short source attribution. No filler or repeated schema information.

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

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

With a single string input, a full output schema, and annotations covering side effects, the description gives the agent everything needed to invoke and interpret results. Listing the concrete output categories is sufficient for this pure calculation tool.

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

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

The schema already describes the only parameter ('The text to measure') at 100% coverage, so the description does not need to compensate. It only restates the same concept as 'a block of text' and adds no format, encoding, or length constraints 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 starts with the concrete verb 'Count the characters in a block of text' and then names every output metric: spaces-removed count, word count, SMS segment count, and Twitter/X character remaining. This makes the tool easy to distinguish from sibling text tools like word_counter or text_splitter.

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 clear from the description: any time an agent needs character-level measurements of a text block. It does not explicitly say when to prefer the sibling word_counter or text_splitter, but the scope and metrics imply the appropriate context without ambiguity.

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

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

Beyond the readOnly/idempotent annotations, the description discloses concrete behavior: it 'Returns ranked candidates with confidence and a decoded preview', auto-decodes up to 8 nested layers with a 60% confidence threshold, and explicitly states its limitation with keyed encryption. This gives an agent a clear model of what will happen when the tool is invoked.

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 dense sentences: core purpose, behavioral details, and a clear limitation plus source. Every sentence adds information, and the most important action verb ('Identify') is front-loaded. There is no filler or duplication of schema content.

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 tool with a rich output schema, the description covers the input type, supported format families, the ranked/confidence/preview return behavior, the auto-decode loop and its stopping condition, and the keyed-encryption limitation. The source URL adds provenance. Nothing essential is missing for an agent to decide whether and how to call this tool.

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

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

The input schema already describes the single parameter as 'The unknown text to identify and decode', and the description's reference to 'a piece of text' essentially restates that. With 100% schema description coverage, the baseline of 3 is appropriate; the description adds no further semantic detail such as length limits, character set, or example formats.

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: 'Identify what encoding or classical cipher a piece of text probably is' and enumerates concrete formats (Base64, Base32, hex, Morse, Caesar/ROT-N, etc.). It also says it 'auto-decodes nested layers', which clearly ties the name to an actionable, distinct function. This differentiates it from sibling tools by focusing on identification and automatic decoding rather than single-format conversion.

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

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

The description makes the primary use case explicit: provide unknown text and get an identification and decode. It also gives a clear when-not: 'Cannot break keyed encryption such as AES'. However, it does not name alternative tools for when the encoding is already known, relying instead on the sibling list, 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, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no behavioral details beyond these—no side effects, auth needs, or rate limits are applicable for a pure conversion. With the annotation bar lowered, the description performs adequately but adds no extra transparency credit.

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 convey the full purpose and direction-specific behavior without fluff. The source URL is an extra clause but not intrusive. Information is front-loaded with the core action first, then the direction details. Very compact and effective, though the source link could be omitted without loss.

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

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

For a simple read-only converter with a full output schema and complete parameter descriptions, the description covers the essential usage: both conversion directions and which inputs are required. It does not mention rounding or precision, but the output schema likely handles that. Overall, it is sufficiently complete for an agent to call 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 baseline is 3. The description reiterates the direction-parameter mapping already present in the schema (e.g., 'cm' description says 'for cm-to-feet'), but adds no new semantic nuance like formatting, precision, or edge-case handling. It correctly reflects the conditional requirement but does not elevate above the schema baseline.

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

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

The description opens with a specific verb and resource: 'Convert a height between centimetres and feet/inches.' It explicitly names both directions and what each returns, which clearly distinguishes this from generic length converters like hopi_length_converter and other unit-specific siblings such as hopi_kg_to_stone or hopi_miles_to_km. The purpose is unambiguous and fully stated.

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 which parameters to use for each direction ('Direction cm-to-feet takes cm... Direction feet-to-cm takes feet and inches...'), giving clear when-to-use context within the tool. It does not explicitly mention alternatives like 'use hopi_length_converter for other units,' but the specialized name and sibling set make that exclusion implicit. There is clear context, just no explicit exclusionary 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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context by noting it 'Uses the standard device-independent conversion' and provides a source URL, which clarifies the conversion semantics beyond the schema.

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

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

The description is two tight sentences. The first front-loads the core conversion behavior and ranges, and the second adds the conversion standard and source link. There is no filler, tautology, or unnecessary repetition of the title or schema.

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 this is a deterministic conversion tool with full parameter schema coverage and an output schema, the description is complete enough for correct invocation. It identifies the mode-dependent directions, the value ranges, and the conversion standard, so an agent has everything needed beyond the structured schema.

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

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

Schema description coverage is 100%, with every parameter already documented with ranges and mode-conditional usage. The description reinforces the 0–100 CMYK and 0–255 RGB ranges, but it does not add per-parameter meaning beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the verb and resource: 'Convert print CMYK values ... to on-screen RGB and hex, or convert RGB ... the other way to CMYK.' It explicitly names both directions, the color spaces involved, and gives ranges, making it unambiguous against sibling color converters like hopi_hex_to_rgb or hopi_rgb_to_hex.

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

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

It provides clear context for when to use the tool: converting between print CMYK values and on-screen RGB/hex. It does not explicitly name sibling alternatives or state exclusions, but the bidirectional scope is specific enough to guide selection without 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 establish readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so no contradiction exists. The description adds a useful fairness guarantee ('fair coin') and summarizes output shape, but with an output schema available, this is context rather than essential disclosure.

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 short sentences front-load the action and result, with no redundant wording. The source URL is a minor but harmless addition, and every sentence earns its place.

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

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

The tool is simple, has one optional parameter, an existing output schema, and annotations covering 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%, and the count parameter is fully documented in the input schema. The description's 'one or more times' adds no meaning beyond the schema's min/default/max, so it rests at the baseline.

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

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

The description uses a specific verb and resource: 'Flip a fair coin one or more times.' It clearly distinguishes this from random utilities like dice_roller or random_number_generator by naming the coin-flip mechanic and adding that results are tallied.

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 obvious use case but gives no guidance about when to prefer this over sibling alternatives such as dice_roller, random_number_generator, or yes_no_wheel. There are no when-to-use, when-not-to-use, or exclusion statements.

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 safety (readOnly, idempotent, non-destructive), so the bar for additional credit is lower. The description adds genuine behavior beyond annotations: the matching is done with straight-line RGB distance (disclosing a non-perceptual approximation), results may be exact OR approximate ('exactly or most closely'), and the colour set size is pinned at 148. The source URL also adds verifiability. 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?

One tightly written sentence that front-loads the verb, resource, and distinguishing algorithm, then appends a useful source reference. Every element earns its place with zero filler or redundancy.

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

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

For a single-parameter, read-only look-up tool with full schema coverage, a strong output schema, and complete annotations, the description is fully adequate. It explains the algorithm, the matching tolerance, and the colour universe (148 named CSS colours). 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 description coverage is 100%, so baseline is 3. The schema already documents the hex format via pattern and example (#DC143C or #F00). The description contributes marginal meaning by implying that arbitrary hex values work and will be matched to the closest named colour, but it does not add formatting or syntax 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 names a specific verb and resource ('Find the named CSS colour'), specifies the input (hex code), and the matching method ('straight-line distance in RGB space across the 148 named CSS colours'). This clearly distinguishes it from colour-related siblings such as hopi_hex_to_rgb, hopi_colour_palette_generator, and hopi_colour_picker without needing to inspect their schemas.

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 implied: given a hex code, get its matching named CSS colour. However, the description never names alternatives or states when NOT to use this tool (e.g., versus hopi_hex_to_rgb for RGB conversion or hopi_colour_picker for interactive picking). With many colour-related siblings, explicit routing guidance is absent, 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?

The description usefully discloses non-determinism ('supporting swatches carry a small random variation, so results vary slightly each call') and cites a source. However, this directly contradicts the idempotentHint=true annotation: repeated identical calls are not guaranteed to produce identical results. Per rubric, a contradiction with annotations scores 1.

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 wasted words. The core action and output are front-loaded, followed by the randomness caveat and source attribution. Every sentence earns its place.

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

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

The tool is simple, schema coverage is complete, and an output schema exists. The description supplies output size, available schemes, and variability behaviour, so nothing necessary for a correct call 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%, and both parameters already have clear descriptions including the enum for scheme. The description adds no format or default details 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?

States a specific verb ('Generate'), specifies the exact output ('five-swatch colour palette'), the input ('base hex colour'), and enumerates the four schemes. This clearly differentiates it from sibling tools like hopi_colour_shades_generator and hopi_random_colour_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 clearly conveys when to use it: whenever a palette is needed from a hex colour using one of the four named schemes. It does not explicitly list alternative tools or exclusions, but the context is clear enough 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 indicate readOnlyHint=true and idempotentHint=true, so the agent already knows this is a safe, non-destructive operation. The description adds value by specifying the exact input format (with or without '#' and case-insensitive) and that the output includes all three formats, which is genuinely useful. It doesn't contradict annotations.

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

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

The description is a single, efficient sentence that states the tool's purpose in the opening clause and includes a useful source link. It is front-loaded with the core functionality and wastes no words.

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

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

Given there is an output schema and the annotations cover read-only and idempotent behavior, the description is mostly complete. It could mention edge cases like invalid hex formats, but the schema's pattern already validates this. Overall, an agent has enough to call 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?

The schema already fully documents the single 'hex' parameter with a pattern and example. The description reinforces the format acceptance (with or without '#') and clarifies the conversion intent, which adds a little beyond the schema but is not essential given the 100% coverage. Baseline is 3, improved to 4 for the input format clarification.

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 that the tool converts a six-digit hex colour code to hex, RGB, and HSL values. It distinguishes itself from sibling tools like hopi_hex_to_rgb and hopi_rgb_to_hex by covering all three representations, but does not explicitly name these alternatives, so it doesn't fully differentiate across the colour conversion cluster.

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

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

The description implies the tool is for converting hex to multiple colour formats, which is clear enough for typical use. However, it offers no explicit guidance on when to choose this over more specific converters like hopi_hex_to_rgb or hopi_hsl_converter, nor does it mention exclusions or prerequisites beyond the hex input format.

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

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

Annotations already declare the tool as read-only, idempotent, and non-destructive, so the safety profile is covered. The description adds meaningful behavioral detail: it explicitly states the number of tints/shades (five each) and the step size (one sixth), and that tints are mixed towards white and shades towards black. This goes beyond the annotations and gives the agent a clear expectation of the operation. It does not mention return format, but the presence of an output schema covers that.

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 action and output specification. Every sentence earns its place: the first states the operation and algorithm, the second credits the source. There is no redundant wording or filler. The structure is clear and easily scannable.

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

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

For a simple single-parameter tool with an output schema, the description provides sufficient detail: it specifies the number of outputs, the mixing direction, and step increments. It does not mention potential error handling or invalid input, but the schema pattern already enforces validity. The tool is fully understandable for an agent to invoke correctly, though it lacks usage context (which is scored separately).

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

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

The input schema provides a full description for the single parameter 'hex' (six-digit hex code with example), achieving 100% schema coverage. The description adds minimal new meaning, merely restating 'base hex colour'. No extra formatting, range, or edge-case information is given. Per the rubric, with high schema coverage the baseline is 3, and the description does not elevate it further.

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 exactly what the tool does: from a base hex colour it generates five lighter tints and five darker shades, specifying the mixing towards white/black and the step count. This is a specific verb and resource, clearly distinguishing it from sibling colour tools like palette generators or random colour generators. The action and output are unambiguous.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention sibling tools such as hopi_colour_palette_generator or hopi_hex_to_rgb, nor any exclusion criteria. An agent must infer usage from the tool name alone. The description is purely functional with no contextual or routing information.

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 two behavioral facts: the return payload (total count plus the combinations) and the hard 5000-result truncation. The truncation is important operational context an agent would otherwise only discover at runtime.

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 the purpose front-loaded and the truncation note placed second. The source URL is minor extra provenance, but it is a single short clause that 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 two-parameter tool with full schema coverage, an output schema, and safety annotations, this description covers the essentials. The only unstated edge cases are behaviors like choose exceeding the item count, which the schema bounds and mathematical definition make largely predictable.

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 items and choose already documented in the schema itself. The description adds only a modest explicit link between 'r' and the choose parameter and 'list' and items, but it does not carry 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 names a specific verb ('List') and resource ('every way to choose r items from a list'), and clarifies the combinatorics semantics with 'ignoring order (combinations)'. This clearly distinguishes it from the many sibling generator tools and other list-processing 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 use case is clear from the first sentence: use this whenever you need to enumerate all order-insensitive selections of r items. It does not name alternatives or state when not to use it, though no sibling tool competes for the same task (e.g., random_team_generator selects a random subset, not all combinations).

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 the safety profile is covered. The description adds valuable behavioral detail beyond annotations: compounding frequency (monthly) and contribution timing (end of month), plus return values and currency. No contradictions.

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

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

Three sentences with no wasted words. Purpose is front-loaded, return values are stated, units and rate basis are given, and a source link is included. Exceptionally concise and well-structured.

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

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

For a calculator with an output schema (not shown but indicated), the description adequately covers inputs, calculation method, and outputs. It lacks details on edge cases or default behavior nuances, but the combination of annotations, schema, and output schema leave little uncovered. The description is complete for an agent to call 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?

With 100% schema coverage, the schema already documents all parameters. The description adds meaning beyond the schema by clarifying the compounding frequency (monthly) and that contributions are added at month-end, which is not in the schema. It also reinforces that amounts are in GBP and rate is annual percentage.

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

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

The description clearly states the tool's purpose with a specific verb ('Project savings growth') and resource ('starting deposit plus a regular monthly contribution'), and details the compounding method. It also lists what it returns (final balance, total paid in, interest earned), making it distinct from sibling savings tools like hopi_savings_goal_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?

It conveys clear usage context: projecting savings with monthly contributions compounded monthly. However, it does not explicitly mention when to use this over alternatives or any exclusions, though the unique combination of features implicitly differentiates it from other financial calculators.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds context beyond these by specifying the output details (AA/AAA for normal and large text) and citing an external source URL, implying a network-backed calculation. 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?

Two tight sentences: the first front-loads the action, inputs, and output criteria; the second is a brief source citation. No redundant phrasing 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 two-parameter calculator, the description is complete: it defines the computation, the input format, the pass/fail reporting (AA/AAA, normal/large text), and even links a reference. The output schema is also available, so the agent has all necessary information to select and invoke the tool correctly.

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

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

The schema covers both parameters fully with descriptions ('Background colour as a six-digit hex code', 'Text colour as a six-digit hex code'). The description merely restates that inputs are hex codes, adding no new semantic detail beyond the schema, so the baseline of 3 is appropriate.

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

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

The description names a specific action ('Work out the WCAG contrast ratio') with a clear resource (foreground text vs background colour, both hex codes) and states the output (pass/fail for AA and AAA for normal and large text). This is distinct from sibling colour tools like hopi_hex_to_rgb or hopi_colour_name_finder, which address different tasks.

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 usage context: it's for WCAG contrast checking with specific input types. However, it does not explicitly name alternatives or state when NOT to use it, though the accessibility focus implicitly separates it from conversion/generation 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 establish that the tool is read-only, idempotent, and non-destructive. The description adds useful behavioral context by specifying accepted input forms: stars, steps, ranges, lists, month/day names, and shortcuts such as @daily and @hourly. Error handling and edge-case behavior are not mentioned, but the output schema and safety annotations lower the burden.

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 purpose in the first sentence. The second sentence adds useful supported-syntax detail, and the source URL is a minor extra that is not fully necessary but does not create significant noise.

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, read-only tool with a full output schema and strong annotations, the description is complete enough. It states the exact input format, the supported cron features, the shortcut extensions, and the transformation being performed, so an agent has sufficient information to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already documents the single 'expression' parameter and provides an example. The description adds some breadth about accepted cron syntax, but most of that is either implied by or consistent with the schema, so it does not substantially exceed the schema baseline.

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

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

The description uses a specific verb and resource: 'Translate a standard five-field cron expression ... into plain English.' It also names the supported syntax features and shortcuts, making it easy for an agent to distinguish this tool from the many unrelated hopi utilities.

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 cron expression needs to be converted into readable English. It does not explicitly mention alternatives or exclusions, but no sibling tool appears to offer the same function, so the lack of explicit routing is a minor gap.

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 this read-only, idempotent, and non-destructive. The description adds valuable behavioral detail beyond annotations: breakeven is always returned, profit/return percentage/total fees appear only when a sell price is provided, and all figures are in GBP. This gives the agent a clear model of output behavior 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 tight sentences with no filler. It front-loads the core action, then explains conditional outputs and currency, and ends with a source reference. Every sentence contributes useful information.

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

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

For a calculator tool with two required and two optional parameters, the description covers inputs, the optional-dependent output behavior, currency, and source. An output schema exists to describe return values in more detail, 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?

Schema coverage is 100%, so parameters are already documented. The description adds useful extra semantics: the fee is 'per-side,' sell price is optional and controls which outputs appear, and currency is GBP. These nuances go beyond the schema's basic field descriptions.

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

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

The description clearly states the specific operation—'work out profit or loss on a crypto trade'—and identifies the exact inputs: buy price, quantity, and optional per-side fee. This distinguishes it from the many other calculator-type sibling tools by focusing on trade P&L rather than position sizing, staking, or DCA.

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: whenever a crypto trade profit/loss needs calculating, with optional sell price for full results and omission for breakeven only. It does not explicitly name alternatives or state when not to use it, but the purpose is specific enough that an agent can route correctly among the large sibling set.

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

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

With annotations already declaring readOnly, idempotent, and non-destructive behaviour, the description adds that the tool returns 'the gradient value and a full background declaration,' which is useful beyond the structured metadata. It does not discuss edge cases, but the annotations cover the safety profile.

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

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

At about 40 words, the description is front-loaded with the result, states options in the second sentence, and gives output/source context in the third. Every sentence contributes.

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 generator with a fully documented schema, an output schema, and clear annotations, the description plus structured metadata covers what the tool does, its inputs, its output, and its safe read-only nature. No essential selection or invocation 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%, so the parameter schemas already carry the meaning; the description adds only a slight reinforcement ('two colours', 'angle in degrees', linear/radial). This meets the high-coverage baseline but does not meaningfully augment parameter details.

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

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

The description states a specific action ('Build a ready-to-use CSS gradient from two colours') and names the two supported forms ('linear gradient with an angle in degrees, or a radial gradient'), which is enough to distinguish it from the many colour-related sibling tools.

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

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

It gives clear context: use when you need a ready-to-use CSS gradient from two colours, with explicit choice between linear and radial. It does not explicitly name alternatives or state when not to use it, so it stops one short of a full routing explanation.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, non-destructive), the description discloses exactly what gets modified (comments, whitespace), what is preserved (quoted strings, calc() spaces), and what the response includes (minified CSS plus before/after byte sizes). This gives the agent full visibility into how the transformation behaves and what to expect.

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. The first sentence gets straight to the action and core behavior, the second covers return value and a source reference. No filler or repetition; every sentence earns its place.

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

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

For a simple single-parameter, read-only, idempotent tool with an output schema available, the description covers what the tool does, what it preserves, what it returns, and even cites the algorithm source. An agent has all the information needed 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?

The input schema has 100% coverage with a clear description for the only parameter, 'css' ('The CSS source to minify'). The tool description adds no additional parameter-specific meaning beyond what the schema already provides, so the baseline of 3 applies.

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

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

The first sentence names the exact action ('Minify CSS') and the resource ('CSS'), and even details the transformation rules (removing comments/whitespace, preserving quoted strings and calc() spaces). This clearly distinguishes it from sibling formatting/minification tools like HTML escape, JSON formatter, or simple whitespace removers.

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: use this when you need to minify CSS. It doesn't name alternatives or explicit when-not-to-use conditions, but given the sibling list contains no other CSS minifier and the name/title align, this is clear context without needing exclusions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context: it follows standard CSV quoting rules, handles embedded commas/quotes/line breaks, and explains the header behavior. It also cites the source, which is a nice transparency touch. It doesn't mention error handling for malformed CSV, but that's a minor gap given the annotations.

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

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

Two sentences with no fluff. The core action and output are front-loaded, followed by the key behavioral details (quoting rules, header modes) and a source citation. Every sentence earns its place.

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

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

The tool is simple (2 params, 1 required) and has a rich schema plus an output schema. The description covers the conversion behavior, quoting rules, and header modes. It doesn't explicitly describe the return value shape, but the output schema exists and the description says 'JSON array', which is sufficient. A minor gap is the lack of mention of error handling for invalid CSV, but overall it's complete enough for an agent to call 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 ('csv' and 'firstRowHeaders'). The description adds a bit of context by explaining the header behavior in prose, but it largely mirrors the schema. Baseline 3 is appropriate because the schema does the heavy lifting and the description doesn't add significant new meaning beyond what's already in the schema.

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

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

The description states a specific verb ('Convert'), a clear resource ('CSV text'), and the output ('a JSON array'). It also distinguishes the two modes (headers on/off) and references standard CSV quoting rules, making the tool's purpose unambiguous. The sibling list includes hopi_json_to_csv, and this description clearly identifies the direction of conversion, so an agent can tell them apart.

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 the two header modes and the quoting rules, which tells an agent when the tool is appropriate for CSV parsing. It does not explicitly name alternatives or state when not to use it, but the context of a large sibling list of converters makes the purpose clear enough. A small gap: no mention of edge cases like empty input or malformed CSV, but the schema's minLength covers empty input.

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, non-destructive behavior, so the description only needs to add extra context. It does so by warning that the conversion is approximate and by citing the source of the conversion values.

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 core behavior is stated in the first clause, followed by a compact ingredient legend and a source URL. No sentence is wasted.

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, simple read-only conversion with a full input and output schema, nothing essential is missing: accepted ingredients are enumerated, the approximation caveat is present, and a source is provided 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 coverage is 100%, so the baseline is 3; the description adds value by expanding the terse enum literals into full ingredient names and clarifying special cases such as 'packed brown sugar' and 'uncooked rice'. The cups parameter's meaning is already clear from the schema.

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

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

The description uses a specific verb ('Convert'), resource ('US cups of a common baking ingredient to grams'), and qualifies the result as approximate. Listing exact ingredient keys distinguishes it from generic volume/weight 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 phrase 'common baking ingredient' implies the intended use case, but the description never explicitly says when to choose this tool over sibling converters or when not to use it. Usage guidance is left to inference rather than 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 and idempotentHint=true, so the description need not repeat that. It adds valuable context about rate freshness (updated hourly) and coverage (150+ currencies), plus a source URL, giving the agent insight into data reliability. 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?

Two sentences, zero filler. The first sentence front-loads the core purpose and key data properties; the second gives code examples and a source link. Every word earns its place, and the structure is immediately scannable.

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: three parameters, all documented in the schema, with an output schema present. Annotations cover safety. The description adds the only missing piece—rate source and update frequency—so an agent has everything needed to invoke it correctly. No gaps.

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

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

Schema coverage is 100% with descriptions for all three parameters. The description adds ISO 4217 code examples (GBP, EUR, USD, JPY) which reinforce the pattern and clarify expected input format, going slightly beyond the schema. This added guidance helps an agent construct valid calls.

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 money between currencies using live mid-market rates, with a specific verb ('Convert') and resource ('currency'). It distinguishes itself from sibling converters (e.g., area, angle) by explicitly mentioning currency and ISO 4217 codes, leaving no ambiguity about its purpose.

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

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

While the description doesn't explicitly state 'use this for currency conversion only', the naming and content make it obvious. It gives clear context (live rates, 150+ currencies) but does not mention alternative tools or exclusions. For a single-purpose converter among many unrelated converters, this is sufficient.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds behavioral nuance about decimal vs binary conversion and the real-world rationale (storage sold vs Windows), which goes beyond the schema. It doesn't 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 concise sentences plus a source link. The main purpose is front-loaded, the units are listed, and the binary/decimal explanation is compact and directly relevant. No filler or redundancy.

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

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

For a simple converter with a fully described schema, an output schema, and annotations covering safety and idempotency, the description is complete. It explains the units, the decimal/binary distinction, and provides a source, leaving no ambiguity 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 all parameters are documented. The description enriches the binary parameter by explaining 'as storage is sold' and 'as Windows reports drive sizes', giving practical meaning beyond the schema's technical description. This adds value without redundancy.

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

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

The description clearly states the verb 'convert' and the specific resource 'digital storage size between units', listing the exact units (B, KB, MB, GB, TB). This distinguishes it from other converter tools like length or weight converters, and the mention of decimal vs binary adds further specificity.

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

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

The description provides clear usage context by explaining when to use decimal (storage as sold) vs binary (Windows drive sizes), which is critical for correct conversion. It doesn't explicitly name alternatives, but the units and context make it obvious this is for digital storage, not other measurements.

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 that the tool is read-only, idempotent, and non-destructive. The description adds genuine behavioral detail beyond those hints: months and years are clamped to the last day of the target month, and dates use YYYY-MM-DD. This is valuable edge-case disclosure for a simple pure calculator.

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 well-structured: the operation and units are front-loaded, the format and edge-case behavior follow, and the source URL is harmlessly placed at the end. 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 deterministic date arithmetic tool, the description covers the operation, the accepted units, the expected date format, the key edge case (clamping), and the return value. The schema covers all parameters and the output schema covers the result, so nothing needed to invoke this tool 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?

The input schema already documents all parameters with descriptions and enums, so the baseline is 3. The description adds meaning beyond the schema by explaining the clamping behavior for months and years, which affects how the 'unit' parameter behaves. This justifies one step above baseline.

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

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

The description states a specific operation ('Add or subtract') on a specific resource ('a date') with exact units (days, weeks, months, years) and notes the return value. This is clearly distinguishable from siblings like hopi_add_working_days or hopi_days_between_dates.

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 opening phrase gives the agent a precise selection condition: shift a calendar date by units of time. The unit list also implicitly excludes working-day-specific tools. However, no explicit alternative or when-not-to-use guidance is provided, so it falls just short of a 5.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds value by disclosing the extra behavior—reporting the weekday for the same day/month in the current year—which is not inferable from the name or schema. This goes beyond annotations, though it could mention edge cases or output format, hence not a 5.

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

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

Three sentences with zero fluff. The primary purpose is front-loaded, the format constraint is stated next, and the extra behavior follows. The source URL is a minor addition but useful for provenance. Every sentence earns its place; no redundancy with annotations or schema.

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

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

For a simple one-parameter read-only tool with an output schema (indicated by 'Has output schema: true') and annotations covering safety, the description is complete. It explains the main operation, the date format, and the auxiliary current-year lookup. 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%, with the parameter 'date' fully documented with type, format, and a matching description. The description merely repeats the YYYY-MM-DD format already present in the schema, adding no new semantic meaning. Baseline 3 is appropriate since 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 opens with a specific verb-resource pair ('Find which day of the week a given date falls on'), making the core purpose unmistakable. The date format and extra behavior (current-year weekday) add specificity, and the tool name itself differentiates it from date-related siblings like hopi_date_calculator and hopi_week_number.

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 clear: when you need the weekday of a specific date. It does not explicitly exclude alternatives or name sibling tools, but the focused phrasing ('day of the week') implies this tool is for exactly that. Lacks an explicit 'when not to use' clause, but the context 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?

Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable context by noting the amounts are gross in GBP before tax, and that output includes yearly, monthly, and weekly figures, which is 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?

The description is a single, well-structured paragraph that front-loads the core purpose and immediately follows with the two modes and key defaults. It is concise, with no wasted words, and every sentence contributes to understanding how to use the tool.

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

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

The tool is a simple calculator with clear schema and annotations. The description covers the essential operational aspects: purpose, modes, default working days, output types, currency, and tax treatment. Since an output schema exists, return values are already specified elsewhere. Nothing critical for an agent 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 every parameter (mode, salary, dayRate, workingDays) is documented in the schema. The description adds value by explaining the default workingDays (220) and the nature of the output (yearly, monthly, weekly figures), which is not in the schema. This enriches the meaning of the parameters beyond the schema definitions.

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