UK Data: Everyday calculators

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

The annotations already establish that this is a safe, idempotent, non-destructive read operation. The description adds useful context about rounding to a specified precision and a credit cost, though it omits edge-case behavior such as division by zero at-bats.

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 compact sentences, front-loads the calculation, then states the return behavior and cost. There is no unnecessary wording.

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

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

For a simple calculator with full schema coverage and annotations covering safety, the description supplies the formula, output rounding, default precision, and cost. Nothing essential for invoking it correctly is missing.

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

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

Schema coverage is 100%, so parameter definitions are already documented. The description adds meaning by explaining the formula using hits and at-bats and confirming the default precision of 3 decimal places, but it does not clarify zero at-bats or precision bounds.

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: it calculates a baseball player's batting average from hits divided by at-bats. This distinguishes it from generic siblings such as average or calculate.

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

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

The intended use is clear from the baseball-specific formula and required inputs. It does not explicitly say when to choose this over generic calculation tools or mention exclusions, 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.

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 two useful behavioral facts beyond them — the 1-credit cost and the dependence on the current date — but says nothing about rounding/precision, timezone of 'current date', or the returned value.

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

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

Two compact sentences with the purpose first and the cost parenthetical last; no filler or redundant restatement.

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, no-output-schema utility, this is close to sufficient: purpose, input basis, and cost are all given. Minor gaps remain around precision and the exact form of the returned age.

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 already documents the required ISO (YYYY-MM-DD) format. The description only restates that a birth date is needed, adding no meaning beyond the schema.

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

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

States a specific verb and resource ('Calculates a person's age in years') plus the basis ('based on their birth date and the current date'), which cleanly separates it from the many other calculate_* siblings that have generic or unnamed purposes.

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

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

The usage is strongly implied by the description, but there is no explicit when-to-use framing, no mention of what to do instead for related questions (e.g. is_leap_year, format_date), and no prerequisites 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 readOnly, idempotent, and non-destructive, so safety is covered. The description adds a credit cost ('cost: 1 credit'), which is genuinely useful context an agent cannot get from structured fields, though nothing is said about output units or rounding.

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: purpose plus formula first, then cost in parentheses. Nothing is redundant and the most decision-relevant information leads.

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 stateless calculator with a self-evident output and a fully documented schema, the description covers purpose, units, and cost. The only minor gap is not stating the output unit (kg/m²) or precision, which is low-risk 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 coverage is 100% and the schema already documents each parameter with units and defaults. The description restates the metric/imperial unit pairing but adds no format, range, or validation detail beyond what the schema provides, 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 ('Calculates Body Mass Index (BMI)') and includes the exact formula, which unambiguously distinguishes it from the many other calculate_* siblings such as calculate_area or calculate_calorie_intake.

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 unit systems and required inputs imply when the tool applies, but there is no explicit when-to-use or when-not-to-use guidance, and no pointer to alternatives such as convert_units for callers who only need unit conversion.

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

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

With annotations already declaring read-only, idempotent, non-destructive, and open-world behavior, the description adds useful context: it names the formula, describes the returned values, and discloses a 1-credit cost. It does not mention assumptions or limitations of the equation, but the key behavioral facts beyond the annotations are present.

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

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

The description is two efficient sentences with the purpose and outputs front-loaded. The credit-cost note is short and useful, and there is no redundant wording.

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

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

For a read-only calculator with a fully documented schema and no output schema, the description explains the calculation method, outputs, and cost. It is nearly complete, though it could briefly note assumptions or typical use limits of the Mifflin-St Jeor equation.

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

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

Schema description coverage is 100%, so each parameter already has documentation. The description only refers generally to personal characteristics and fitness goals and does not add per-parameter meaning beyond the schema; baseline 3 is appropriate.

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

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

The description states a specific verb and resource: calculates recommended daily calorie intake. It also names the Mifflin-St Jeor equation, macronutrient distribution, and the exact outputs, making it distinguishable from generic calculators such as calculate_bmi.

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 personal characteristics and fitness goals, but it does not explicitly say when to use this tool versus alternatives such as calculate_bmi. There are no exclusions or prerequisites, so the agent must infer the appropriate context.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, so safety is largely covered. The description adds behavior the annotations do not: it returns the mean rounded to 2 decimal places (valuable since there is no output schema) and states the cost of 1 credit. Minor gap: no mention of behavior for empty or invalid grade 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?

Two short sentences with zero filler: purpose and scale first, then return value, precision, and cost. Nothing is duplicated or padded, and the most decision-relevant information is front-loaded.

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

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

For a one-parameter, read-only computation with no output schema, the description covers purpose, input domain, output shape (mean rounded to 2dp), and cost. The remaining omission is input handling (empty list, out-of-range values, weighting), which is a modest gap rather than a blocking one.

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 is already documented as a numeric list on the 0.0–4.0 scale, so the description can only restate it. The description does reinforce the 4.0 scale and the "mean of all grades" semantics, but adds no format or edge-case 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?

"Calculates the Grade Point Average (GPA) from a list of grade points on a 4.0 scale" names a specific verb (calculates), a specific resource (GPA), and the input domain (grade points on a 4.0 scale). An agent can distinguish it from generic siblings like average or calculate_median because the GPA/4.0-scale framing is explicit.

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

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

The description never says when to prefer this over the many neighboring arithmetic tools (average, calculate_grade, calculate_median, calculate_standard_deviation). There are no exclusions, no prerequisites, and no alternative-selection guidance; the agent must infer usage from the name alone.

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

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

Annotations already establish readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered by structured data. The description adds one genuinely useful behavioral fact beyond them: the call costs 1 credit. It does not disclose the actual grade cutoffs, which is the one behavioral detail an agent cannot infer.

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

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

One front-loaded sentence covering the transformation and the scale, with the cost note appended. No filler, though the parenthetical cost could be separated so it does not compete with the primary statement.

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 pure calculator with no output schema, the description is nearly sufficient — the return value (a letter grade) is clear. The missing piece is the mapping itself: 'standard grading scale' is ambiguous (90+ = A? 93+?), and out-of-range handling is unstated, which matters because the schema has no required-field enforcement.

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 single parameter is already documented as a 0-100 percentage; the description merely restates 'numerical percentage score'. It does not resolve the schema's union type (number or string) or clarify what happens for out-of-range values, so it adds little 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 both the input and output resources: converting a numerical percentage score into a letter grade on an A-F scale. This also implicitly distinguishes it from calculate_gpa, the nearest sibling, which works on a grade-point scale rather than percentages.

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 pure-function nature of the tool (feed it a percentage, get a letter), but there is no explicit when-to-use guidance, no pointer to calculate_gpa for GPA-style conversions, and no statement of prerequisites. Nothing misleads, but nothing routes the agent either.

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

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

Annotations already cover safety (readOnlyHint, idempotentHint, destructiveHint=false), so the description's value is in the extras it supplies: it discloses the return payload (tip amount and total including tip) and a per-call cost of 1 credit, neither of which appears in the annotations. It does not address rounding behavior or how string inputs are coerced, which are the remaining behavioral unknowns.

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 front-loaded sentences plus a parenthetical cost note; every clause carries information (what it computes, what it returns, what it costs) and there is no filler or redundancy.

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

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

For a two-parameter arithmetic tool with full schema documentation and complete safety annotations, the definition is nearly sufficient — it even covers the return values despite there being no output schema. Minor gaps remain around rounding/precision and negative or zero inputs, which matter for a money calculation.

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 bill_amount and tip_percentage fully documented including units and the "15 = 15%" convention. The description restates the two inputs ("bill total and tip percentage") without adding format, rounding, or range detail, so the schema does the heavy lifting and the baseline of 3 applies.

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

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

The description names a specific verb and resource ("Calculates the tip amount") and states the two inputs it consumes, so the agent can tell this apart from siblings like calculate_tax or calculate_discount on subject matter alone. It stops short of explicitly contrasting with those nearest 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?

Usage is only implied: the domain (tipping) makes the intended scenario obvious, but there is no statement of when to prefer this over calculate_tax, calculate_discount, or the generic calculate tool. No prerequisites or exclusions 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?

The annotations already declare read-only, idempotent, non-destructive behavior. The description adds useful context beyond that: supported strftime tokens, strict rejection of impossible dates such as 31 February, and a 1-credit cost. It does not describe the exact return shape, but behavior is otherwise well covered.

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 front-loaded sentences plus a short cost note, with no wasted wording. The most important information, format conversion and supported strftime codes, comes first.

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

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

This is a low-complexity formatting tool with rich annotations and full schema coverage. The description covers the format syntax and invalid-date behavior sufficiently for an agent to call it correctly, and no output schema is needed.

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

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

Schema description coverage is 100%, so the baseline would be 3. The description still adds meaning by listing supported strftime codes and clarifying that time is optional while impossible dates are rejected rather than normalized.

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 a date, with optional time, from one format to another using strftime codes. It is clear, but it does not explicitly distinguish itself from date/time siblings such as convert_time.

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

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

The use case is implied by the description, but there is no explicit when-to-use or when-not-to-use guidance, and no alternative tools are named. It is the minimum viable level for a straightforward formatting 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 readOnly, idempotent, non-destructive, so the safety profile is covered. The description adds real value beyond that: the deterministic algorithm (so results are verifiable) and the '1 credit' cost, which is operationally relevant. It stops short of stating the return form (boolean) explicitly, though 'Checks if' strongly implies it.

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

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

One tight sentence plus a parenthetical cost note. The core purpose is front-loaded and every clause earns its place by either specifying the rule or disclosing cost.

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 pure function with no output schema, the definition is essentially complete: it states the rule, the input, and the cost. The only minor gap is that the boolean return type is only implied, not stated.

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 'year' parameter is already documented with an example (2024). The description adds no syntax, range, or format detail beyond the schema, so the baseline 3 applies — the schema does all the parameter work here.

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 ('Checks') and resource ('a given year') and pins down the exact rule applied (Gregorian: divisible by 4, century exception, divisible by 400). This is unambiguous and clearly distinct from the many generic 'calculate_*' siblings.

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

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

Usage is implied by the narrow scope — an agent can infer it should call this when it needs a leap-year determination and nothing else. However, there is no explicit when-to-use/when-not guidance, no statement of alternatives, and no note that the rule is Gregorian-only versus other calendar conventions.

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