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

With no annotations, the description carries the transparency burden. It discloses the input format (YYYY-MM-DD) and the return value (years plus exact days), but does not mention behavior for invalid dates, future birth dates, leap years, or the exact return structure. This is adequate for a simple calculator but not comprehensive.

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

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

The description is three short sentences that front-load the purpose, then provide input format and output details. There is no fluff; every sentence earns its place.

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

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

Given there is no output schema, the description states the return value as 'age in years + exact days' but does not clarify the precise shape (e.g., separate fields, string, object). It also omits edge-case handling. This is moderately complete for a single-param tool but leaves some details to the agent's 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 0%, so the description must compensate for the bare birthDate string parameter. It adds crucial semantics by specifying the format (YYYY-MM-DD) and its purpose in the tool. This is meaningful addition beyond the schema.

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

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

The description clearly states the tool computes age from a birth date and specifies the output as years plus exact days. It is distinct from the generic converters and date_difference_calculator, though it does not explicitly name alternatives or contrast with them.

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

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

Usage is implied by 'Age from birth date' – an agent can infer it is for age calculation. However, there is no explicit guidance about when to choose this tool over the similar date_difference_calculator or any exclusions, leaving some ambiguity.

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

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

No annotations are provided, so the description alone must carry the behavioral burden. It states the conversion action and unit set, but does not disclose return format, handling of invalid units, precision/rounding, or case-sensitivity of unit strings. It is minimally informative but not misleading.

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

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

The description is two short sentences with no filler. It front-loads the core purpose and unit set, then lists the required inputs. Every part 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 conversion tool with no output schema, the description covers the essential inputs and unit domain. It is missing a clear statement of the output representation and any constraints around unit strings, which would help an agent invoke it correctly in ambiguous cases.

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

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

The schema has 0% coverage and no enums, so the description must compensate. It does list the relevant units and names all three parameters, giving agents the allowed unit vocabulary. However, it does not explicitly map value/from/to to their roles or clarify accepted input formats beyond that list.

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: 'Convert area,' and enumerates the exact unit pairs (mm²/cm²/m²/km² ↔ in²/ft²/yd²/acre/ha). This clearly distinguishes it from sibling converters like length_converter or temperature_converter.

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

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

The description implies usage by naming area unitscars, but it does not explicitly say 'use this for area conversions' or contrast it with alternatives. The sibling list makes the distinction inferable, yet there is no direct when-to-use or when-not-to-use 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention whether the operation is read-only, what the return value looks like, any side effects, or assumptions (e.g., base-1024 vs base-1000). For a simple conversion tool this may be less critical, but the absence of any behavioral details leaves the agent guessing.

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

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

The description is extremely concise, a single sentence that front-loads the main action and units. However, it is so sparse that it sacrifices necessary detail. It earns points for brevity but loses for under-specification, as key parameter semantics and usage context are missing.

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

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

For a tool with no annotations, no output schema, and minimal schema descriptions, the description is insufficient. It does not cover the return format, unit case sensitivity, or conversion conventions. While the tool is conceptually simple, the description leaves too much to inference, making it incomplete for an agent that needs to call it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It lists 'Input: value, from, to' but only repeats the parameter names from the schema. It does not explain that 'from' and 'to' expect unit strings like 'KB' or 'MB', nor does it clarify the meaning of 'value'. The unit list in the first sentence gives a hint, but it is not explicitly mapped to the parameters, leaving room for misinterpretation.

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

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

The description clearly states the action ('Convert') and the resource (data storage units b/B/KB/MB/GB/TB). This distinguishes it from sibling converters like length_converter or weight_converter, which handle different unit families. It is specific and not a tautology, though it could be more explicit about converting between the listed units.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. While the unit list implies it is for data storage, there is no mention of when not to use it or how it compares to sibling converters. An agent must infer applicability from the unit names alone, which is insufficient for clear 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the tool calculates days/weeks/months but does not disclose the output format (e.g., whether it returns a single number, multiple values, or an object), nor any edge cases or behavior on invalid dates. This is a significant gap for a calculator tool.

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

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

The description is extremely concise—a single sentence that front-loads the core purpose. There is no wasted text, and the input format hint is included. However, the brevity contributes to the lack of completeness, so it's not 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?

The description is incomplete for a tool with no output schema, no annotations, and 0% parameter coverage. It fails to specify the return value, which is critical for an agent to interpret results. It also doesn't mention whether it returns all units (days, weeks, months) or a choice, or any behavior for edge cases. The description is too sparse to fully guide 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?

The description adds the date format YYYY-MM-DD, which is useful given the schema has no descriptions. However, it doesn't explain the meaning of startDate and endDate beyond the obvious, nor does it clarify ordering or validation. Since schema coverage is 0%, this is partial compensation but insufficient for full clarity.

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

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

The description clearly states the tool computes the difference between two dates in days, weeks, or months. It is specific about the resource (dates) and the operation (difference calculation), and it is distinguishable from sibling tools like age_calculator, though it doesn't explicitly call out alternatives.

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

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

The description implies the usage scenario (computing date differences) but provides no explicit guidance on when to choose this tool over alternatives or any exclusions. For example, it doesn't clarify when to use this versus age_calculator, though the purpose makes it somewhat obvious. Lacks explicit routing or when-not-to-use 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the conversion action and input format but does not disclose whether conversions are case-sensitive, what unit string formats are accepted (e.g., 'j' vs 'J', 'kj' vs 'kJ'), whether the operation is read-only, or what the output format looks like. This is a meaningful gap for a tool that depends on exact string matching.

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

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

The description is compact and front-loaded with the core purpose ('Convert energy'), followed by the supported unit families and the required input shape. Every sentence earns its place, though the input format sentence is slightly terse and could be integrated more naturally.

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

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

Given the tool has no annotations, no output schema, and zero schema description coverage, the description is under-specified. An agent needs to know the exact accepted unit strings, whether the conversion is bidirectional, and what the result format is. The description provides the unit families but leaves critical invocation details unspecified.

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 compensate for the schema's lack of parameter documentation. The description names the three parameters ('value, from, to') and implies their roles, but it does not explain the expected unit string formats, the range/type of value, or the meaning of 'from' and 'to' beyond the obvious. This is minimal compensation for a schema with zero descriptions.

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

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

The description states a specific verb ('Convert') and resource ('energy') with the supported unit families (j/kj, cal/kcal, wh/kwh, btu). It clearly distinguishes from sibling converters by naming the energy unit types, though it doesn't explicitly name a sibling 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?

The description implies usage by listing the required inputs ('Input: value, from, to'), which tells an agent what to provide. However, it does not state when to prefer this tool over other converters or provide any exclusion criteria, leaving usage context mostly 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?

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only states the conversion operation and input fields. It does not mention any constraints, error handling, edge cases (e.g., unknown units, case sensitivity, rounding), or the output format. For a simple converter this might be implied, but the description adds no behavioral detail beyond the schema, leaving the agent to infer the behavior.

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

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

The description is extremely concise: two sentences covering the purpose, the units, and the input parameters. It is front-loaded with the main action and includes no fluff or redundancy. Every word adds value, making it appropriately sized for a simple conversion tool.

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

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

The tool is simple (a unit converter) with no output schema or annotations. The description provides the essential information: the units and the parameter names. However, it does not describe the return value (e.g., the converted number), error behavior for invalid units, or any formatting details. For a minimal tool this is adequate, but it could be more complete by stating that the output is the converted numeric value and that unsupported units will cause an error.

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 compensate. It lists the valid unit strings (mm, cm, m, km, in, ft, yd, mi) and states the input order (value, from, to), which helps an agent understand that 'from' and 'to' take these unit strings and 'value' is numeric. However, it does not explicitly state that these are the only acceptable values for from/to, nor does it clarify case sensitivity or aliases, leaving some ambiguity.

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

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

The description clearly states 'Convert length' and lists the specific units (mm/cm/m/km ↔ in/ft/yd/mi), making the tool's purpose unambiguous. It distinguishes itself from sibling converters like weight_converter or temperature_converter by naming the unit types, so an agent can immediately identify this as the length-specific tool.

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

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

The description provides clear context by naming the units and the input pattern ('value, from, to'), implying the agent should use this tool for length conversions. While it doesn't explicitly mention alternatives or exclusions, the sibling tool names (weight_converter, temperature_converter, etc.) make the usage context obvious, and the description's specificity removes ambiguity about when to select it.

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?

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It does not state what the tool returns, whether it mutates anything, how it handles a missing operation parameter, or any edge cases. The description simply lists inputs and operations, providing no behavioral details beyond the schema.

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

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

The description is extremely short and could be considered under-specification rather than concise. It lacks any clear sentence structure, does not front-load the most critical information, and omits necessary context. While it does not waste words, it fails to earn its place by providing adequate information.

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

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

With 3 parameters, no annotations, no output schema, and 0% schema description coverage, the description is severely incomplete. It does not explain default behaviors, return values, or error handling. An agent cannot reliably invoke this tool correctly based on the provided information alone.

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 compensate by explaining parameter meanings and relationships. While it lists the parameters ('value', 'percent', 'operation') and repeats the enum values, it does not clarify how these parameters interact (e.g., what 'increase' does with 'value' and 'percent'). It adds minimal semantic value beyond the schema itself.

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 identifies the resource ('Percentage') and lists the operations ('of / increase / decrease / whatPercent') but provides no verb or complete statement of purpose. It reads more like a collection of keywords than a clear explanation of what the tool does, making it difficult for an agent to understand the tool's function at a glance.

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

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

There is no guidance on when to use this tool versus the sibling calculators (e.g., tip_calculator, date_difference_calculator). The description does not mention prerequisites, alternatives, or conditions under which this tool is the appropriate choice. The agent is left to infer usage entirely from the tool name and sibling context.

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

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

With no annotations, the description carries the burden of disclosing behavior. It states the core operation (conversion between power units) and required inputs, which is adequate for a simple stateless converter. It does not mention behavior for invalid units, case sensitivity, or rounding, but these are less critical for this tool type.

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

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

The description is two sentences with no filler: the operation, unit groups, and input parameter names are all front-loaded and easy to parse.

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

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

For a simple three-parameter converter, the description names all parameters and unit categories, enabling a basic invocation. However, with no output schema, no enums, ambiguous unit tokens, and no exact accepted-value format, there are gaps that could lead an agent to call the tool incorrectly.

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 there are no enums, so the description must clarify the parameters. It names value, from, and to, and lists accepted unit groups, adding meaning beyond the bare schema. However, the unit tokens are ambiguous ('mw', 'tr') and no exact string format or case rules are provided, leaving the compensation incomplete.

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

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

The description uses a specific verb ('Convert') and clearly identifies the resource ('power') with concrete unit groups (mw/w/kw, hp, btu/h, tr), which distinguishes it from sibling converters like length_converter or temperature_converter. It loses a point because some unit tokens ('mw', 'tr') are ambiguous.

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

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

The description implies the intended use case by naming 'power' and listing power unit categories, making it obvious which sibling tool to select. However, it does not explicitly state when not to use it or point to alternatives for other quantity types.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action (convert) but does not disclose what the output looks like, whether it is reversible, how invalid units are handled, or any side effects. For a read-only conversion tool, the lack of output format description is a notable omission.

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

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

The description is one short sentence that front-loads the purpose and then lists inputs. It is extremely concise with no filler words, earning a 5 for conciseness.

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

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

The tool is simple (3 params, no output schema) but the description is incomplete. It does not specify the exact unit strings expected, the output format, or any error behavior. Without enums or schema descriptions, the agent must infer too much to call this tool correctly.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It only lists 'value, from, to' without explaining that value is a number, from is the source unit, and to is the target unit. The unit list implies the format, but the exact accepted strings (e.g., 'mph' vs 'mi/h') are not specified, leaving ambiguity.

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

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

The description clearly states the tool converts speed and lists the supported units (m/s, km/h, mph, knots, ft/s), which distinguishes it from sibling converters like length_converter or weight_converter. The verb 'Convert' and resource 'speed' are specific, but it doesn't explicitly contrast with siblings, so a 4 is appropriate rather than 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 tool versus the other converters, nor any exclusions or alternatives mentioned. The implication that it's for speed conversions is present through the unit list, but no explicit 'use for speed only' or reference to sibling tools is given. For a converter family, this is a 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the conversion action and input format but does not disclose any side effects (e.g., whether it is a pure function, no external calls, or return value format). For a simple converter, this is minimal but acceptable; however, it lacks any statement about the nature of the operation beyond the conversion itself.

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

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

The description is a single, efficient sentence that front-loads the purpose and then provides a compact input specification. Every element serves a purpose, with no filler or redundant information.

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

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

For a simple converter with no output schema, the description provides the essential information: what it does, the input parameters, and the allowed values. It does not explicitly describe the return format, but that is typically implied for converters. The low complexity means this is largely complete, though a brief note on return value would make it fully complete.

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

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

The schema has no descriptions and no enums, so the description's hint that 'from' and 'to' accept 'c/f/k' adds critical meaning beyond the raw schema. It compensates for the 0% schema description coverage by clarifying the allowed values and their shorthand notation, which is essential for correct invocation.

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

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

The description clearly states the tool converts temperature between Celsius, Fahrenheit, and Kelvin, with a specific verb ('convert') and resource (temperature). It naturally distinguishes itself from sibling converters (length, weight, etc.) by naming the exact domain, leaving no ambiguity about what it does.

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

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

The description implies usage for temperature conversion but does not explicitly state when to use it vs. alternatives or provide exclusions. However, the tool name and description make the intended context obvious among the sibling converters, so there is clear context without explicit 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Convert time' and lists inputs, but does not disclose side effects (none expected), whether the operation is read-only, edge-case behavior (e.g., negative values), or the output format. For a non-mutating tool this is less critical than for a mutation tool, but the description still fails to state that it is a pure calculation or what the return looks like.

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

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

The description is highly concise: two short sentences, front-loaded with the core purpose and unit list. Every word adds information, and there is no fluff or redundancy. It could be slightly more structured by explicitly tying inputs to parameters, but overall it is efficient.

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

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

For a simple 3-parameter converter with no output schema, the description is adequate but has clear gaps. It does not explicitly state that from/to accept the listed abbreviations, nor describe the output value. An agent could likely call it correctly by inference, but the description is not fully self-sufficient given the absence of annotations and parameter descriptions.

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

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

With 0% schema description coverage, the description must compensate for missing parameter documentation. It merely lists input names ('value, from, to') without explaining that value is the numeric amount and from/to accept the unit abbreviations listed earlier. It does not explicitly map the unit strings to the from/to parameters, leaving the agent to infer that from and to should use those abbreviations. This is minimal added value over the raw schema.

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

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

The description states a specific verb ('Convert') and resource ('time') and enumerates the exact units supported (ms/sec/min/hr/day/week/month/yr). This clearly differentiates it from sibling converters like length_converter or weight_converter without needing to open schemas.

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

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

The purpose is clear enough that an agent can infer when to use it (time conversion), and the unit list implies coverage of time-only conversions. However, it does not explicitly name sibling alternatives or state 'use this for time, not for length/weight,' so exclusion guidance is only implied, not 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?

With no annotations, the description carries the behavioral disclosure burden. It usefully exposes defaults (tipPercent 15, people 1), but it does not state the calculation formula, rounding behavior, or whether the result is the tip amount, total, or per-person share.

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 carry the purpose, parameter list, and defaults with no repetition or filler. Every word contributes to correct invocation.

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

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

For a simple calculator the input list and defaults are sufficient to make a call, but the lack of an output schema means the description should clarify what is returned (e.g., per-person total including tip). Edge cases like people=0 or non-numeric inputs are not addressed.

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 compensates by naming all three parameters and adding default values not present in the schema. It does not spell out units or validation, but the roles of billAmount, tipPercent, and people are clear from context.

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

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

The description begins with a specific verb and object—'Calculate tip and split bill'—and the tool name makes its financial scope obvious. This clearly distinguishes it from sibling converter/calculator tools such as percentage_calculator or length_converter.

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

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

The intended usage context is clear: use it when computing a tip and dividing a bill, and it accepts billAmount with optional tipPercent and people. There is no explicit exclusion or mention of alternatives, but the context is unambiguous enough to route an agent correctly.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It only states the conversion action and input names, but does not mention the return format (e.g., a number), error handling for invalid units, case sensitivity, or any side effects. As a simple read-only conversion, this is a minimal gap, but the description does not explicitly say it is safe or how it behaves on failure.

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

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

The description is two sentences, front-loads the purpose and unit list, and has zero wasted words. It efficiently conveys the tool's scope and input requirements without redundancy.

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

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

The description covers the core purpose, input parameters, and valid unit values. However, it does not specify the output format (e.g., a numeric result) or describe error behavior for invalid inputs. Given that there is no output schema and no annotations, these details would help an agent call the tool correctly and interpret results. The description is adequate for a simple converter but leaves some behavioral gaps.

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

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

The schema has 0% description coverage, so the description must compensate. The first sentence lists all valid unit strings for the 'from' and 'to' parameters, which is essential information not present in the schema. This adds meaning beyond the schema, though it does not clarify the 'value' parameter beyond its type (number) or explain that from and to must be one of the listed strings. The unit list is a significant contribution.

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

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

The description states a specific verb ('Convert') and resource ('volume'), and lists the supported units (ml/l/cup/tbsp/tsp/floz/pint/quart/gallon), which clearly distinguishes it from sibling converters like length_converter or weight_converter. The unit list is concrete and unambiguous, so an agent can immediately identify this tool for volume conversions.

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

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

The description implies usage through the phrase 'Convert volume' and the listed units, but it provides no explicit guidance on when to use this tool versus other converters, nor any exclusions (e.g., 'for length use length_converter'). The input line 'Input: value, from, to' only names the parameters and does not give context about selection criteria.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'Convert weight' and lists input parameters, without revealing any side effects, return format, error handling, or limitations. For a simple converter, this is insufficient; it doesn't even clarify whether conversion is bidirectional or what happens with invalid units.

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 very concise, with two short sentences that contain no fluff. It front-loads the unit scope. However, it is arguably too terse, omitting essential parameter details, but that is more a completeness issue than a conciseness one. It earns points for being efficient.

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

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

Given the tool's simplicity, one might expect a brief description, but the schema provides no parameter descriptions, no output schema, and no annotations. The description only lists units and parameter names, leaving out critical details like the exact accepted unit strings (e.g., 'mg' vs 'milligram'), whether all conversions are supported, and what the output format is. This is inadequate for an agent to call it correctly without guessing.

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 explain parameter meaning. It lists units in the conversion line but does not explicitly map them to the 'from' and 'to' parameters. It merely says 'Input: value, from, to.' without defining each parameter's expected type or allowed values, leaving the agent to infer that from/to accept unit strings. This is ambiguous and insufficient for a zero-coverage schema.

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

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

The description clearly states the tool's function ('Convert weight') and lists specific units (mg/g/kg/tonne ↔ oz/lb/st), which distinguishes it from sibling converters for length, temperature, etc. This is a specific verb+resource with enough detail to identify its domain.

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

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

The description provides clear context that this is for weight conversion, implied by the unit list. It does not explicitly name alternatives or exclusions, but the unit scope makes it obvious when to use it versus other converters. No explicit 'when not to use' is given, so it lacks exclusions.

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