MaCalculatriceEnLigne

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint=false and destructiveHint=false, so the safety and determinism profile is covered structurally. The description adds the Epley formula choice and the return shape, which is modest extra context but nothing about behavior beyond what annotations and output schema provide.

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

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

The core purpose and formula are front-loaded in one efficient sentence. The remaining sentences are short, though the 'See list_bundles' pointer is tangential cross-promotion rather than information needed to invoke this tool.

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

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

For a two-parameter, read-only, idempotent calculator with full schema coverage and an output schema, the description supplies enough to call it correctly. Restating the return object is redundant given the output schema, but nothing essential is missing.

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

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

Schema description coverage is 100% and both parameters (weight, reps) are documented in the schema with bounds. The description only restates the input concept as 'from a known lift' and echoes the returned field names, adding no new meaning about units, ranges, or interpretation beyond the schema.

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

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

The description states a specific verb and resource ('Generate a full 1RM-to-12RM repetition table from a known lift') and names the underlying method (Epley formula), which is clear and concrete. However, it does not distinguish itself from the closely related sibling calculate_one_rep_max, leaving the agent to infer the difference.

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

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

There is no statement of when to use this tool versus alternatives (notably calculate_one_rep_max), nor any prerequisites or exclusions. The trailing 'See list_bundles for related sport calculators' is a cross-reference to a browsing tool, not usage guidance for this tool.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is fully covered. The description adds only the return shape (hours and minutes), which is modest added value given an output schema also exists. No edge-case behavior (e.g., minute overflow past 59, negative inputs) is disclosed.

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

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

Two short sentences with the core purpose front-loaded first. The second sentence carries the only weak payload — a cross-reference to list_bundles and an unexplained 'temps-rh' label — but the whole thing is far from bloated.

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

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

For a simple four-parameter arithmetic tool with full schema coverage, an output schema, and complete annotations, nothing essential is missing to call it correctly. The only shortfall is the absence of routing guidance versus the many sibling time calculators.

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 four well-described parameters (hours1/minutes1/hours2/minutes2, each with bounds). The description's 'two time durations' adds no syntax or constraint detail beyond the schema, 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?

States a specific verb and resource: add two time durations, with the output form (total in hours and minutes) made explicit. It is clearly distinguishable from neighbors like calculate_time_difference, though it never names that sibling to sharpen the contrast.

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 only guidance is 'See list_bundles for related "temps-rh" calculators', which points at a bundle-listing tool rather than naming an alternative calculator or stating when to prefer this over calculate_time_difference or calculate_timezone_convert. No when-to-use or when-not-to-use condition is given.

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, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered for what is a pure deterministic computation. The description adds the enumerated return fields, but that largely restates the existing output schema, so net new behavioral insight is modest.

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 compact sentences, front-loaded with the core action before the return values. The inline return-field list is somewhat redundant given an output schema exists, but it is short and does not bloat the definition.

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 full annotations and an output schema, the definition covers what the tool does and what it returns. The only meaningful gap is the unaddressed ambiguity against calculate_age_in_units, which is a usage-guideline issue rather than a completeness failure of core behavior.

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 birth_date field is documented as 'YYYY-MM-DD — Date of birth' in the schema itself. The description only echoes 'from a birth date' without adding format, range, or edge-case (e.g., future dates) semantics, so 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?

States a specific verb+resource ('Calculate exact age ... from a birth date') with the unit of output (years, months, days), which is clear standalone. However, it does not distinguish itself from the very close sibling calculate_age_in_units, nor from the many animal-age tools (calculate_cat_age, calculate_dog_age), so sibling differentiation is missing.

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

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

There is no when-to-use or when-not-to-use guidance. The trailing 'See list_bundles for related temps-rh calculators' is a bundle cross-reference, not usage context, and it does not tell the agent when to pick this tool over calculate_age_in_units.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and closed-world behavior, so the safety profile is carried by structured data. The description adds the returned unit set, but since an output schema exists that is largely redundant, and nothing is said about date-range limits, future dates, or error behavior.

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

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

Three short sentences with the core operation front-loaded, and nothing is padded or vague. The middle sentence listing return units duplicates what the output schema already provides, which is the only wasted space.

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

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

For a one-parameter, read-only calculator with full schema coverage and an output schema, the definition covers what the agent needs to invoke it correctly. The remaining omission is sibling disambiguation against calculate_age, which the description leaves to inference.

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

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

Schema description coverage is 100% and the single parameter 'birth_date' is documented as YYYY-MM-DD in the schema itself. The description only restates 'from birth date' without adding format, range, or edge-case meaning, so the baseline of 3 for a fully documented single-parameter tool 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?

States a specific verb and resource ('Calculate exact age in multiple units from birth date') and names the output units, so the operation is unambiguous. However, the sibling list contains a plain 'calculate_age', and this description never explains how it differs from that tool, which is the single most likely confusion an agent would face.

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 only guidance is 'See list_bundles for related "fun" calculators', which is a cross-reference to browsing, not a when-to-use rule. There is no statement of when to prefer this over calculate_age, calculate_pet_age, or calculate_dog_age, and no input prerequisites beyond the required birth_date.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safe/pure-computation profile is fully covered. The description adds the valuable scope detail that units are UK-standard and lists what is returned, but adds nothing about limits, batch semantics, or validation behaviour beyond 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?

Prose is tight and front-loaded with the computation, but the final sentence pointing to list_bundles for 'cuisine' calculators is unrelated to alcohol-unit maths and does not 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?

For a single-parameter computation tool with an output schema and full annotations, the essentials are present, and return values are covered by the output schema anyway. The remaining gap is the batch array/schema shape, which the description neither clarifies nor corrects.

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 0%, so the description must carry the burden, yet it says 'Inputs: volume mL, ABV %' in the singular, while the schema requires an array of drink objects with type/volume_ml/abv_pct. It omits the 'drinks' array wrapper and the 'type' enum entirely, and its singular framing mildly misrepresents the accepted shape.

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

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

States a specific verb and resource ('Compute alcohol units (UK) and grams of pure alcohol'), which cleanly separates it from siblings like calculate_blood_alcohol or calculate_bac_points. It does not explicitly differentiate from those siblings, and the trailing 'See list_bundles for related cuisine calculators' pointer is off-topic rather than clarifying.

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?

Gives a use context ('health tracking and limit awareness') but no when-to-use-vs-alternative guidance, e.g., it never says how it differs from calculate_blood_alcohol or calculate_bac_points, which are close neighbours. Usage is implied rather than directed.

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

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

Annotations already establish the full safety profile (readOnly, idempotent, non-destructive, closed-world), so the description's remaining burden is light. It adds the shape of the result, but since an output schema exists that information is largely duplicative rather than new behavioral context.

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

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

Two short sentences, purpose front-loaded before the routing pointer. Enumerating the return fields consumes most of the length and is redundant given the output schema, so it is efficient but not maximally tight.

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 full schema coverage, complete annotations, and an output schema, the description supplies everything an agent needs to invoke it correctly. Nothing critical is missing; the return-field list is surplus rather than a gap.

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

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

Only one parameter (altitude_m) with 100% schema coverage including description and 0-8850 bounds, so the schema carries the semantics. The description adds no unit, range, or interpretation detail beyond what the schema already states; 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?

Specific verb+resource: 'Assess altitude sickness risk and recommend acclimatization schedule.' This is clearly distinguishable from the hundreds of unrelated calculate_* siblings, and no other sibling covers altitude sickness.

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

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

Usage is only implied: an agent with an altitude value infers it should use this tool. There is no explicit when-to-use/when-not statement, and the only routing hint ('See list_bundles for related voyage calculators') points to a discovery tool rather than naming an alternative 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 cover the safety profile (readOnly, idempotent, non-destructive, non-open-world), so the description carries a lighter burden. It adds nothing beyond that — no note on numeric precision, rounding, or output format — and the 'Returns: {original}' placeholder is a malformed template artifact rather than useful disclosure.

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

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

The first sentence is tight and front-loaded, which is good. The second sentence is a broken placeholder ('{original}') that conveys no information, and the list_bundles pointer is tangential to invoking this tool.

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

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

An output schema exists, so return values need not be explained, and the parameter surface is simple and fully documented. Still, the description omits the one thing an agent needs here — how this differs from convert_angle — and the malformed Returns clause leaves the output description worse than silence.

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 enums on both unit parameters, so the schema already documents all three parameters fully. The description repeats the unit list, which is harmless but adds no meaning beyond the schema; 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?

States a specific verb (Convert), resource (angles), and enumerates the supported units, so the operation is unambiguous. However, it never distinguishes itself from the sibling tool convert_angle, which appears to cover the same ground, leaving genuine ambiguity about which to pick.

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

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

There is no statement of when to use this tool versus alternatives; the only guidance is a generic pointer to list_bundles for 'conversions' calculators. With a near-identical sibling (convert_angle) in the toolset, the absence of routing guidance is a meaningful 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, idempotentHint, and destructiveHint=false, so the safety profile is fully covered structurally. The description adds no further behavioral context (e.g., compounding convention, rounding, currency handling beyond the EUR-named fields), so it neither contradicts nor enriches the annotations.

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

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

Two short sentences, front-loaded with the purpose and with zero filler. The 'Returns:' sentence is redundant with the output schema, which costs it a point but does not make the text bloated.

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

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

An output schema exists, so the return-value listing in the description is unnecessary, and the three inputs are fully documented in the schema. What is missing is disambiguation from the many overlapping finance calculators, which is the main thing an agent needs to choose this tool correctly.

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

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

Schema description coverage is 100%, so principal, rate (annual percent), and periods (months) are already documented in the schema. The description adds no parameter-level meaning beyond that, 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?

States a specific verb and resource ('Calculate periodic payment amount for a loan or annuity'), so an agent knows it is an annuity/loan payment solver. However, it does not distinguish itself from close siblings such as calculate_loan_payment, calculate_mortgage, or calculate_lmnp_amortization, which cover overlapping ground.

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 only routing hint is 'See list_bundles for related finance-universal calculators', which is a discovery pointer rather than a when-to-use rule. There is no guidance on when this is preferred over calculate_loan_payment or calculate_present_value, which is the key ambiguity given the sibling set.

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

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

Annotations already declare openWorldHint=true, idempotentHint=false, and destructiveHint=false; the description adds one genuinely useful signal, the premium-subscription requirement, which is an entitlement gate an agent cannot infer from the schema. It does not explain why the call is non-idempotent (AI generation may vary between identical calls) or whether calls consume quota, so the added context is partial.

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

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

Two short sentences with the capability stated first and the constraint second; no filler and no repetition of schema or annotation content. Every clause carries 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?

An output schema exists, so return values need no explanation, and the schema covers both inputs. The description supplies the fallback positioning and the subscription requirement, leaving only minor gaps around cost/latency and explicit preference ordering versus specialized tools.

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 only two parameters, so the schema fully documents 'query' (natural-language request, English/French) and 'context'. The description adds nothing about either parameter, 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?

States a specific capability (universal calculator) and explicitly positions it as the fallback for calculations 'not covered by specialized tools', which distinguishes it from the hundreds of calculate_* siblings. The 'AI-powered' framing is slightly promotional but the catch-all role is unmistakable.

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

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

'Handles any calculation not covered by specialized tools' functions as an implicit selection rule: reach for a domain-specific sibling first, then fall back here. No explicit 'do not use for X' guidance or examples, but the routing condition is clear enough to act on.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is fully covered. The description adds essentially nothing behavioral beyond stating output units, which the output schema already provides. It is a pure computation, so a baseline 3 is appropriate.

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

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

Five short, front-loaded sentences with the core purpose and units stated first; little waste. The input and cross-reference sentences are compact, though the invented shape/radius detail is wasted (and misleading) text.

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?

An output schema exists so return values need not be explained, and the description covers purpose and units. But it misrepresents the input surface (nonexistent shape/radius params, missing substrate_cm), so an agent lacks a reliable picture of what to pass.

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

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

With 0% schema coverage the description must compensate, and it partially does by naming L×W×H in cm. But it invents inputs that do not exist ('shape (rectangular/cylindrical/bow-front)', 'radius×height') and omits the real substrate_cm parameter, actively misdescribing the schema.

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

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

States a specific verb and resource ('Compute aquarium water volume') plus output units (L and US gallons), which clearly distinguishes it from generic siblings like calculate_volume or calculate_pool_volume. Clear and specific, though it doesn't explicitly name the sibling it is not.

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?

'Use for fishkeeping, dosing, and stocking decisions' gives concrete usage context, and it cross-references list_bundles for related calculators. However, it offers no when-not guidance or direct alternative (e.g., calculate_volume for non-aquarium shapes).

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, non-destructive, closed-world, so the safety profile is fully covered. The description adds the return semantics ('area in input-units squared'), which is useful, but nothing about validity constraints or error behavior across the shape variants.

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

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

Three short sentences, front-loaded with the core purpose, with no filler. The trailing bundle pointer is the only mildly expendable sentence.

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?

An output schema exists so return values need not be explained, and the tool is a pure read/compute with no side effects, meaning the annotations plus description cover the essentials. The remaining gap is which dimension parameters each shape requires, a real hazard given only 'shape' is required and additionalProperties is false.

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 each of the 10 parameters has a short label, so the baseline is 3. The description adds no shape-to-dimension mapping, which is the one piece of semantics the schema genuinely lacks — 'width/height' vs. 'length/height' vs. 'semi_major/semi_minor' per shape is left entirely to inference.

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

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

States a specific verb+resource ('Compute area for common 2D shapes') and enumerates the shape family, which cleanly separates it from calculate_volume, calculate_perimeter, and calculate_ellipse in the sibling list. An agent can pick this tool without opening the schema.

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?

Gives context ('geometry, real estate, or paint estimates') but never says when NOT to use it or which sibling to prefer — e.g., calculate_ellipse exists separately yet ellipse appears in this tool's own enum, and calculate_paint_needed/calculate_paint_quantity are the natural siblings for the paint use case cited. The 'See list_bundles' pointer is a weak routing hint rather than real 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, destructiveHint=false and a closed-world scope, so the safety profile is fully covered. The description adds the output field list, but no behavioral context such as which category applies by default in practice, rounding behavior, or jurisdiction assumptions.

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

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

Two sentences, front-loaded with the purpose, and the sibling pointer is placed last. The 'Returns:' enumeration is somewhat redundant given a full output schema exists, but it does not bloat the definition.

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 annotations, 100% schema coverage and an output schema all present, the description only needs to establish the domain and scope, which it does. A note on category selection defaults or jurisdiction limits would make it fully self-contained.

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

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

Schema description coverage is 100% with an enum on 'category' and a minimum on 'revenue', so the schema does the heavy lifting. The description adds nothing about parameter meaning beyond what the schema declares; 3 is the correct 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?

States a specific verb ('Calculate') plus a precisely scoped resource ('French auto-entrepreneur (micro-enterprise) net income and social charges'), which separates it from the many other French tax siblings like calculate_french_income_tax or calculate_employer_cost_fr.

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

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

Usage is implied by the domain-specific naming, and it does point to 'list_bundles' for related 'finance-france' calculators. However, it never states when to prefer this over calculate_french_income_tax or calculate_french_salary, so the routing guidance is only partial.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so safety is covered. The description adds only that it returns 'mean and detail', which is thin behavioral context and arguably redundant given the output schema 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?

Front-loaded with the core verb and the supported variants, and each sentence is short. The lone blemish is the erroneous 'mode' input mention and the somewhat gratuitous list_bundles pointer, but overall it is tight.

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 output schema exists so return-value description is not required, and the description covers purpose and inputs adequately. However, the nonexistent 'mode' parameter and the unexplained mechanism for choosing between mean types leave a real gap for a tool with four distinct modes.

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

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

Schema coverage is 100%, so the baseline would be 3, but the description claims inputs include 'mode' — a parameter that does not exist in the schema (only values and weights are defined). This introduces a phantom parameter that could mislead an agent about how geometric/harmonic selection is made, offsetting the schema's own quality.

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

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

States a specific verb (compute) and resource (mean/average) and enumerates the four variants it supports (simple, weighted, geometric, harmonic), which distinguishes it from generic arithmetic siblings like calculate_statistics or calculate_grade_average. An agent can identify its scope without opening the schema.

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?

'Use for grade averages, returns, or rates' gives loose usage contexts but names no alternatives and provides no when-not-to-use guidance, despite there being a dedicated calculate_grade_average sibling. The 'See list_bundles' pointer is a catalog cross-reference, not real routing guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds that this is an estimate for pre-official tracking and that it returns a weighted average and mention, though it does not disclose formula assumptions or input constraints.

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

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

The description is short and front-loads the purpose before usage, inputs, outputs, and a related-bundle pointer. The 'Inputs' and 'Returns' sentences partly duplicate the schema and output schema, so not every sentence fully 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-purpose calculator with a fully described input schema and an output schema, the description covers the essential context. It does not mention that all seven inputs are required or the 0–20/0–720 ranges, but those details are available 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 every parameter and its coefficient/scale is already documented in the schema. The description's 'grades by subject with coefficients' adds no syntax or meaning beyond that structured data.

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

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

The description names a specific verb ('Estimate') and resource ('French Baccalauréat final score'), and the mention of grades/coefficients clarifies the exact scope. This is sufficient to distinguish it from siblings such as calculate_brevet_points or calculate_parcoursup_points without opening either schema.

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 states a concrete usage context ('track lycée results before official scores'), which tells the agent when this tool is relevant. However, it does not name direct alternatives or explicitly state when another calculator (e.g., Brevet or Parcoursup) should be chosen instead.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds the direction of the adjustment (less leavening, more liquid, higher temp), which is useful domain context, but says nothing about permissions, limits, or edge cases like sea-level input.

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

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

Four short sentences, purpose and mechanism front-loaded before the input/output summary. The trailing bundle pointer is marginally useful and the list reads cleanly, with little waste.

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

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

An output schema exists, so return values need not be spelled out, and annotations carry the safety profile. The description covers purpose, trigger context, and inputs adequately; only the sibling disambiguation is thin for a catalog with several baking/recipe calculators.

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

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

Schema description coverage is 100%, so all five parameters are already documented by the schema, establishing the baseline of 3. The description only summarizes 'altitude m, ingredients' and actually blurs the granular ingredient params (flour/sugar/liquid cups) into one vague term, adding no real 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?

States a specific verb+resource+mechanism: 'Adjust baking recipe for high altitude (less leavening, more liquid, higher temp).' An agent immediately knows what it computes. However, it does not differentiate itself from close siblings like calculate_baking_conversion or calculate_recipe_scale; the 'see list_bundles' pointer is not the same as naming the alternative.

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?

'Use for mountain cooking' gives an implied context for use, which is better than nothing. But there is no when-not guidance (e.g., low-altitude recipes, general baking conversions) and no mention of the sibling calculators that would cover adjacent cases.

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

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

The annotations already disclose that this is a read-only, idempotent, non-destructive, closed-world calculation. The description adds little behavioral context beyond 'Returns converted quantity,' which is redundant because an output schema exists, and it omits any ingredient-specific conversion assumptions or 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 short and front-loads the purpose, but one sentence lists incorrect parameters and another cross-references list_bundles for unrelated 'cuisine' calculators, which does not earn its place. The overall size is reasonable, but the content includes low-value and inaccurate material.

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

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

Given the simple two-parameter schema, 0% schema description coverage, and an output schema that already covers the return value, the description should at least explain ingredient and quantity_cups. Instead it misstates the inputs and provides no conversion basis, so it is not complete enough 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 0% and the actual schema has only two parameters: ingredient and quantity_cups. The description instead lists 'value, from-unit, to-unit,' which do not exist in the schema, and it omits quantity_cups entirely, making its parameter guidance actively misleading.

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 clear verb and resource: converting baking measurements between cups, tablespoons, grams, and milliliters for common ingredients. It adds a usage context, 'translating recipes across regions,' but does not explicitly distinguish itself from close siblings such as calculate_cooking_conversion or convert_cooking.

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

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

It gives an implied usage context ('Use for translating recipes across regions') but does not state when to choose this tool over the many other conversion and cooking calculators. There are no exclusions or explicit alternatives named.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds the return shape {input, decimal_value, result}, which is modestly useful context but partially redundant given an output schema exists. No auth, limits, or error behavior disclosed.

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

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

Two tight sentences, front-loaded with the core operation and supported bases. Every clause earns its place with 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?

With annotations and an output schema present, the description carries a light burden and covers purpose and return shape adequately. The one notable omission is sibling disambiguation from calculate_number_base_convert, which for a large overlapping toolset matters more than usual.

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

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

Schema description coverage is 100% with all three params documented and base bounds (2-36) enforced in the schema. The description only restates the 2-36 range already present in the schema, adding no new meaning (e.g., accepted digit formats for values above 9). 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?

Specific verb+resource: 'Convert numbers between bases' with concrete examples of supported bases. It is clear what the tool does, but it never distinguishes itself from the sibling 'calculate_number_base_convert', which appears to cover the same operation. That overlap keeps it below a 5.

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

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

No guidance on when to use this over the near-identical 'calculate_number_base_convert' sibling, nor any prerequisites for 'value' formatting. The 'See list_bundles' pointer is a cross-reference, not usage guidance. Effectively no when/when-not instruction.

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, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description usefully scopes the computation to uniform distributed loads (implying other load cases are out of scope), but adds nothing about limitations, edge cases, or assumptions beyond 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 tightly written sentences, with the core computation stated first. The trailing list_bundles cross-reference is mildly tangential for this specific tool, but it is short and does not obscure the primary 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 stateless, read-only calculator with an output schema present, the description covers what the tool computes and what it returns, so return values need not be re-explained. The one real gap is the unit asymmetry between the input (kg/m) and the returned load_kN_per_m, which the agent must infer.

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

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

Schema description coverage is 100%, so all three parameters (span_m, load_kg_per_m, beam_type enum) are already documented in the schema. The description adds no parameter detail and notably omits that beam_type supports 'simply_supported' vs 'cantilever', which materially changes the results; 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 gives a specific verb ('Calculate') plus the exact quantities and resource ('max bending moment and shear for a beam under uniform distributed load'). No sibling tool computes beam loads, so it is unambiguously distinguishable from the long list of other 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 only routing hint is 'See list_bundles for related construction calculators', which is a navigation pointer rather than a when-to-use statement. There is no indication of when this tool is appropriate versus alternatives, nor any prerequisite or exclusion (e.g., point loads or other load types not supported).

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is well covered. The description adds a list of return fields, but that largely duplicates the existing output schema and does not disclose behavioral assumptions such as which tax year or ATN formula version is used.

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

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

The description is front-loaded and only two sentences long, with no filler. The second sentence lists return fields that are already covered by the output schema, so it is mildly redundant rather than purely additive.

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

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

With a complete input schema, an existing output schema, and rich annotations, the definition is nearly self-sufficient. The description supplies purpose and a related-calculators pointer, though it could note the Belgian tax-year or formula assumption for full completeness.

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 co2, fuel_type, and catalog_value in detail, including units and enum values. The description adds no parameter-level meaning beyond what the schema provides, making the baseline score of 3 appropriate.

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

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

The description states a specific verb ('Calculate') and a precise, differentiated resource ('Belgian benefit-in-kind for company car'), using the local term 'avantage de toute nature voiture'. It is immediately distinguishable from the many Belgian tax and car siblings such as calculate_belgian_income_tax or calculate_car_depreciation.

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

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

Usage is implied by the narrow domain ('company car benefit-in-kind'), but there is no explicit guidance on when to use this tool versus alternatives or what preconditions apply. The only routing hint is 'See list_bundles for related finance-belgique calculators', which helps discovery but does not state when this specific calculator is the right choice.

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 a read-only, idempotent, non-destructive, closed-world computation, so safety is fully covered. The description adds 'Returns tax due and effective rate', but that is largely redundant given an output schema exists, and it omits any caveats about regional rate assumptions.

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

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

Four short sentences, purpose front-loaded, no filler. It earns most of its space except for the redundant return-value statement and the inaccurate input list.

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

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

Output schema exists, so return values needn't be explained, and annotations cover safety. The material gap is the phantom 'region' input that the schema does not support, leaving an agent unsure whether regionality is chosen or implicit.

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 defines amount and relationship, so the baseline would be 3. But the description asserts 'Inputs: region, amount, recipient relation' – 'region' is not a parameter at all, which is misleading, and 'recipient relation' loosely renames the relationship enum without adding 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 names a specific verb and resource (compute Belgian donation tax) and scopes it to three regions, which separates it from the many other Belgian tax siblings like calculate_belgian_income_tax. However, it claims a 'region' input that the tool cannot actually take, slightly muddying what the tool is.

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?

'Use for estate planning in Belgium' gives a clear use context, and it points to list_bundles for related calculators. But there are no when-not conditions and no direct naming of an alternative sibling tool, leaving the routing guidance implicit.

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

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

Annotations already establish the safe, idempotent, closed-world read profile, so the bar is lower; the description adds real domain context beyond that — the tax year applied, the progressive-bracket method, and the tax-free allowance reduction step. It omits assumptions such as household/dependents treatment, which matters for a tax engine.

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 compact sentences, front-loaded with the calculation identity before the version qualifier and cross-reference. The return-field preview is slightly redundant given the output schema but is short and skimmable, so no sentence is wasted.

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

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

With an output schema present, the description needn't fully explain returns, and it correctly leaves detail there. Method and tax-year context are supplied, but a tax calculator with only 'income' as input silently assumes a household/family situation that the description never states, which is the main residual gap.

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

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

Single parameter with 100% schema description coverage, so the schema already defines 'income' as annual taxable income in euros after social security and professional expenses. The description only echoes that framing ('annual taxable base') and adds no further format, boundary, or unit nuance.

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

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

States a precise verb+resource (Belgian personal income tax, IPP/PB) on an annual taxable base, and pins the version to income-year 2026 / tax year 2027 with the SPF method. It is clearly distinguishable from other national income-tax siblings by country, but it does not differentiate itself from close siblings such as calculate_belgian_salary or calculate_belgian_social_contributions.

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

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

Usage is only implied: 'on an annual taxable base' tells the agent what input shape is expected, and the closing 'See list_bundles for related finance-belgique calculators' is a navigation pointer rather than a when-to-use rule. No exclusion or alternative-selection guidance versus the other Belgian 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, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds that a monthly pension estimate is returned, which is modest added context, but nothing about assumptions or edge cases (e.g. career_years capped at 45).

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?

Front-loads the core purpose, then inputs, return, and a cross-reference. Mostly efficient, though the 'See list_bundles' pointer and the 'Inputs:' enumeration add some noise given the schema already lists them.

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?

An output schema exists so return values need not be explained, and the description covers purpose and context adequately. However the incorrect parameter characterization leaves an agent that trusts the description to supply the wrong enum values.

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

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

Schema coverage is 100%, so the baseline is 3, but the description actively misleads: it describes an input as 'status (employee/self-employed)' while the actual schema parameter is household_type with enum single/household (60%/75% rates). This contradicts rather than clarifies the schema.

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

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

States a specific verb (Estimate) and a precisely scoped resource (Belgian retirement pension), which distinguishes it from the many generic siblings like calculate_retirement_pension or calculate_swiss_lpp. An agent can identify it without opening the schema.

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?

'Use for retirement planning in Belgium' implies a context but names no alternatives or exclusions, even though siblings like calculate_retirement_pension (generic) and calculate_retirement_date exist. The agent must infer when this Belgian-specific tool is 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?

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds genuinely useful disclosure beyond that: the exact estimation assumptions (ONSS 13.07%, annual personal income tax, single filer, no municipal surcharge) and the internal endpoint it mirrors, which tells the agent the result is an estimate rather than a payroll-grade figure.

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?

Front-loaded with the conversion statement, followed by assumptions, a brief return enumeration, and a related-tools pointer. Dense but every clause carries information; the return-field list is somewhat redundant given an output schema exists, which keeps it from a 5.

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

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

For a single-parameter, read-only calculator with an output schema, the critical missing piece would be the estimation assumptions — and those are supplied explicitly (single filer, no municipal surcharge). Remaining gaps are minor, e.g. no note on precision or whether other filing statuses are supported.

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

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

Schema description coverage is 100% with a single required parameter (gross_monthly, in euros) fully documented, so the baseline of 3 applies. The description confirms the euro currency and monthly basis but adds no syntax or edge-case guidance beyond the schema.

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

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

States a specific verb+resource+scope: convert Belgian gross monthly salary to net salary. It is clearly distinguishable from siblings such as calculate_belgian_income_tax and calculate_belgian_social_contributions, which compute only a component rather than the full gross-to-net conversion.

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

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

Usage is implied (Belgian gross-to-net estimation) and the description cross-references the 'finance-belgique' bundle via list_bundles, but it never states when to prefer this tool over component calculators like calculate_belgian_income_tax or how it differs from calculate_french_salary / calculate_swiss_salary. No explicit exclusions or selection criteria are given.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description nonetheless adds genuine behavioral context by disclosing the progressive tier structure and the applied rates (20.5%, 14.16%), which tells the agent how the computation is bracketed rather than just that it is a safe read.

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?

Front-loaded with the purpose in one sentence, followed by the output key list and a single cross-reference. Every element earns its place, though the enumerated return keys overlap with the existing output schema and could be trimmed.

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 covers domain, jurisdiction, and calculation shape adequately; return values are additionally documented by the output schema. Only the absence of explicit sibling routing keeps it short of 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?

There is exactly one parameter with 100% schema description coverage ('Annual net professional income in euros'), so the schema fully carries parameter meaning. The description adds nothing about the parameter itself, which matches the baseline 3 for high-coverage schemas.

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?

Specific verb + resource + jurisdiction: 'Calculate Belgian self-employed social contributions (cotisations INASTI)'. The scope is narrow enough (self-employed INASTI contributions) that an agent can immediately distinguish it from the many other Belgian finance siblings such as calculate_belgian_income_tax, calculate_belgian_salary, or calculate_belgian_pension.

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 qualifier 'self-employed' implies the population it applies to, but there is no explicit when-to-use or when-not guidance (e.g. salaried employees should use calculate_belgian_salary instead). The pointer to list_bundles is a discovery aid rather than usage guidance, so this remains implied rather than stated.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is fully covered without the description. The description adds the conversion direction (HT<->TTC), which is useful, but omits operational details such as rounding behavior or accepted rate constraints beyond what the schema states.

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

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

Two short sentences, front-loaded with the primary action, with no filler. The 'Returns:' enumeration is partly redundant against the existing output schema but stays compact and does not harm readability.

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, annotation-backed calculator with a full output schema, the description covers purpose, operation, and return shape adequately, so return values need not be re-explained. The only shortfall is the absence of guidance distinguishing it from sibling VAT tools.

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

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

Schema description coverage is 100% and both enums (mode, rate) are fully documented in the schema, so the baseline of 3 applies. The description restates the HT/TTC concept but adds no new parameter meaning (e.g. how the rate enum interacts with mode) beyond the schema.

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

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

States a specific verb and resource ('Calculate Belgian VAT') plus the core operation ('convert between HT and TTC'), which cleanly separates it from the many sibling VAT calculators (french/moroccan/swiss/uk/generic). The 'Belgian' qualifier does the jurisdictional disambiguation work, though it never explicitly contrasts the tool with calculate_vat_generic or calculate_vat_reverse.

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

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

Usage is only implied by the HT/TTC conversion framing; there is no explicit when-to-use or when-not-to-use statement and no routing against the neighboring VAT tools. The only pointer ('See list_bundles for related finance-belgique calculators') directs the agent to a bundle rather than clarifying which calculator to pick.

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, and an output schema exists. The description still adds genuine value by flagging the pseudoscience nature (framing the results as entertainment rather than valid health data) and summarizing the returned shape, which goes beyond the structured metadata.

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

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

Three tight sentences: purpose first, usage/disclaimer second, inputs/outputs third, with a pointer to list_bundles last. No filler, well front-loaded.

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

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

For a simple two-input read-only calculator with a full output schema, nothing an agent needs to call it correctly is missing; the pseudoscience caveat and return summary round it out.

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

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

Schema description coverage is 100%, so both parameters are already documented with format. The description merely lists the two inputs without adding syntax or constraints, so it neither compensates for nor improves on the schema – 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?

States a specific verb (compute) and resource (physical/emotional/intellectual biorhythm cycles) and specifies the required inputs. It is clearly distinguishable from neighboring calculation tools like calculate_age or calculate_life_path_numerology.

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

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

The phrase 'Use for self-tracking enthusiasts (pseudoscience)' gives some context about the intended audience, and it points to list_bundles for related 'fun' calculators. However, it never states when-not to use this tool or names a concrete alternative, so usage is only implied.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds that the result is a Widmark-formula *estimate* and names the returned fields, but does not discuss accuracy limits or assumptions of the model, leaving moderate added 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?

Two short, front-loaded sentences with no filler. The only minor redundancy is enumerating return fields that an output schema already provides.

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 annotations covering safety, a full output schema, and 100% parameter coverage, the description is sufficient to invoke the tool correctly. Its one real gap is the absence of disambiguation from siblings like calculate_alcohol_units and calculate_bac_points.

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% (drinks, weight_kg, sex enum, hours_drinking are all documented), so the schema carries the parameter burden. The description adds no parameter-level meaning beyond that, which is the expected baseline of 3.

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

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

The description gives a specific verb (estimate), resource (blood alcohol content), and even the method (Widmark formula), so the purpose is unambiguous. However, it does not differentiate itself from close siblings such as calculate_alcohol_units or calculate_bac_points, which an agent could easily confuse with 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?

There is no explicit when-to-use or when-not-to-use guidance, and no routing away from near-identical siblings. The only pointer is 'See list_bundles for related "sante" calculators,' which is a discovery aid rather than 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, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds only that a weight category is produced, and since an output schema exists, that is largely redundant. No extra behavioral context (rounding, category thresholds, unit assumptions) is offered.

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

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

Two short sentences, front-loaded with the core action, with no filler. The second sentence is a cross-reference to list_bundles rather than information about this tool, which is mildly off-purpose but still cheap and useful for routing.

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

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

For a simple two-parameter calculator with full schema coverage, complete annotations, and an output schema, the description supplies everything needed to invoke it correctly. It stops short of 5 only because it gives no differentiation from the nearby BMI/BMR/body-fat calculators.

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 (weight_kg, height_cm) fully described including units and minimums. The description adds no unit conventions, ranges, or edge-case handling 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?

States a specific verb (Calculate) and resource (BMI) plus the derived output (weight category), which distinguishes it from adjacent siblings such as calculate_bmr, calculate_body_fat and calculate_ideal_weight. It never explicitly names those siblings, so differentiation relies on the agent's own reading of the tool list.

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

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

The only guidance is 'See list_bundles for related sante calculators', which is a discovery pointer rather than a when-to-use rule. There is no statement of when this tool is preferable to calculate_bmr or calculate_body_fat, and no prerequisites or exclusions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive, so safety is covered. The description adds genuinely useful context by naming the exact equation used, which explains the computation. It does not disclose edge cases (e.g., formula limits by age/sex), but an output schema exists, so return detail is not required here.

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

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

Two short sentences, front-loaded with the core action and method, then the return. No wasted words. Every clause earns its place.

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

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

For a simple deterministic calculator, the definition is essentially complete: annotations cover the safety profile, the schema fully documents the four inputs, and an output schema handles the return shape. The only missing piece is explicit routing guidance versus adjacent health calculators.

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% — all four parameters (weight_kg, height_cm, age, sex) are documented in the schema with ranges and an enum. The description adds no additional parameter meaning, so the baseline of 3 applies.

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

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

Names a specific verb (Calculate) and resource (Basal Metabolic Rate) and even specifies the method (Mifflin-St Jeor), which meaningfully distinguishes it from siblings like calculate_bmi or calculate_tdee. It stops short of explicitly contrasting those siblings, but the formula pinpoints the exact calculation.

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 own use case through the resource name but offers no explicit when-to-use or when-not conditions relative to calculate_tdee, calculate_bmi, or calculate_ideal_weight. The 'see list_bundles' line is a discovery pointer rather than usage guidance, leaving the agent to infer applicability.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered structurally. The description adds the deterministic formula name and the return key, which is modest additional context but nothing about accuracy limits or edge cases (e.g. output near BMI extremes).

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

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

Two short sentences, front-loaded with the core action and method, with no padding. The explicit 'Returns: {body_fat_pct}' is slightly redundant given an output schema exists, and the list_bundles pointer is tangential, but the text is otherwise tight.

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

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

For a simple, deterministic three-input calculator with a full schema, complete annotations and an output schema, the description supplies everything needed to invoke it correctly: inputs, method and the returned field. Only edge-case behavior and the sibling-vs-sibling choice are left unstated.

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 each of the three parameters carries its own description, range and enum, so the schema does the heavy lifting. The description only echoes the parameter names as inputs without adding format or constraint detail beyond the schema; 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?

States a specific verb+resource ('Estimate body fat percentage') and names the exact inputs (BMI, age, sex) and method (Deurenberg equation), which implicitly separates it from the sibling calculate_body_fat_navy. It never names that sibling explicitly, so the differentiation is inferential rather than stated.

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

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

Usage is only implied: an agent can infer it should be called when BMI, age and sex are available. There is no guidance on when to prefer this over calculate_body_fat_navy or calculate_bmi, and the closing pointer to list_bundles is a cross-reference, not a when-to-use rule.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds the method name, which does signal the underlying formula and its accuracy profile, but that largely restates the tool name and gives no further behavioral context (e.g. that hip measurement becomes mandatory for one sex).

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

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

Two short sentences with the purpose front-loaded and no filler. The second sentence about list_bundles is a slight tangent but costs little and may aid discovery.

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?

An output schema exists so return values need no explanation, annotations cover the safety profile, and the schema fully documents all six inputs. Combined with a clear purpose statement, an agent has everything needed to invoke the tool correctly.

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

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

Schema description coverage is 100%, with each of the six parameters documented including units, measurement sites, defaults and the female-only requirement for hip_cm. The description adds no parameter meaning beyond the schema, 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?

States a specific verb (Calculate), resource (body fat percentage) and qualifying method (US Navy circumference), so an agent knows exactly what is computed. It does not, however, distinguish itself from the closely-named sibling calculate_body_fat, leaving the agent to guess which body-fat tool to pick.

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 only guidance is 'See list_bundles for related sante calculators', which is a discovery pointer rather than a when-to-use statement. There is no mention of when the Navy method is preferable to calculate_body_fat, calculate_bmi, or calculate_waist_hip_ratio, and no prerequisites such as needing hip_cm for females.

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, destructiveHint=false and closed-world, so the safety profile is fully covered and the description need not restate it. The description adds domain context that output is a delay time in milliseconds per note value, but says nothing extra about precision, rounding, or bounds beyond what the schema's min/max already imply.

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

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

Two short sentences, both earning their place: the first states the transformation and its output unit, the second routes to related calculators. The core purpose is front-loaded with 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?

With an output schema present, the description need not explain return values, and both required parameters are fully documented in the schema, so the definition is sufficient to invoke the tool correctly. The remaining gap is the absence of explicit when-to-use/alternative guidance for a very narrow computation.

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 enum of note values is fully enumerated in the schema, so the structured fields already carry the parameter meaning. The description adds no syntax, range, or format detail beyond the schema, making the baseline 3 appropriate.

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

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

The description names a specific verb (Convert) and a precise resource (BPM tempo to millisecond delay times), with the note-value dimension called out, so an agent knows exactly what transformation this performs. It does not explicitly differentiate itself from adjacent music/time siblings such as calculate_frequency_note or calculate_reverb_predelay, which is the only thing keeping it from a 5.

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

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

The only guidance is a navigation pointer ('See list_bundles for related musique calculators'), which tells the agent where related tools live but not when to choose this tool over alternatives. There is no statement of prerequisites, input ranges, or when-not-to-use, leaving the agent to infer usage from the purpose sentence alone.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is fully covered. The description adds that this is a pure physics computation returning a distance in meters, which is useful, but it is otherwise thin and inaccurately claims a reaction-time input.

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

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

Four short, front-loaded sentences that lead with the computation and end with a discovery pointer; appropriately sized for a simple calculator. One sentence is spent on the inaccurate input list, which detracts slightly from otherwise tight structure.

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 annotations, a 100%-covered schema, and an output schema, most of the burden is carried structurally. Still missing: what reaction time the model assumes internally (since it is not an input), and any differentiation from calculate_distance_securite.

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

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

Schema coverage is 100%, so the two real parameters (speed_kmh, condition) baseline at 3. However, the description's 'Inputs:' list invents a third parameter ('reaction time s') that does not exist under additionalProperties:false, actively misleading the agent into an invocation that would fail.

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

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

States a specific verb and resource ('Compute reaction + braking distance by road condition') and scopes it to driver safety education, which clearly separates it from the hundreds of unrelated calculate_* siblings. The only blemish is that it advertises an input ('reaction time s') that the tool does not actually accept.

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?

Gives a domain hint ('Use for driver safety education') and routes to list_bundles for related 'auto-transport' calculators, so usage is implied. It never names or excludes a concrete alternative, notably the close sibling calculate_distance_securite (safety distance), leaving the agent to guess which to call.

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

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

Annotations already establish readOnly, idempotent, non-destructive, and closed-world behavior. The description adds that it returns ratio and meters per pedal turn, but gives no further behavioral detail such as precision or output structure.

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

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

Front-loads the purpose and stays compact. The input and return sentences are useful, though the incorrect wheel-diameter input makes one sentence harmful rather than helpful.

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 calculation tool with an output schema, the description is nearly sufficient, but it references a wheel diameter input that the schema does not accept. That inconsistency leaves the agent unable to know whether development per pedal turn can actually be computed.

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% for the two actual parameters, so the baseline would be 3. However, the description claims a third input, 'wheel diameter mm', that does not exist in the schema, and calls cog_teeth 'sprocket teeth'. This mismatch can mislead invocation.

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

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

States a specific verb and resource: compute cycling gear ratio and development per pedal turn. It clarifies the domain with 'road cycling gear analysis' but does not distinguish itself from close siblings like calculate_gear_ratio or calculate_velo_development.

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?

Gives a clear context ('Use for road cycling gear analysis') but does not say when to choose this over calculate_gear_ratio or calculate_velo_development. The pointer to list_bundles is not a usage alternative for this calculation.

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/non-destructive/closed-world, so the bar is lower, and the description adds useful context: inputs are in centimeters and the supported sizing systems. It doesn't state any preconditions or limitations (e.g. valid measurement ranges), which keeps it from a 5.

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

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

Two sentences, front-loaded with the operation and inputs, then the return shape and a cross-reference. No filler; every clause carries 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 three-parameter calculation tool, the description covers unit conventions, supported systems and output keys, which is most of what an agent needs. The main gap is routing relative to calculate_bra_size_convert, though the output schema relieves it of explaining return values.

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

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

Schema description coverage is 0%, so the description carries the burden, and it does specify the measurement unit (cm) and the three accepted system values, which maps to all three required parameters. It adds little about the semantics of the bust/underbust values themselves, but the names are largely self-describing.

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

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

States a specific verb and resource (calculate bra size) plus scope (FR/US/UK) and inputs (underbust, bust in cm), so the agent knows exactly what it computes. It does not differentiate itself from the close sibling calculate_bra_size_convert, which handles the case where a size already exists, so it falls short of a 5.

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

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

There is no guidance on when to use this versus calculate_bra_size_convert or the other apparel-size tools. The pointer to list_bundles for 'textile-mode' calculators is a soft cross-reference, not a when-to-use rule or exclusion.

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, destructiveHint=false and a closed world, so the safety profile is covered without the description. The description adds only the return shape ({FR, US, UK, EU}), which largely duplicates the output schema, and says nothing about conversion-table nuances (e.g., whether cup letters are re-mapped across systems) or failure behavior for odd band/cup inputs.

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

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

Two short sentences, purpose front-loaded, no padding. The return-shape fragment and the cross-reference are compact enough to earn their place.

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

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

With an output schema defined and rich annotations, the description does not need to explain return values or safety, and it confirms the tool returns all four systems. It is slightly thin on when this converter should be chosen over related sizing tools, but nothing required to invoke it correctly is missing.

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

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

Schema description coverage is 100% and all three parameters (band_size, cup, from_system) are documented in the schema, including the enum for from_system. The description's mention of the four systems restates the enum rather than adding meaning, so the baseline of 3 applies.

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

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

Names a specific verb (Convert) and resource (bra size) and enumerates the four sizing systems it maps between, so the agent knows exactly what it produces. It does not, however, distinguish itself from the adjacent non-conversion sibling calculate_bra_size, leaving the agent to infer the difference from the name alone.

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

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

Usage is only implied by the topic: convert a size when you need it in another system. There is no explicit when-to-use versus alternatives statement and no exclusions, though the closing pointer to list_bundles gives a mild ecosystem hint about related 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 a safe, read-only, idempotent, closed-world operation, so the safety profile needs no restating. The description adds the return categories (hydration % and dough type firm/standard/wet), which is useful, but the thresholds defining those categories are left unstated and the output schema already carries the return shape.

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

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

Three compact sentences with the formula and purpose front-loaded, then inputs and outputs. Every sentence is short and functional; the trailing list_bundles pointer is the only slightly tangential element.

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 output schema covers return values, so the description needn't explain them in depth. Purpose, inputs, and outputs are all addressed; only the category thresholds for the dough type are missing, which is a minor gap for a simple two-parameter calculator.

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

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

Schema coverage is 100%, so both parameters (flour_grams, water_grams) are already fully documented in the schema. The description's 'Inputs: flour g, water g' merely restates that, adding no syntax or unit nuance beyond the structured data. 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?

States a specific verb ('Compute'), the exact resource (baker's hydration %), and even the formula (water/flour×100), which unambiguously identifies the tool and differentiates it from generic calculators like calculate_hydration (water intake). An agent can select it without opening the schema.

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?

Says 'Use for bread recipe analysis,' which implies context but gives no explicit when-not conditions or named alternatives. The pointer to list_bundles for related 'cuisine' calculators is vague routing rather than a concrete alternative selection rule, and it does not distinguish itself from the similarly named calculate_hydration sibling.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world behavior, so the safety profile is fully covered structurally. The description adds only 'Returns break-even units and revenue,' which slightly overlaps the existing output schema and omits edge cases (e.g. behavior when price per unit does not exceed variable cost).

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?

Front-loads the core purpose in the first sentence and keeps each sentence short. The final pointer to list_bundles is arguably tangential for a computation tool, keeping it just short of perfect.

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 an output schema and full schema parameter coverage, the description covers purpose, inputs, outputs, and navigational context. The remaining gap is edge-case behavior, which the annotations and output schema partly absorb.

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

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

Schema coverage is 100%, so all three parameters are already documented in the schema. The description merely restates the inputs ('fixed costs, price/unit, variable cost/unit'), adding no formula context such as units, currency, or sign conventions beyond what the schema provides.

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

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

States a specific verb ('Compute') and resource ('break-even point in units and revenue'), so an agent immediately knows what it produces. However, it doesn't differentiate itself from any sibling calculator beyond the self-evident topic, which is fine given there is no competing break-even tool, but it stops short of the 5-tier sibling-naming example.

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

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

Explicitly names the use context ('Use for business plans and pricing decisions'), which exceeds the bare minimum of an implied use. There are no exclusions or alternative calculators named, but for a standalone finance utility the stated context is clear enough.

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

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

Annotations already declare readOnlyHint/idempotentHint true and destructiveHint false, so the safety profile is covered and the description only needs to add context. It does add a little ('Returns due date and gestation milestones'), though that is partly redundant with the output schema, and it discloses no calculation assumptions or validation rules.

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

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

Four short sentences, front-loaded with the purpose and inputs, with no filler. The list_bundles tail is the only sentence that does not clearly 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?

An output schema exists, so return values need not be explained, and the description is adequate for a two-parameter read-only calculator. But the wrong enum list plus the wrong parameter name leave the agent without a reliable picture of valid inputs, which is the one thing that matters most here.

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 0%, so the description must carry the parameter burden, and instead of clarifying it misinforms: it names 'species' (the parameter is 'animal') and lists dog/cat/horse/rabbit/cow, which contradicts the actual enum (dog/cat/rabbit/hamster). An agent following the description could pass an invalid value such as 'horse'.

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

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

States a concrete verb+resource ('Compute due date for animal breeding') and names the two required inputs, so the tool's function is unambiguous. However, it does nothing to separate itself from close siblings like calculate_dog_pregnancy, calculate_cat_pregnancy, calculate_pregnancy_due_date and calculate_due_date.

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

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

The only guidance is the thin audience note 'Use for breeders' plus an unrelated pointer to list_bundles. Nothing tells the agent when to prefer this generic tool over the species-specific pregnancy calculators in the sibling list, which is the main selection risk here.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds only 'Returns total points and mention,' which is already carried by the output schema, leaving little behavioral value beyond structured data. No auth, precision, or edge-case disclosure.

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

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

Three front-loaded sentences, with the core purpose first and no filler. The trailing list_bundles pointer is slightly tangential but does not bloat the text meaningfully.

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, the description needn't explain return values, and annotations cover the safety profile. It is complete enough for its target audience, with only the missing sibling/alternative routing as a gap.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters with ranges (e.g., socle_commun 50-400, science /50). The description's 'grades by subject, continuous control' is a loose restatement rather than added meaning, so 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?

States a specific verb+resource: 'Estimate French Brevet (DNB) score from grades and continuous-control marks.' The 'Brevet (DNB)' framing distinguishes it from the nearby calculate_bac_points sibling, though the differentiation is implicit rather than stated. Clear purpose with mild sibling ambiguity.

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

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

'Use for collège students forecasting their result' gives the target audience/context but no when-not guidance and does not name calculate_bac_points as the alternative for lycée students. The 'See list_bundles' pointer is a cross-reference to a discovery tool rather than an alternatives guide, so usage is implied rather than explicit.

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

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

Annotations already declare readOnlyHint, idempotentHint and non-destructive, so the safety profile is covered. The description adds that a waste margin is incorporated and that pallets are returned, but with an output schema present the return-value note carries limited weight and no caveats (e.g., what waste % is assumed, rounding) are disclosed.

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

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

Three short sentences, front-loaded with the core computation and efficient overall. The "Inputs:" sentence is a compact enumeration style, but its content is inaccurate, which undercuts the value of the space it occupies.

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?

An output schema exists so return values need not be explained, and the masonry framing is adequate. However, the description implies inputs that the schema does not accept and omits that the waste margin and brick size are fixed internally rather than user-supplied, leaving a real ambiguity for invocation.

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

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

The schema is fully documented and defines type/height_m/length_m, but the description's "Inputs: wall dimensions, brick size, waste %" names two inputs (brick size, waste %) that do not exist in the schema, which forbids additional properties. An agent may attempt to pass those phantom parameters and fail, so the description misleads rather than clarifies.

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

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

States a specific verb+resource+scope: compute bricks or blocks needed for a wall including a waste margin. It also distinguishes itself from the vast sibling set by pointing to list_bundles for related 'construction' calculators, so an agent can place it without opening the schema.

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?

"Use for masonry projects" gives clear usage context and the list_bundles pointer routes agents to related tools. There is no explicit when-not or alternative masonry calculator named, 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, idempotentHint, destructiveHint=false and openWorldHint=false, so safety and determinism are covered without the description. The description adds that inputs are object mass/volume plus fluid density and that a float/sink verdict is produced, but says nothing about unit handling, the default fluid, or edge cases like zero volume.

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

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

Four short sentences, front-loaded with the purpose before inputs, outputs and the cross-reference. Slight filler in the trailing list_bundles pointer, but overall tight.

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, return values need not be explained, and annotations carry the safety profile; the description covers purpose, inputs and result shape. It is only short on the default-fluid assumption and unit conventions, which matters for a computation 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 all three parameters carry their own unit documentation, so the baseline is 3. The description repeats 'object mass/volume, fluid density' without adding anything the schema lacks, notably that fluid_density defaults to 1000 (water).

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

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

States a specific verb (compute) and resources (buoyancy force, displaced volume, floating analysis) and anchors the method with '(Archimedes)'. No sibling in the list covers buoyancy, so the tool is unmistakable once matched against the catalog.

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?

'Use for physics or shipping' gives a loose domain hint but no when-not conditions, prerequisites, or a named alternative to compare against. The pointer to list_bundles is a discovery aid, not usage routing.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and closed-world behavior, so the safety profile is covered. The description adds little beyond that (no auth, limits, or edge-case behavior), which is acceptable for a pure calculator but not rich context.

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

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

Purpose is front-loaded and the text is short and scannable. However, the 'Inputs:' and 'Returns:' sentences largely duplicate the input schema and the existing output schema, so a small amount of redundancy is present.

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

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

For a simple three-parameter calculator with an output schema and full annotations, the description supplies enough to call it correctly. It also cross-references list_bundles for related finance calculators, adding useful discovery 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 coverage is 100%, so the schema already documents all three parameters with EUR units. The description's 'cash on hand, monthly expenses, monthly revenue' merely restates these inputs without adding syntax or interpretation, matching the baseline 3 for high-coverage schemas.

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

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

States a specific verb ('Compute') and resource ('startup monthly burn rate and runway'), which is clearly distinct from neighboring finance calculators like calculate_churn_rate or calculate_break_even. It does not explicitly contrast itself with any sibling, so it stops just short of a 5.

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

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

Provides a clear when-to-use statement ('Use for fundraising or expense control'), giving the agent concrete scenarios. It offers no exclusions or named alternatives, which keeps it from a 5.

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

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

Annotations already declare readOnly/idempotent/non-destructive/closed-world, so the safety profile is covered. The description adds real domain context beyond them: the governing standard (NF C 15-100), the residential scope, and the fact that a required section is the return value. It does not cover edge cases like minimum section rules or multi-phase wiring.

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?

Front-loaded with the operation and standard, then inputs and return value, ending with a pointer to a sibling listing tool. The 'Inputs: ...' clause is terse but earns its place; nothing is padded.

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

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

Output schema and annotations mean the safety and return-shape burden is off the description's shoulders, and it correctly supplies the standard and domain. The unresolved kW-vs-W discrepancy and the silence about calculate_cable_section_electrical leave two gaps an agent must guess through.

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

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

Schema coverage is 100%, so baseline would be 3, but the description actively misstates the input model: it says 'power kW' while the schema parameter is power_w in watts, and omits that voltage and max_drop_pct have defaults. A unit mismatch of 1000x is worse than silence and can cause a wrong invocation.

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

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

States a specific verb and resource ('Compute electrical cable cross-section (mm²)') and anchors it to a named standard (NF C 15-100), which is genuinely distinguishing. However, it never acknowledges the near-identical sibling calculate_cable_section_electrical, so an agent cannot tell which of the two to pick from the description alone.

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

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

'Use for residential wiring' implies the applicable domain but gives no when-not conditions or explicit alternative routing. The only routing hint ('See list_bundles for related construction calculators') points to a discovery tool rather than to a competing calculator, so conflict resolution is left implicit.

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, destructiveHint=false, and openWorldHint=false, covering the safety profile. The description adds the return fields, which is useful context, but this may overlap with the output schema and does not disclose formula assumptions or 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?

Two short sentences, front-loaded with the main action, followed by return values. The list_bundles pointer is somewhat unnecessary for invoking this specific tool but does not bloat the definition significantly.

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

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

The tool is simple, annotations cover safety, and the schema and output schema are rich. However, the description fails to differentiate this from the sibling calculate_cable_section and omits any note on electrical assumptions, which is a meaningful gap for selecting the correct calculator.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters with units and defaults. The description lists the same inputs without adding syntax, constraints, or electrical assumptions beyond what the schema provides.

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

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

States a specific verb and resource: calculate cable section, and lists the main inputs. However, it does not distinguish this tool from the sibling calculate_cable_section, so an agent cannot tell them apart from the description alone.

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

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

Provides no when-to-use or when-not-to-use guidance, and does not name alternatives. The reference to list_bundles is vague and does not help select between this and other 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 read-only, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds domain-meaningful context beyond that: the interpretation threshold (target ≥3.0) and the fact that a health verdict accompanies the ratio. It omits edge-case behavior (e.g. LTV=0), keeping it from a 5.

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

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

Four short sentences, front-loaded with the core computation before usage, inputs, and output. The 'Inputs:' sentence mildly duplicates the schema and the bundle pointer is incidental, so it is efficient but not maximally tight.

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

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

For a 2-parameter read-only calculator with a 100%-covered schema, an output schema, and full annotations, the description supplies the one thing structured fields cannot: the domain benchmark for interpreting the result. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100%, with both cac and ltv documented including EUR units, so the schema carries the semantic load. The description only restates them as 'Inputs: total CAC, LTV' and adds no format or constraint detail, matching the baseline 3.

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

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

States a specific verb (Compute) and a precise resource (CAC vs LTV ratio), and the acronym is spelled out so an agent knows exactly what is calculated. It is readily distinguishable from neighbor tools like calculate_churn_rate or calculate_roi.

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?

Gives clear context ('Use for SaaS unit economics analysis') and even a benchmark target (≥3.0), so the agent knows when this applies. It does not name a competing tool or state exclusions, and the pointer to list_bundles is about discovery rather than a true alternative, so it falls short of a 5.

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