Microapp

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

Annotations declare the tool as read-only, idempotent, and non-destructive, which is reinforced by the description's 'Returns...' phrasing. The description goes beyond annotations by detailing the computed outputs (Wald confidence interval, absolute/relative lift, z statistic, two-tailed p-value, significance decision), giving useful insight into its behavior.

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

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

The description is a single, information-dense sentence that efficiently conveys the calculation purpose, the full list of outputs, and the default significance level. No unnecessary words or repetition.

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

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

Given the presence of a full output schema and a complete input schema, the description adequately covers the tool's purpose, inputs, and outputs. It also notes the default alpha and the two-tailed nature of the test, providing sufficient context for an AI agent to use the tool correctly.

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

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

The input schema provides exhaustive descriptions for all five parameters, including constraints and defaults, achieving 100% coverage. The description only mentions the default alpha (0.05) without adding further parameter semantics, so it provides minimal value beyond what the schema already offers.

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 as a two-proportion z-test for A/B conversion-rate experiments, which is a specific statistical procedure. It also lists the exact outputs (rates, confidence interval, lift, z statistic, p-value, significance decision), making it easy to distinguish from sibling tools like ab-test-sample-size.

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 indicates the tool is for analyzing A/B conversion-rate experiments, which implies its primary use case. It does not explicitly mention when to use an alternative like ab-test-sample-size, but the context is sufficient for an agent to infer the right scenario.

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

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

Annotations already declare readOnlyHint and idempotentHint true, so the description adds value by specifying the statistical assumptions: two-tailed alpha default of 0.05 and power default of 0.80. 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 well-structured sentence that front-loads the result and lists inputs efficiently; no filler.

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

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

For a read-only calculator with a rich schema and an output schema, the description provides all necessary context: purpose, key inputs, defaults, and statistical framing. No additional details are needed.

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

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

Schema description coverage is 100% and the description essentially recounts each parameter's meaning from the schema (baseline rate, relative lift, alpha, power). The description adds no parameter-level detail beyond the schema, so a baseline of 3 is warranted.

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 the tool computes the required sample size per arm for a two-proportion A/B test, naming all key inputs. This specific verb+resource clearly differentiates it from sibling calculators.

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

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

The description establishes clear context: it is for two-proportion A/B test sample-size calculations, with default alpha and power. It does not explicitly name alternatives or when-not-to-use, but the intended use 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 declare readOnly, idempotent, and non-destructive. The description adds specific calculation details—sidereal orbital periods from NASA and Julian year for Earth—which helps the agent understand the data source and calibration. This is valuable beyond annotations, so a 4.

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

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

Two concise sentences deliver the core functionality and calculation basis without unnecessary words. Front-loaded with the operation.

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 simple conversion, full schema coverage, a read-only annotation, and an output schema, the description suffices. It covers the essential context (source and Earth year definition) without needing to explain return values.

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

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

The input schema has 100% coverage for the single parameter, describing bounds and data type. The description reiterates that age is in Earth days but adds no new parameter-specific details. 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 an Earth-day age to planetary years using a specific verb ('return') and resource (eight planets plus Pluto). It distinguishes from the sibling 'weight-on-other-planets' by focusing on age rather than weight.

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 implicitly defines the use case: converting an age in Earth days to planetary ages. It does not explicitly name alternatives or exclusions, but the input-output relationship is unambiguous, and among siblings only this tool handles age conversion. A score of 4 reflects clear context without explicit alternative guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the tool's safety profile. The description adds no further behavioral context such as return format, precision, or edge-case handling; it only restates the purpose, providing no additional transparency 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 a single sentence that lists the action and supported units. Every word is informative, with no filler or repetition, and it is appropriately front-loaded.

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

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

The tool is a simple converter with complete schema documentation and an output schema. The description plus annotations and schema fully cover what an agent needs to invoke it correctly, so no additional context is required.

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 clear descriptions for value, from, and to, including enums for source and target units. The description adds no parameter-specific semantics, so the baseline of 3 applies.

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

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

The description clearly states the tool converts between angle units and enumerates the supported units (degree, radian, gradian, turn), which distinguishes it from sibling converters like length-converter or temperature-converter. The verb 'convert' and resource 'angle units' are specific and unambiguous.

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

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

The description implicitly defines when to use this tool by naming angle units as the conversion domain, making the context clear. It does not explicitly provide exclusions or alternatives, but given the sibling tool names, the intended use is obvious.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false. The description adds useful behavioral context by defining the principal value range (-90°, 90°) / (-π/2, π/2) and the inverse relationship tan(θ) = x, which explains what the result represents. It doesn't detail output formatting but is sufficient for a read-only 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 two tight sentences with no filler. It front-loads the core purpose, follows with the mathematical definition and range, and ends with a clear pointer to an alternative. 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 calculator tool with strong annotations and no output schema, the description sufficiently explains what the result is (an angle), the possible unit options, the principal value constraint, and the key alternative. No critical context is missing for an agent to correctly select and invoke the tool.

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

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

Schema description coverage is 100%, and the schema already fully describes both parameters, including domain and defaults. The description adds minimal new parameter meaning beyond what is in the schema (e.g., 'any real number' is already in the x description), so it does not elevate above 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 states a specific verb ('Compute') and resource ('arctan(x)'), clearly identifies the mathematical function (inverse tangent), and notes the degrees/radians options. It also differentiates from two-argument arctan by explicitly naming atan2, which distinguishes it from related tools.

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

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

The description gives clear guidance on when to use this single-argument arctan tool versus atan2, including an explicit exclusion: 'For two-argument arctan that resolves the full circle, use atan2 instead.' This is a strong when-not/alternative statement.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, which adequately cover the safety profile. The description adds the unit list but no additional behavioral context such as rounding, precision, or error handling, so it provides only baseline value.

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

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

A single, focused sentence that front-loads the action and resource, followed by a concise enumeration of supported units. No wasted words or redundant information.

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

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

For a simple unit conversion tool, the description together with the rich schema and annotations provides all necessary context. The output schema exists to cover return values, so no further explanation is needed.

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

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

The input schema provides full descriptions for all three parameters (value, from, to) with 100% coverage. The tool description only repeats the unit list already present in the enum values, offering no additional 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 clearly states a specific action ('Convert') on a specific resource ('area units') and enumerates all supported units. This distinguishes it from sibling converters for length, volume, etc.

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

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

The description gives clear context for when to use this tool—when an area conversion is needed—without explicitly stating alternatives. The sibling tool names make the alternative obvious, but no direct exclusion is mentioned, so it stops 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 the behavioral detail that it computes both a simplified ratio and a decimal ratio, going beyond the static annotations. No contradiction exists.

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

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

The description is two sentences long, front-loads the core function in the first sentence, and adds relevant usage context in the second. Every word earns its place with no redundancy or unnecessary detail.

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

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

For a simple calculator tool with an output schema (indicated by 'Has output schema: true'), the description fully covers purpose and usage context. Annotations and schema handle safety and parameter constraints, so nothing important is missing.

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

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

Schema description coverage is 100%, with both width and height having clear descriptions (e.g., 'Width in any unit' and 'Height in same unit as width'). The description itself adds little beyond the schema, only referring to a 'pair,' which is already evident from the schema's required fields. This meets the baseline for high schema coverage.

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

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

The description uses a specific verb ('Compute') and resource ('width × height pair'), clearly distinguishing this tool from the many sibling calculator tools. It also specifies the two outputs (simplified ratio and decimal ratio), 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?

The description provides clear context for when to use the tool ('image, video, screen, and design contexts') but does not explicitly mention when not to use it or name alternative tools. It lacks exclusions but is still useful for selecting the tool in relevant scenarios.

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 read-only, idempotent, and non-destructive. The description adds value by specifying exactly which statistics are computed and noting the possibility of multiple modes with 'mode(s)', which is a useful behavioral nuance 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 a single, well-structured sentence that front-loads the verb and resource, then enumerates the outputs without any redundant text. Every word earns its place.

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

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

For a simple single-parameter calculator with a full schema description and an output schema present, the description is complete enough. It covers all computed statistics, and schema constraints (minItems=1) handle edge cases.

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

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

The input schema fully describes the only parameter ('numbers') with a clear description and constraints. The tool description does not add additional parameter-specific semantics, so a baseline score of 3 is appropriate given 100% schema coverage.

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

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

The description uses a specific verb ('Compute') and names a clear resource ('summary statistics for a list of numbers') with an explicit list of statistics. This distinguishes it from sibling tools like geometric-mean and percentage-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 purpose is self-evident, but the description offers no explicit guidance on when to use this tool versus alternatives, nor any exclusions. Usage is only implied by the stated statistics.

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 specifying 'UTF-8 safe' and the exact role of each mode, going beyond what annotations provide.

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

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

Two sentences, front-loaded with the core purpose, followed by mode usage and a safety note. Every word earns its place; no fluff or redundancy.

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

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

The tool is simple, an output schema exists for return values, and the description covers purpose, mode selection, and encoding safety. It doesn't mention error handling for invalid base64, but for a straightforward converter, the description is adequately complete.

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

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

Schema description coverage is 100%, with both parameters already documented in the input schema. The description reaffirms the mode semantics but adds little beyond the schema's own descriptions, so baseline 3 is appropriate.

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

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

The description clearly states the tool encodes plain text to base64 and decodes base64 back to text, with a clear verb-resource relationship. It distinguishes from sibling tools by being the only base64 utility, and the mode parameter explicitly differentiates the two directions.

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 operating instructions (use mode='encode' or 'decode'), which provides clear usage context. It doesn't explicitly mention alternatives or when not to use, but given the tool's unique purpose, the guidance is sufficient.

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

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

Annotations already disclose read-only, idempotent, non-destructive behavior. The description adds meaningful context beyond that: it explains the output includes decimal, hex, binary, octal, and a low-32-bit binary representation, and that operands are BigInts. No contradictions with annotations.

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

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

A single, front-loaded sentence that lists operations and output formats without redundancy. Every piece of information earns its place, and the structure makes the core purpose immediately clear.

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 straightforward calculator with a moderate parameter set and an output schema. The description covers the operational scope and output formats, while the schema supplies parameter details and the annotations cover safety. No significant missing context.

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

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

Schema description coverage is 100%, with each parameter well-documented (formats, required conditions, shift semantics). The description itself adds little parameter-level detail beyond restating that operands are BigInts, which is already implied by the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool runs bitwise operations (AND, OR, XOR, NOT, shifts) on two BigInt operands and returns results in multiple bases plus a low-32-bit binary representation. The verb+resource are specific, and the operation list distinguishes it from other calculator tools.

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

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

The description provides clear context for use: when a bitwise operation on arbitrary-precision integers is needed. It does not explicitly name alternatives or exclusions, but no sibling tool offers overlapping functionality, so the intended use 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the calculation formula and the definition of a board foot, which meaningfully explains behavior beyond annotations. It does not detail output rounding, but for a simple calculator this is minor.

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 exactly two sentences with no filler. The first states the purpose, the second provides the formula and unit definition. Every word serves a purpose.

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

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

For a straightforward calculator with fully documented parameters and comprehensive annotations, this description is complete. It provides the formula, definition, and context. The lack of an output schema is acceptable since the computed result is self-explanatory.

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

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

Input schema has 100% parameter description coverage, so the baseline is 3. The description adds value by tying parameters together in the formula and defining a board foot, reinforcing the role of thickness, width, length, and qty. This elevates it above 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 opens with a specific verb and resource: 'Compute board feet for lumber.' It immediately states the tool's purpose and is clearly distinct from sibling calculators like area or length converters. The inclusion of the formula further cements the purpose.

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

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

The description provides clear context that this tool is for lumber board foot calculations. While it does not explicitly mention alternatives, the specialized nature makes the intended use evident. Sibling tools do not overlap with this function, so no exclusions are needed.

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

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

Annotations already declare readOnly, idempotent, and non-destructive hints. The description adds the 'copy-ready CSS string' output trait and explains the layer structure, which provides useful behavioral context beyond the annotations. No contradiction with annotations.

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

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

The description is two sentences with front-loaded purpose, then parameter details, then output format. Every word earns its place; there is zero waste and no redundancy with the 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?

With only one required parameter, a detailed schema, an output schema present, and annotations providing the safety profile, the description is fully sufficient. The output format is explicitly stated, so an agent can correctly invoke the tool without additional context.

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 100% of parameters with detailed descriptions for each field (offset, blur, spread, color, inset). The description only lists the field names without adding new meaning, so the baseline score of 3 is appropriate as the schema already provides full parameter semantics.

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 ('Build') and names the exact resource ('CSS box-shadow declaration'), clearly distinguishing it from sibling tools like color-converter or hex-to-rgb. It also specifies the scope ('one or more shadow layers'), leaving no ambiguity about its 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 clearly implies the use case (generating box-shadow CSS from layers), which is obvious from the context. However, it does not explicitly state when not to use this tool or name alternative tools. Since no sibling tool overlaps, this is acceptable but lacks explicit exclusion guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety and side-effect profile is established. The description adds behavioral context beyond these annotations by specifying the outputs (gross burn, net burn, runway) and the unique 'health label' benchmarked to SaaS funding-stage expectations. 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 two sentences with no filler. The first sentence front-loads the core purpose and inputs, while the second adds the unique health-label output. Every word earns its place, making it highly concise and well-structured.

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

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

The tool is a straightforward calculator with four simple numeric parameters, all fully documented in the schema. Annotations provide safety context, and an output schema exists (as stated in context signals), so the description need not explain return values. The description adds the health-label benchmark, ensuring complete context for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 100% with each parameter already explained in detail (e.g., starting_cash: 'Cash on hand at the start of the period, in dollars. Use the bank balance plus any short-term equivalents.'). The description adds no additional parameter-level meaning, but this is acceptable because the schema carries the full burden. Baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Compute a startup's gross burn, net burn, and runway from starting cash, ending cash, the period in months, and optional monthly revenue.' This includes a specific verb ('Compute'), a resource ('startup's gross burn, net burn, and runway'), and enumerates the inputs, which distinguishes it from all sibling calculator tools. The additional mention of a 'health label benchmarked to standard SaaS funding-stage runway expectations' further differentiates it.

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

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

The description implies when to use the tool by listing the required parameters (starting cash, ending cash, period months) and optional monthly revenue, giving the agent clear contextual cues about the data needed. However, it does not explicitly mention alternatives or when not to use it. The schema provides additional usage guidance for the period_months parameter (e.g., 'Use 1 for last month, 3 for a quarter, 12 for the trailing year').

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 this as read-only, non-destructive, and idempotent, so the bar is lower. The description simply restates the operation without adding behavior details such as edge-case handling or output confirmation, though none are necessary given the output schema.

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

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

The description is two short clauses, front-loading the primary action and listing the four case formats. No filler 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 2-parameter text transformation with full schema coverage, an output schema, and annotations indicating safety, the description plus structured data provide sufficient context. No major 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 descriptions cover both parameters fully (100% coverage), including the enum meanings for case. The description repeats the case options but adds no new semantic information beyond the schema.

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

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

The description uses a specific verb 'change' and identifies the resource 'case of text,' listing four specific case types. This clearly distinguishes it from sibling text tools like reverse-text or dedup-lines.

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

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

No explicit when-to-use guidance or alternatives are mentioned. The intended usage is implied by the tool's name and purpose, but there is no discussion of when to choose this over other text manipulation tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds valuable behavioral context by stating it returns separate counts and highlights the 'without guessing' aspect, which informs the agent about the tool's output style and reliability.

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-loaded with the main action and results, followed by concrete, useful examples. Every word earns its place without unnecessary filler or repetition of schema details.

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

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

For a simple single-parameter tool with strong annotations and an output schema, the description fully covers purpose, behavior, and use cases. It provides enough context for an agent to select and invoke this tool correctly without ambiguity.

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 is fully self-descriptive with 100% coverage: the single parameter 'text' is documented with its type and maxLength. The description adds no additional parameter-level detail beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb and resource: 'Count characters in text, with and without spaces.' It clearly distinguishes itself from sibling tools like word-counter and vowel-counter by emphasizing the two distinct outputs (with/without spaces) and the use case for character-limit checks.

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, such as checking if text fits in a tweet (280 chars) or SMS (160 chars). It does not explicitly mention when not to use it or name alternatives, but the examples make the intended usage highly apparent.

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 the input mode flexibility and the full list of computed values, but it does not discuss error behavior or edge cases beyond what schema param descriptions already cover. This is slightly above baseline 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?

One well-structured sentence that front-loads the action and input, then enumerates the outputs. No filler.

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

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

The tool is simple and stateless; annotations declare it read-only, and an output schema exists to document return values. The description covers the dual input modes and the scope of calculations. It is sufficiently complete for this calculator, though it doesn't explicitly restate validation rules that are already in the schema.

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

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

Schema description coverage is 100%, so the schema documents all three parameters. The tool description clarifies the relationship between parameters (cidr OR ip+mask) and enumerates the output fields, adding some semantic context but not significantly beyond the schema.

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

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

The description uses the specific verb 'Parse' and names the resource (IPv4 CIDR block or IP + dotted-decimal mask), then lists the computed outputs. It clearly distinguishes this from sibling calculators, which cover unrelated domains.

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

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

The description specifies the two accepted input forms (CIDR or IP+mask) and implicitly states when to use the tool—whenever network calculations on IPv4 blocks are needed. No alternative tool exists among siblings, so no explicit exclusions are needed. Clarity is high, but it stops short of giving explicit when-not guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the description adds complementary detail: it is a pure calculation returning three specific values (total spent, invested future value, opportunity-cost gap). The 'not to moralize' note clarifies tone, but no mention of compounding frequency or nominal/real assumptions, though these are not required 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?

Three sentences, each earning its place: first defines the comparison, second lists outputs, third gives intent. No redundant phrasing or restating of the tool name.

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

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

With an output schema present and annotations covering safety, the description fully covers purpose, calculation logic, and return contents. The tool is simple enough that no further detail about return structure or side effects is needed; nothing is missing.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters. The description adds value by giving the calculation formula ('drink price × times per week × years') and clarifying that the alternative investment is 'at a given annual return,' which maps directly to annual_return_percent without repeating 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 a specific comparative verb ('Compare') and resource ('total nominal cost of a recurring coffee habit' vs. invested value), making the tool's purpose unmistakable. It also distinguishes itself from the sibling tool coffee-ratio-calculator by focusing on opportunity cost rather than brewing ratios.

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 (whenever the user wants to see the opportunity cost of coffee spending vs. investing) and adds context ('make compounding visible, not to moralize'). It does not explicitly list alternatives or exclusions, but the scope is clear enough for an AI to select it among sibling calculator tools.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds that the tool returns recommended grind and brew time beyond the computed variable, and clarifies the OR relationship between coffee and water inputs. 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, front-loaded with the action verb and resource, listing methods and succinctly describing input/output. 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?

With a well-documented schema, an output schema present, and low complexity, the description covers the primary workflow and additional outputs. It omits mention of ratio override, but that is already in the schema, so the description is sufficiently complete.

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

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

Schema coverage is 100% with detailed descriptions for all five parameters. The description summarizes the core relationship ('enter coffee grams OR water ml') but adds little beyond what the schema already specifies, so the baseline 3 applies.

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

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

The description uses the specific verb 'Compute' and targets a clear resource: coffee-to-water ratio for popular brew methods. It lists the methods and clarifies it returns the complementary variable plus grind and brew time, distinguishing it from sibling tools like coffee-habit-cost-calculator and recipe-scaler.

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: use this tool to compute the ratio for a chosen brew method, entering either coffee grams or water ml. It implies the use case but does not explicitly name alternatives or exclude cases, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, establishing safety. The description adds the useful behavioral trait of auto-detecting the input format, but does not disclose output shape, invalid input handling, or edge cases. It adds some value beyond annotations but remains minimal.

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, information-dense sentences. The first states the core purpose, the second explains a key behavior (auto-detection). No filler or redundancy.

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

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

Given the strong annotations and complete schema, the description is largely sufficient. The only minor gap is ambiguity about whether the output returns all representations or a specific one, but the output schema (not shown) likely resolves this. The description could also mention invalid input behavior, but it is 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?

Schema description coverage is 100%, so the baseline is 3. The tool description does not add parameter information, but the schema's parameter description thoroughly lists accepted input formats. No additional compensation is needed.

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

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

The description states a specific action ('Convert') on a clear resource (color) and enumerates the supported representations (hex, RGB, HSL, HSV). It distinguishes itself from the sibling 'hex-to-rgb' tool by covering more formats, and the auto-detection note reinforces 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?

The description implies when to use it (when color conversion across these formats is needed) but does not explicitly mention alternatives or when not to use it. It does not reference the overlapping sibling tool 'hex-to-rgb', leaving the choice to the agent's inference.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the tool is known to be safe and deterministic. The description adds valuable behavioral detail about the generated output: it persists via localStorage and dispatches a cookieconsentchange CustomEvent, which informs integration assumptions. No contradictions with annotations.

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

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

The description is two sentences: the first states the core purpose, the second lists inputs and output behavior. It is front-loaded with the verb, and every clause adds relevant information. No redundant or filler 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 tool with 8 parameters, nested objects, and an output schema, this description is complete: it covers the purpose, input categories, output behavior (persistence, event dispatch), and signals it is a self-contained snippet. The output schema handles return-value details, so no additional explanation is needed.

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

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

Schema description coverage is 100%, so the schema already documents every parameter with detailed descriptions (position enum, style enum defaults, button labels, etc.). The description summarizes the inputs but adds no new semantic meaning; it simply restates what the schema provides. Baseline of 3 is appropriate.

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

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

The description opens with a specific verb+resource: 'Generate a copy-pasteable HTML+CSS+JS cookie consent banner.' This clearly states what the tool does, distinguishes it from sibling generators (box-shadow, passphrase, etc.), and includes the output format (HTML+CSS+JS) which is a key differentiator.

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 clear: the tool produces a cookie consent banner, and the input/output description clarifies its scope. However, there is no explicit 'when not to use' or mention of alternatives, though the purpose is self-evident in a generator-heavy sibling list.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, lowering the burden. The description adds value by explaining the tool's non-mutating actions (parse, describe, compute) and specifying the 5-field constraint. No contradictions with annotations exist.

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 only two sentences and is entirely front-loaded with the core actions. It includes a relevant example without any redundant words or filler, making every sentence earn its place.

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

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

Given the rich input schema, annotations, and the presence of an output schema, the description is complete. It covers the input format, the computation behavior, and an example, leaving no significant gaps for an agent to understand and invoke the tool correctly.

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

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

The schema covers all three parameters with detailed descriptions (100% coverage), so the baseline is 3. The description's example adds a concrete illustration but does not provide additional semantic depth beyond what the schema already states for fromIso and nextCount.

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: 'Parse a 5-field cron expression, describe it in plain English, and compute the next N fire times.' It precisely identifies the resource (cron expression) and the actions (parse, describe, compute), making it distinct from sibling tools like calculators and converters.

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 by specifying the exact input format and an example: "Input the standard 'minute hour day-of-month month day-of-week' form (e.g. '0 9 * * 1-5' for weekdays at 9am)." It does not explicitly mention when not to use the tool or name alternatives, but no close siblings exist, so the guidance is sufficient.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds the key behavioral trait of using binary (1024-based) sizing, but this is also repeated in the parameter schema description for 'from'. No contradictions exist, and no additional operational details are needed given the simple nature of the tool.

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

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

The description is two sentences, front-loaded with the verb and resource, and includes the essential detail about binary sizing. Every word earns its place with no waste, making it extremely 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?

Given the simplicity of the converter, the tool description combined with the rich input schema (with enums and descriptions) and output schema provides complete context. The description clarifies the unit set and conversion base, which is sufficient for an agent to use the tool correctly.

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

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

Schema description coverage is 100%, with each parameter (value, from, to) having a clear description. The tool description adds no additional parameter semantics beyond the schema, so the baseline of 3 applies.

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

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

The description clearly identifies the tool as a storage unit converter with the specific verb 'Convert', names the exact units (bit, byte, kilobyte, etc.), and specifies the binary (1024-based) sizing. This distinguishes it from other converter siblings like length-converter or temperature-converter.

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

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

The description states the conversion domain (digital storage units) and notes the binary sizing, giving clear context for when to use the tool. It doesn't explicitly mention alternatives or exclusions, but the specificity of the units makes the usage obvious among sibling converter tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the tool is known to be safe and non-mutating. The description adds valuable behavior details: the inclusive count formula using absolute difference and the multi-unit return values. This goes beyond annotations and clarifies the calculation method.

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

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

The description is three short sentences, front-loaded with the primary purpose, then giving essential behavioral details. Every sentence earns its place, with no repetition or wordiness.

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 a schema covering both parameters and an output schema present, the description provides sufficient context: purpose, return units, and calculation logic. The annotations cover safety, so no additional behavioral caveats are needed.

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

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

The input schema already provides full descriptions for both 'start' and 'end' parameters (ISO 8601 format), so schema coverage is 100%. The description does not add significant parameter-level meaning, though the absolute-difference formula implicitly states that parameter order is irrelevant.

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 calculates the number of days between two ISO 8601 dates, with a specific verb and resource. It also notes the returned units (days, weeks, months, years), distinguishing it from other date-related calculators in the sibling list like 'easter-date-calculator' or 'age-on-other-planets'.

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 the time span between two dates) but does not explicitly state alternatives or exclusions. There is no mention of when not to use it or which sibling tool might be more appropriate in other scenarios.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds useful behavioral context beyond annotations, such as order preservation and optional case-insensitivity. It does not contradict annotations and provides enough transparency for a simple utility.

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

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

The description is two concise sentences with no wasted words. It front-loads the primary action and immediately covers the most important nuance (order preservation). Every sentence earns its place.

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

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

Given the tool's low complexity, rich schema, and presence of an output schema, the description adequately covers the main behavior, key option (case-insensitive), and behavioral guarantee (order preservation). It is complete for an agent to select and invoke this tool correctly.

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

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

Schema coverage is 100%, with all three parameters (text, keep, case_insensitive) having descriptions. The description adds no substantial parameter information beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Remove') and resource ('duplicate lines from a text block'), clearly stating the tool's function. It also adds a key differentiator ('Order is preserved (not sorted)') that distinguishes it from sibling tools like sort-lines.

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

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

The description provides clear context for when to use the tool (to deduplicate lines) and implicitly excludes sorting with the parenthetical '(not sorted)'. However, it does not explicitly name alternative tools or state when not to use it, lacking 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, idempotentHint, and destructiveHint, and the description adds no behavioral context beyond echoing the discount percentage in the return, which is not critical since an output schema exists. It does not 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, concise sentence that front-loads the action and output, 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 calculator with well-documented params and an output schema, the description is complete enough for an agent to select and invoke correctly; no further context like rounding rules is necessary.

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

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

Schema description coverage is 100% for both parameters, so the description does not need to add parameter details; it doesn't, and the schema already explains 'Original price' and 'Discount 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 applies a percentage discount and returns the sale price, amount saved, and the discount percentage, which is specific and distinguishes it from sibling calculators like percentage-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 provides no guidance on when to use this tool versus alternatives, such as percentage-calculator or tip-calculator, and lacks exclusions or prerequisites.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the bar is lower. The description adds useful behavioral context by listing return values (final value, gains, CAGR, inflation-adjusted figures) and the lump-sum head-to-head, without contradicting annotations.

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

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

The description is two sentences, front-loaded with the primary purpose and followed by a concise list of outputs. 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?

The description, combined with a complete schema and output schema, gives enough context for a user to understand the tool's function and result. It could mention assumptions like constant return rates, but for a calculator this is sufficient.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds minimal parameter nuance beyond the schema—only noting that inflation-adjusted figures are optional. It does not need to compensate for missing schema info.

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

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

The description clearly states the tool projects the final value of a DCA plan and compares it to lump-summing, naming specific outputs. This distinguishes it from sibling calculators by explicitly mentioning DCA and the lump-sum comparison.

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

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

The description provides clear context: it's for comparing DCA vs lump-sum investment. However, it does not explicitly mention when not to use it or name alternative tools, so it misses the full 'when/when-not' guidance.

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

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

Annotations already declare this as read-only, idempotent, and non-destructive. The description adds meaningful behavioral context by explaining the cross-field consistency rules and the deterministic-seed property, which are not captured in the annotations or 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 concise sentences that front-load the core purpose and then add valuable behavioral detail. No filler or redundant restatement of the tool name.

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

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

With a 100% schema coverage and an output schema present, the description provides the right level of high-level context. It explains the tool's unique value (tabulated fake data with coherent identities) while leaving parameter details to the 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?

Because the schema describes all seven parameters with full coverage, the baseline is 3. The description earns extra credit by clarifying how the field parameters interact (e.g., 'first/last name match the email; state matches the ZIP prefix'), giving semantic meaning beyond the individual parameter definitions.

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 'Generate tabular test fixtures (JSON or CSV) from a chosen mix of fake fields,' giving a specific verb, resource, and output formats. It further distinguishes itself from sibling generators (e.g., random-number, uuid-generator) by emphasizing row-level consistency and public-domain data tables.

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 frames when to use the tool: for creating tabular test fixtures with realistic identity correlations (e.g., first/last name match email, state matches ZIP). It does not explicitly name alternatives or exclusions, but the context is concrete enough to guide selection among the sibling list.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable context by listing the specific computed dates and naming the Meeus/Anonymous Gregorian algorithm, which helps agents understand the calculation behavior beyond the annotations. No contradiction with annotations.

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

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

The description is two concise sentences, front-loaded with the main verb 'compute', and conveys both the purpose and the method without any extraneous 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 single-parameter calculator with an output schema, the description is fully adequate. It specifies the input range, the exact computations performed, and the algorithm used, while the output schema handles return-value expectations. No missing context for an agent to select and invoke the tool.

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

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

The input schema provides full coverage of the 'year' parameter with a detailed description, minimum/maximum constraints, and additionalProperties=false. The description repeats the year range but adds no meaning beyond what the schema already states, so the baseline score of 3 applies.

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

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

The description uses the specific verb 'compute' and names the exact resources: Western (Gregorian) Easter Sunday, Eastern Orthodox Easter, and related liturgical dates (Ash Wednesday, Palm Sunday, Good Friday, Pentecost). It also specifies the year range and algorithm, making it clearly distinct from any sibling tool.

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

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

The description clearly states the valid year range (1583-4099) and the scope of what the tool calculates, giving a clear context for when to use it. It does not explicitly mention alternatives or exclusions, but no close sibling tool exists, so this is not a significant 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds one useful clarification ('calorie (thermochemical)') but does not disclose behavioral details such as rounding, precision, or handling of edge cases. It does not 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?

A single, front-loaded sentence with a clear verb and all relevant unit names. No filler, repetition, or unnecessary detail.

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

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

For a simple, stateless converter with complete input schema coverage, an output schema, and safety annotations, the description fully covers the essential purpose and unit set. No additional prerequisite, environment, or behavioral context is needed.

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

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

Input schema already documents all three parameters with 100% coverage and enums for from/to. The description adds meaningful semantic nuance by specifying that 'calorie' is thermochemical, disambiguating it from other calorie definitions not captured 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?

Description states a specific action ('Convert between energy units') and enumerates the exact unit set (joule, kilojoule, calorie, kilocalorie, watt-hour, btu), making it clearly distinct from sibling converters for length, temperature, volume, etc.

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

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

The description implies its use for energy conversions but does not explicitly state when to choose it over alternatives or mention exclusions. There is no 'use this tool when...' guidance, so usage context is only inferred from the tool name and unit list.

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 discloses return values (simplified numerator/denominator, decimal value, gcd, percentage), going beyond the annotations which already indicate read-only and idempotent behavior. It does not mention edge cases, but the schema handles the denominator non-zero constraint.

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

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

The description is a single, front-loaded sentence that efficiently conveys the tool's purpose and return values with no redundant information.

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

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

Given the simplicity of the tool, the rich annotations, and the presence of an output schema, the description is complete. It clearly states what the tool does and what it returns, with no critical gaps.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds some context by restating that numerator and denominator are the fraction parts, but does not provide additional syntax or format details beyond the schema.

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

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

The description clearly states the tool's function with a specific verb ('Simplify') and resource ('a fraction'), and specifies the outputs. It distinguishes itself from sibling calculators by focusing specifically on fraction simplification.

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

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

The description implies usage (when you need to simplify a fraction) but provides no explicit exclusions or alternatives. No guidance is given for when not to use this tool or how it compares to related calculators like percentage-calculator.

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

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

Annotations already mark the tool as read-only and idempotent, so the description correctly avoids restating those. It adds behavioral detail by defining the mathematical operation (n-th root of the product) and noting the additional return of the arithmetic mean, which is not visible in 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 extremely concise: two sentences that front-load the core purpose and immediately follow with the key extra behavior. Every word earns its place, with no filler or redundant restatement of the title.

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

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

For a simple calculator with one well-documented parameter and an output schema available, the description covers the essential purpose, input domain, and extra output. It is fully complete for this tool's complexity.

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

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

The schema already fully documents the single parameter, including type, constraints, and the invalidity of negative/zero values. The description only restates that it is a list of positive numbers, adding no new semantic detail, so the baseline 3 is appropriate.

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

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

The description begins with a specific verb ('Compute') and explicit resource ('geometric mean'), immediately clarifying what the tool does. It also notes the inclusion of the arithmetic mean, distinguishing it from a pure geometric-mean-only tool and from sibling calculators.

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

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

The description states the input requirement ('list of positive numbers') and implies use when a geometric mean is needed. It does not explicitly contrast with siblings like average-calculator, but the added return of arithmetic mean provides context for when this tool might be preferred.

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 goes beyond the readOnly/idempotent annotations by disclosing that rules from each selection are merged and duplicate lines are dropped silently, and that the result is file content ready to save. This provides valuable behavioral context that could affect user expectations, though it does not delve into deeper 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?

Two concise sentences: the first states the purpose and the second covers behavior and output. Every word earns its place, with no redundancy or fluff.

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

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

Given the presence of an output schema and detailed annotations, the tool description sufficiently covers the merging behavior, duplicate elimination, and output form. It is complete enough 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?

The input schema already provides 100% coverage for the single parameter, including a list of known template IDs and the minItems requirement. The description only indirectly references 'picking technologies' and adds no additional semantics, so the baseline of 3 is appropriate.

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

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

The description clearly states a specific verb ('Build') and a specific resource ('.gitignore file'), and explains the approach (picking technologies). This unambiguously distinguishes it from sibling generator tools like cookie-consent-generator or dummy-data-generator.

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

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

The description implies clear usage context: when you need a .gitignore file by selecting technologies, with rules merged and deduplicated. It does not explicitly mention alternatives or when not to use, but the tool's unique scope makes the intended use obvious.

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

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

Annotations already mark the tool as readOnly and idempotent, but the description adds meaningful behavioral details: the default resting heart rate of 80 bpm, the ability to override it, and the specific output fields (heartbeats, breaths, minutes alive, days alive). This explains underlying assumptions without contradicting annotations.

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

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

The description is three well-structured sentences: purpose, default assumption, and return values. Every sentence adds necessary information with no redundancy, and the main purpose 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 stateless calculator, the description combined with the input schema and output schema provides complete context. It covers inputs, defaults, and returns, and edge cases like birthMs <= nowMs are handled in the schema. No critical information is missing.

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

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

The input schema provides 100% parameter description coverage, including defaults and constraints for birthMs, nowMs, restingBpm, and breathsPerMinute. The description only reiterates the 80 bpm default and override capability, adding no extra parameter-level semantics.

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: 'Estimate the total number of heartbeats a person has had since birth' with specific verb (estimate) and resource (heartbeats since birth). It also specifies inputs (DOB, now timestamp) and outputs, distinguishing it from sibling date calculators like days-between.

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 (given birth date and reference timestamp), but does not explicitly mention exclusions or alternatives. Since no sibling tool offers heartbeat estimation, this level of guidance is sufficient.

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

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

Annotations already declare the tool read-only, idempotent, and non-destructive. The description adds useful behavioral details about accepted hex formats and optional # prefix, which goes beyond the annotations and clarifies handling of different input shapes. No contradiction exists.

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

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

The description is only two sentences, front-loads the core action, and provides a concrete example followed by accepted input variations. Every sentence earns its place with no redundant 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 conversion tool with full parameter schema coverage and an output schema present, the description adequately specifies input constraints and output purpose. It supports the annotations and leaves no critical gap for a straightforward pure function.

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 description of the hex parameter fully covers accepted formats (#RGB, #RGBA, #RRGGBB, #RRGGBBAA, with/without #). The tool description adds an example and reiterates the format set, but provides no additional semantic meaning beyond the schema, 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 tool converts hex colors to RGB and RGBA channel values, with a concrete example. It specifies accepted input formats (3-, 4-, 6-, and 8-digit hex with or without #), making it distinct from a broader color-converter sibling.

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

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

The description implies usage (when you have a hex color and need RGB/RGBA values) but does not directly compare against alternatives like color-converter. There is no explicit when-to-use or exclusion guidance, leaving the agent to infer the appropriate context.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so no contradiction. The description adds valuable context beyond annotations by naming the data source (RFC 9110/IANA) and detailing what the lookup returns (canonical name, scenarios, mistakes). No missing safety caveats are needed because the tool is read-only.

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

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

The description is two sentences long, front-loaded with the primary purpose in the first sentence. It immediately states what the tool does, gives search examples, and lists return fields without any filler. 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 lookup tool with one parameter and an output schema, the description is complete. It covers purpose, search syntax, data source, and return content. No critical information is missing, and the output schema handles formal return-value definitions.

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 very detailed description of the 'query' parameter, including example values and behavior. The tool description's search examples ('404', '4xx', 'not found') merely echo the schema's parameter description, adding no extra meaning beyond what the schema already provides. Baseline of 3 is appropriate due to high schema coverage.

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

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

The description clearly states the tool's function: 'Look up HTTP response status codes from RFC 9110 and the IANA registry.' It uses a specific verb ('look up') and resource, and further distinguishes itself by explaining search modes (code, category, free-text). This is a distinct lookup tool among the sibling calculators/generators, so it scores high.

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 examples of when to use the tool ('Search by code (404), category (4xx), or free-text (not found)') which implies usage contexts like debugging. However, it does not explicitly mention when not to use it or name alternative tools. There are no exclusions, but explicit alternatives are missing, so it stays at 4 per the rubric.

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

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

The description contradicts the annotations: it warns that calling bans your IP, implying a side effect, while annotations declare readOnlyHint=true and destructiveHint=false. This is a serious inconsistency that could confuse an agent.

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 short sentence delivers the warning with maximum clarity and no wasted words. It is perfectly front-loaded and easy to parse.

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

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

Despite the annotation contradiction, the description alone is fully sufficient for an agent to know the tool is off-limits. No output schema or parameters exist, so nothing else is needed.

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

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

The tool has zero parameters, so no parameter details are needed. The empty schema and 100% coverage make the baseline 4 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 is unambiguous: this is an internal honeypot that must not be called. It uses a clear directive ('do not call') and explicitly states its nature, distinguishing it from all sibling tools.

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

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

It provides explicit when-not-to-use guidance ('do not call') and the consequence (IP ban). No alternatives are needed since the tool should never be invoked.

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 (read-only, idempotent), the description discloses the core behavioral model: direction asymmetry with quantitative recovery rates (1 day per zone eastbound, ~2/3 day per zone westbound), and the exact output categories (severity band, recovery days, direction-specific tips). This provides deep transparency into how the tool computes and what it returns.

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

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

The description is three sentences, each earning its place: purpose, behavioral rule, and output details. It is front-loaded with the main action and avoids any fluff or repetition.

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

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

Given the output schema exists and the annotations cover safety profile, the description completes the picture by explaining the algorithm directionality, output types, and even the nature of adjustment tips. There are no unresolved gaps for a calculator of this complexity.

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

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

Schema coverage is 100%: both fromOffset and toOffset are well described with ranges and examples. The description adds no additional parameter-specific 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 opens with a specific verb ('Predict') and resource ('jet-lag severity and recovery time for a trip between two time zones'), clearly distinguishing this calculator from general time zone tools. It further specifies direction asymmetry and returns categories, which sets it apart from sibling calculators.

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

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

The description makes it clear the tool is for predicting jet lag between two time zones, which is a clear usage context. It does not explicitly mention exclusions or alternatives, but given the unique specialization, no close sibling competes directly.

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 goes beyond the annotations by disclosing that the tool validates input and returns a clear error on invalid JSON, which is not stated in the schema or annotations. It also explains the two output behaviors (pretty-print with indentation vs. minify). Since annotations already declare readOnlyHint, idempotentHint, and destructiveHint, the added behavioral context is valuable and non-contradictory.

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-loaded with the primary action and mode options, and includes a brief mention of the error handling. Every word contributes necessary information with no filler or redundancy. It is concise yet complete for a tool of this simplicity.

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

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

Given the tool's low complexity (3 params, all documented in schema), the presence of an output schema, and robust annotations (readOnly, idempotent, non-destructive), the description covers all necessary behavioral aspects: formatting modes, validation, and error reporting. It does not need to explain return values because the output schema exists, and the description adds appropriate context for the tool's usage.

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

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

The schema covers all three parameters with descriptions (100% coverage), so the baseline is 3. The description adds modest context by explaining the 'pretty' and 'minify' modes, which corresponds to the 'mode' parameter, and implies validation for the 'json' parameter. However, it does not add significant detail beyond the schema's own parameter descriptions, such as defaults or constraints.

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

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

The description clearly states the tool's function with a specific verb ('Format JSON') and resource ('JSON'), and distinguishes between two modes (pretty-print or minify). It also mentions validation, setting it apart from generic converters or calculators in the sibling list. The resource and action are unambiguous and fully aligned with the tool name.

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 the tool (when needing to format or validate JSON) and clearly distinguishes the two modes. It does not explicitly mention when not to use it or list alternatives, but the sibling tools are unrelated to JSON formatting, so no alternative is needed. The contexts of 'pretty-print' and 'minify' provide clear usage scenarios.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds the critical behavioral fact that the tool does NOT verify the signature, which is beyond the annotations and essential for safe use. This fully discloses the tool's limitations.

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

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

The description is two sentences with no fluff. It leads with the core action, then adds the critical caveat. Every word earns its place.

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

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

For a simple tool with one parameter and an output schema, the description covers the purpose, the key non-verification behavior, and usage caution. There is no need to explain return values since the output schema exists. The description is complete for safe and correct usage.

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 parameter 'token' has a clear description including the expected format. The tool description does not add any additional parameter semantics beyond what the schema already documents, so the baseline of 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Decode a JWT into its header and payload.' This clearly states what the tool does and distinguishes it from any potential verifier or other JWT-related tool. The mention of 'header and payload' makes the output explicit.

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

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

The description explicitly states 'use this for inspection only' and warns 'never to trust the token's claims,' providing clear when-to-use and when-not-to-use guidance. However, it does not name any alternative tool for signature verification, so it falls slightly short of the highest bar for explicit alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description's 'Convert' is consistent with a read-only, stateless transform. The description adds no additional behavioral context (e.g., rounding or precision), but none are necessary for this simple operation. 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 description is a single, information-dense sentence that lists all supported units without any fluff. It is front-loaded with the verb and resource, making it easy to parse quickly.

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 simple, stateless nature, a complete input schema, and the presence of an output schema, the description fully covers the tool's purpose and context. No additional information about return values or edge cases is needed.

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

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

The input schema has 100% coverage with clear descriptions for value, from, and to, including enums for the unit fields. The description adds no extra 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 uses the specific verb 'Convert' and specifies the resource ('common length units') along with all eight supported units, clearly distinguishing it from similar converter tools like area-converter or weight-converter. The purpose is immediately obvious.

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 enumeration of length units (millimeter, centimeter, meter, etc.) makes the usage context unambiguous: use this tool for length conversions. However, it does not explicitly name alternative tools or state exclusions, so it earns a 4 rather than 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?

The description adds transparency beyond the annotations by specifying the standard amortization formula and warning that all amounts share the same but unspecified currency. These are behavioral details not captured by the read-only/idempotent annotations.

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

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

The description is three short sentences, with the primary purpose in the first sentence and key behavioral notes following. Every sentence adds value without repetition or padding.

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 sufficient for this simple calculator: it covers the calculation type, formula, and currency caveat, while the output schema and annotations fill in the remaining structural details. 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?

The input schema already documents all three parameters, so the description doesn't need to repeat them. However, it adds the semantic note that principal and computed amounts use the same currency, which clarifies how to interpret the numeric values.

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

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

The description opens with a specific verb 'Compute' and names the exact financial outputs (monthly payment, total interest, total cost) and the loan type (fixed-rate amortizing). This clearly distinguishes it from the many other calculator siblings and states the tool's core 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 clearly defines the use case: fixed-rate amortizing loans, which implies it is not for other loan types. However, it does not mention any alternative tools or explicitly state when not to use it, so it stops short of full usage 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. The description adds context beyond that by listing the return values (total cost, per-attendee breakdown, cost-per-minute, order-of-magnitude comparisons). No contradiction with annotations.

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

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

The description is a single, front-loaded sentence with a parenthetical clarifying output examples. Every phrase earns its place, with no redundancy or filler.

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

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

For a simple calculator with a robust output schema and full parameter descriptions, the description adequately covers when to use it and what it returns. No additional context is necessary 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 the schema already provides rich descriptions for 'duration_minutes' and 'attendees' (e.g., 'fully loaded' explanation, count semantics). The tool description only mentions 'duration' and 'attendees with hourly rates', adding no meaningful detail beyond the schema.

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

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

The description uses a specific verb ('Calculate') and resource ('total cost of a meeting'), clearly stating inputs and expected outputs. It distinguishes itself from sibling calculators like coffee-habit-cost-calculator or road-trip-cost-calculator by focusing specifically on meetings.

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 the tool: when you have a meeting duration and attendees with hourly rates. It does not explicitly name alternatives or exclusions, but the input requirements are clearly stated, making the usage context 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds meaningful behavior beyond these: it parses standard notation including nested parentheses and hydrate dots, and returns both a total and per-element breakdown. This provides useful context without contradicting the annotations.

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

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

The description is two sentences. The first sentence states the core function and output unit; the second explains parsing capabilities and return contents. Every phrase earns its place, with no wasted words or repetition of annotations.

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

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

For a single-parameter read-only calculator, the description is complete. It covers input syntax, supported notation variants, and output shape. Annotations (readOnly, idempotent, non-destructive) and an output schema exist, reducing the burden on the description to describe return values or safety. No critical gaps remain.

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

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

Schema description coverage is 100%, so the schema fully documents the 'formula' parameter with examples and notation rules. The description's mention of 'nested parentheses' and 'hydrate dots' adds no new semantic value beyond what the schema already provides. Baseline 3 is correct when structured data carries the 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 opens with 'Compute the molar mass (g/mol) of a chemical compound from its formula,' using a specific verb and resource. It clearly distinguishes itself from the many sibling calculator tools by specifying the exact domain (molar mass) and the input type (chemical formula).

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 states the tool's scope and parsing capabilities, making it clear when it should be used. There is no explicit exclusion or naming of an alternative, but among the sibling tools, none offer molar mass calculation, so the usage context is unambiguous. A 4 is appropriate because guidance is implied rather than explicitly stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the key behavioral fact that raw scores are auto-bucketed (and the schema clarifies that scores override counts), which is useful beyond annotations.

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

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

A single sentence that leads with the action and metric, then lists the two supported input forms. 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?

The tool is a simple pure calculation; annotations cover read-only/idempotent behavior, the schema fully documents parameters and constraints, and an output schema exists for return values. The description supplies the remaining piece—what the tool computes and which inputs are accepted—so it is complete for the tool's complexity.

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

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

Schema description coverage is 100%, with each parameter's bucket meaning and the mutual-exclusion rule documented in the JSON schema itself. The description only reiterates the two modes at a high level, so it adds minimal new semantic value beyond the schema.

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

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

The description names the exact calculation ('Net Promoter Score') and the verb 'Compute,' and it specifies two distinct input modes (pre-aggregated counts vs raw 0–10 scores). This distinguishes it from the many sibling calculators by naming a unique metric.

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 states the tool computes NPS from either counts or raw scores, giving clear context for when to choose it. It doesn't explicitly name alternative tools to use instead, nor does it state exclusions, but the context is unambiguous among the 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 readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful return-value context (Accept/Reject decision, breakdown) but does not disclose any edge-case behaviors, such as the NPV decision rule (e.g., accept if NPV >= 0) or handling of multiple IRRs. This is acceptable given the strong annotations, but it leaves some behavioral traits undocumented.

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-loaded with the core action, and contains zero filler. Every sentence earns its place: the first states the primary function, the second lists the return values. This is an ideal level of conciseness.

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

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

Given the tool's low complexity, comprehensive schema descriptions, presence of an output schema, and strong annotations, the description is complete. It covers the purpose, inputs, and outputs sufficiently for an agent to select and invoke the tool correctly. No critical gaps remain.

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

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

Schema description coverage is 100%, with each parameter (initial_investment, discount_rate_percent, cashflows) already having detailed descriptions. The tool description adds no additional parameter semantics beyond restating 'cashflows discounted at a given rate.' Per the calibration baseline, a score of 3 is appropriate when the schema fully covers parameter meaning.

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

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

The description clearly states the tool's purpose with specific verbs and resources: 'Compute Net Present Value (NPV) and Internal Rate of Return (IRR) for a series of cashflows discounted at a given rate.' It also lists the outputs (NPV, Accept/Reject decision, IRR, per-period present-value breakdown), fully distinguishing it from sibling tools like loan-calculator or discount-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 provides clear context on what the tool does, which implies when to use it (for NPV/IRR calculations). It does not explicitly name alternatives or exclusions, but the sibling list contains no other financial-calculator tools, so confusion is unlikely. A minor gap is the lack of explicit 'when not to use' guidance, but the purpose 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 declare readOnlyHint=true and idempotentHint=true, and the description adds valuable behavioral context: input is lowercased and stripped of non-alphanumeric characters before comparison. It does not explain return format, but output schema exists to cover 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?

Two sentences, no filler: the first states the core purpose, the second explains the algorithm. Every word earns its place.

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

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

This is a low-complexity tool with a single parameter and an output schema. The description covers the essential normalization behavior, making it fully sufficient for an agent to select and invoke correctly.

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

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

Schema coverage is 100% with the parameter 'text' described as 'Word or phrase to test.' The description adds normalization processing details but does not alter or expand parameter meaning 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 clearly states a specific verb ('Test whether') and a well-defined resource ('a word or phrase is a palindrome'), with exact normalization behavior (lowercased, stripped of non-alphanumerics) that distinguishes it from sibling tools like reverse-text or case-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 context is unmistakable: use this tool to test for palindromes. It doesn't explicitly name alternatives or exclusions, but the tool's niche is so distinct among siblings that no further guidance is needed.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint as safe, so the description's main contribution is disclosing the return payload—'the joined string, the word count, and an entropy estimate in bits.' This adds useful context beyond the annotations without any contradiction.

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