BoringToolsKit

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

Annotations already declare readOnlyHint=true, openWorldHint=false, and destructiveHint=false, so the safety profile is fully covered and the bar is lower. The description adds that the tool also computes one-year interest and ending balance, disclosing the derived output set, but says nothing about edge cases such as zero-rate periods or invalid compounding values.

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

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

A single sentence of appropriate length, front-loaded with the primary computation and then the secondary outputs. No filler, no redundancy.

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

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

With no output schema, the description usefully states what is returned (APY, one-year interest, ending balance), and annotations cover the safety profile. Parameter documentation is complete via the schema. Only the lack of guidance on how this differs from the other interest/yield siblings leaves a small 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 all three parameters are already documented in the schema, which sets the baseline at 3. The description reinforces the meaning of 'nominal rate' and 'compounding frequency' and clarifies that 'deposit' is an example amount, but adds no format, unit, or range detail beyond what the schema states.

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

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

The description gives a precise verb ('Compute') and resource ('annual percentage yield'), and enumerates the exact inputs (nominal rate, compounding frequency) and outputs (one-year interest, ending balance). It is clear a compound-yield calculation, though it never explicitly distinguishes itself from close siblings like compound_interest, simple_interest, or rule_of_72.

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 guidance and no mention of alternatives, which matters here because several siblings (compound_interest, simple_interest, rule_of_72) overlap in domain. The agent must infer that this tool is for the APY/APR-style effective yield rather than raw interest accumulation.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, which fully covers the safety profile of a pure computation. The description adds only that the result includes a percent time change; it says nothing about response format or how edge cases (speed 0, negative) behave.

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

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

A single front-loaded sentence that names the computation and the two outputs with no filler. 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?

With no output schema, the description carries the burden of describing returns and does so at a high level (new duration plus percent time change). It leaves output units and the speed/duration direction convention unstated, which is a minor but real 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 both parameters (speed as a multiplier, duration in seconds) are already fully documented. The description mentions playback speed and duration conceptually but adds no constraint or format 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 (compute) and a precise resource (new audio duration at a given playback speed), plus the secondary output (percent time change). The domain (audio) is clear enough to separate it from the finance/health calculator siblings without needing to name any of 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?

No explicit when-to-use, when-not-to-use, or alternatives are given. For a self-contained arithmetic calculator the usage is strongly implied, but the description never states a condition or exclusion that would help an agent choose it over, say, a generic percentage 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 cover the safety profile (readOnlyHint=true, openWorldHint=false, destructiveHint=false). The description adds only the word 'Estimate', implying an approximate result, but omits details such as whether taxes, fees, or insurance are included.

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

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

A single sentence, front-loaded with the purpose, followed by a compact list of inputs. There is no filler or repetition, and every element helps identify the calculation.

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 no output schema, the description states the return value (monthly payment) and the major inputs. Minor gaps remain, such as not mentioning the default term of 60 months or that the estimate excludes taxes/fees, but these are largely covered by the schema.

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

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

Schema description coverage is 100%, so the schema fully documents each parameter. The description merely lists parameter names (price, down, trade, term, APR) without adding format, constraints, or defaults beyond what the schema already provides.

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

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

States a specific verb ('Estimate') and resource ('monthly auto-loan payment'), and lists the relevant inputs. It clearly distinguishes this tool from sibling loan calculators like boat_loan and mortgage_payment.

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 such as boat_loan or mortgage_payment. The agent must infer usage solely from the tool name and the auto-loan framing.

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, openWorldHint=false, and destructiveHint=false, so the safety profile is fully covered. The description adds only that a category is returned alongside the numeric BMI, which is modest extra value for a pure calculation.

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

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

A single front-loaded sentence with the action, resource, outputs, and unit system; nothing is wasted or buried.

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 no output schema, the description covers the inputs, the unit convention, and the returned values (BMI plus category). Only the absence of any routing against sibling health calculators keeps it from being 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?

Schema description coverage is 100%, so weightLb, heightFt, and heightIn are already documented, giving a baseline of 3. The phrase 'in US units' is the only unit interpretation the description adds, and it merely reinforces what the schema already states.

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

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

States a specific verb (Calculate), resource (body mass index), and outputs (BMI and category) plus the unit system. The resource is distinct from nearby siblings like bmr_tdee and maintenance_calories, though the description never explicitly contrasts 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?

The description says what the tool computes but gives no when-to-use guidance, prerequisites, or routing against the many sibling calculators (e.g. bmr_tdee, calorie). An agent must infer that BMI is the right choice 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 this a safe, read-only, closed-world computation. The description adds genuinely useful context by naming the Mifflin-St Jeor equation and flagging that the result is an estimate, but says nothing about units of the returned values or precision, which matters for a numeric calculator with no output schema.

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

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

A single tight sentence with the verb front-loaded and zero filler. It is appropriately sized for the tool, though it could have spent those words on sibling differentiation instead of re-listing inputs the schema already carries.

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?

Inputs are fully covered by the schema and annotations cover safety, but with no output schema the description should at least indicate what the two returned values are (BMR and TDEE, presumably kcal/day). It stops at 'estimate', leaving the agent to infer the return shape.

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 every parameter, including the activity multiplier example. The description merely lists the same inputs without adding format, range, or unit detail beyond what the schema provides; 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?

Names a specific verb (Estimate) and two resources (BMR and TDEE) and even pins the formula (Mifflin-St Jeor). However, it never distinguishes itself from close siblings like maintenance_calories, calorie, or bmi, which an agent would need in order to pick correctly.

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 when-to-use guidance and no exclusions. The description does not tell the agent when BMR/TDEE is the right choice versus maintenance_calories or calorie, which sit right next to it in the tool list.

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

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

Annotations already establish the safe, read-only, closed-world profile, and the description adds real value beyond them by naming what the calculation returns: amount financed and total interest. It also flags which inputs are optional. It does not state assumptions such as tax basis or payment frequency, but for a pure calculator this is solid.

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

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

A single front-loaded sentence with no filler; the core resource leads and the optional/computed details follow. Slightly list-heavy but nothing is wasted.

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

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

For a six-parameter calculator with no output schema, the description covers the inputs and names the key outputs, while annotations cover the safety profile. Minor omissions (tax application basis, payment cadence) do not block 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 coverage is 100%, so all six parameters are already documented, giving a baseline of 3. The description adds only the grouping notion that tax, down payment, and trade-in are optional, which the schema's required list already conveys.

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 resource (boat/RV loan payment) and enumerates the optional inputs and computed outputs (amount financed, total interest). The 'Boat or RV' qualifier distinguishes it from auto_loan and mortgage_payment siblings, though it does not explicitly route between 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?

No when-to-use guidance, no prerequisites, and no named alternatives. The agent must infer that this is for boat/RV purchases rather than autos or homes purely from the name and the word 'Boat or RV'.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=false, so the safety profile is covered. The description adds the after-tax basis and the three destination buckets, but says nothing about rounding, precision, or what happens with zero/negative income. With annotations doing the heavy lifting, this is adequate rather than rich.

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

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

A single efficient sentence that front-loads the method and the input basis, then names the output split. No filler.

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

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

For a one-parameter pure calculator with no output schema, the description supplies enough: the income basis and the three result categories. It could go one step further by noting that three amounts are returned or how debt paydown is treated, 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?

Only one parameter and schema coverage is 100%, so the schema already documents 'income' as monthly after-tax income. The description restates the same qualifier ('after-tax income') without adding units, currency, or range constraints, 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 (split), a specific resource (monthly after-tax income), a named rule (50/30/20) and the exact output buckets (needs, wants, savings/debt paydown). An agent can tell this apart from neighbors like savings_growth or emergency_fund without opening a 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?

Usage is only implied: 'monthly after-tax income' signals the input basis, but the description never states when to use this versus savings_growth, emergency_fund, or a plain percentage split. For a set of independent calculators, implicit context is tolerable but there is no explicit guidance 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=true, openWorldHint=false, and destructiveHint=false, so the agent knows this is a safe, closed-world read operation. The description adds that the tool computes three outputs, but does not disclose error behavior (e.g., what happens with invalid inputs) or any other behavioral traits beyond what annotations provide.

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

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

A single sentence that is front-loaded with the core purpose and then lists the outputs. Every clause earns its place with no redundancy or filler.

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

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

For a simple, pure-calculation tool with full schema coverage and annotations covering safety, the description is adequate: it states what is computed and what is returned. However, it does not mention potential error conditions (e.g., zero years) or provide guidance on rounding precision, leaving minor gaps for an agent.

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 descriptive text for each parameter, so the schema already documents start, end, and years. The description adds the conceptual meaning that these are starting and ending values connected over time, but provides no additional syntax or format details beyond the schema.

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

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

States a specific verb (compute) and resource (compound annual growth rate), and specifies the exact inputs (start, end, years). It also names the outputs (total return percent, absolute change), distinguishing it from siblings like rule_of_72 or compound_interest which compute different financial metrics.

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 CAGR calculations but offers no explicit when-to-use or when-not-to-use guidance relative to alternatives like rule_of_72 or compound_interest. An agent can infer the appropriate context from the description, but no routing or exclusion criteria are provided.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=false, so the safety profile is fully covered. The description adds the formula (Mifflin-St Jeor) and the US-unit convention, which is useful context for interpreting inputs, but says nothing about defaults for the four optional parameters or what the response contains.

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

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

A single front-loaded sentence with no filler; every clause (what is estimated, the formula, the unit system) carries information an agent needs.

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 no output schema, the description does not indicate what comes back (e.g. BMR and TDEE values) or how optional parameters are defaulted, which matters for a 6-parameter calculator. It is adequate for invoking the tool but leaves the result shape and optional-parameter behavior 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 100%, so the schema already documents every parameter, giving a baseline of 3. The description adds the unit-system constraint ('US units') and the formula context, but does not clarify the activity multiplier semantics beyond the schema's own 1.2 example or the defaults when age/sex/activity are omitted.

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 specific resources (BMR and total daily energy expenditure), plus the formula and unit system, so an agent knows exactly what is computed. It fails to distinguish itself from the near-identical sibling bmr_tdee (and maintenance_calories), which is the main remaining gap.

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 when-to-use or when-not-to-use guidance is given, and no alternative is named. With siblings bmr_tdee, maintenance_calories, and bmi present, an agent has no textual basis for choosing this tool over them.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so safety needs no restatement. The description adds genuine behavioral context beyond that: it discloses the inputs consumed (room area), the 2x2 ft tile assumption, and a 5 percent cut-waste factor, which shapes how the result should be interpreted.

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

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

A single front-loaded sentence carrying the tile size, room shape constraint, and waste factor with no filler. Nothing could be removed without losing a real constraint.

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 no output schema, the description usefully signals what comes back: a tile count, the room area, and a cut-waste reminder. It does not clarify rounding behavior or whether the waste allowance is already folded into the count, leaving a minor ambiguity for a tool this simple.

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 both parameters (length, width in feet) are fully documented in the schema, so the description need not explain units. It recasts them as 'room area' but adds no syntax or constraint detail 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 (count) and resource (2x2 ft ceiling tiles) plus scope (rectangular room). An agent can distinguish it from siblings such as roofing, insulation, and square_footage without inspecting any 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 is implied by the domain: you call it when you need ceiling tile counts for a rectangular room. However, no explicit when-to-use condition is stated and no alternative sibling (e.g., roofing for shingles, square_footage for raw area) is named or excluded.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds one useful behavioral note beyond that — the multiplicative implementation avoids factorial overflow for large n — but says nothing about precision, return type, or limits on n.

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

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

A single front-loaded sentence with zero filler; the operation is stated first and the implementation note follows. Nothing in it is redundant or wasteful.

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 pure-math calculator with full schema coverage and annotations covering safety, the description is nearly complete. The only omission is the return value (a single count), which is trivial to infer, though there is no output schema to state it.

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% ('Total items, at least 1' and 'Items chosen, between 0 and n'), so the schema already carries parameter meaning. The description's 'n choose r' phrasing restates the parameter relationship without adding constraints or format details beyond the schema.

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

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

The description names a specific verb and resource ('Compute the number of distinct combinations, n choose r'), which is unambiguous against a sibling list of unrelated calculators. It does not explicitly differentiate itself from any sibling, but no close alternative (e.g. permutations) exists to confuse it with.

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 this is the tool for choosing unordered subsets, but the description gives no when-to-use framing, no comparison to alternatives such as permutations, and no guidance on edge cases like r = 0 or r = n.

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 (readOnlyHint=true, destructiveHint=false, openWorldHint=false), and this is a pure computation, so little behavioral disclosure is needed. The description adds value by naming the outputs (future value, total contributed, interest earned), which matters because there is no output schema.

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

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

Two tight sentences with zero filler, front-loading what the tool computes and then what it returns. Nothing is redundant or buried.

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 six-parameter calculator with one required field, no output schema, and full schema coverage, the description covers the core behavior and compensates for the missing output schema by listing return values. It stops short of explaining compounding assumptions or defaults, but the schema carries those.

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 six parameters (principal, rate, years, contrib, compound, timing) are already documented in the schema, establishing a baseline of 3. The description adds only marginal meaning, clarifying that monthly contributions are optional and that the result is a future value.

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

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

States a specific verb (grow a balance) and resource (compound interest) plus the distinguishing feature of optional monthly contributions. It is clearly a compounding calculation tool, but it does not explicitly separate itself from near-siblings like simple_interest, savings_growth, or cagr, leaving the agent to infer the boundary.

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 the many financial siblings (simple_interest, savings_growth, rule_of_72, dividend_reinvestment). The mention of 'optional monthly contributions' hints at the scenario but gives no exclusions, prerequisites, or alternative 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 establish this as a safe, read-only, closed-world computation, so the bar is lower. The description adds the key behavioral rule that discounts stack sequentially rather than additively, which is the main thing an agent could get wrong.

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 with zero filler, and the critical non-additive warning is front-loaded where it will be read before the agent fills the schema.

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

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

With no output schema, the description carries the return-value burden and does name the output (final checkout total), which is sufficient. It could mention rounding/currency or what happens when only originalPrice is supplied, but nothing essential is missing for correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3. The description earns an extra point by clarifying the relationship between parameters that the schema does not state: discounts apply sequentially and the coupon is fixed, giving meaning to how discount1/discount2 combine.

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: computing the final checkout total from stacked percentage discounts, a fixed coupon, and tax. It is clearly distinguished from generic sibling calculators like 'percentage' by naming the exact input composition, though it never names an alternative tool explicitly.

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 note that sequential discounts are NOT additive is genuinely useful usage context, and 'a tax assumption' signals this is a modeling tool. However, there is no explicit when-to-use vs when-not-to-use guidance and no pointer to any sibling calculator for simpler percentage math.

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

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

Annotations already cover safety (readOnly, non-destructive, closed-world), so the bar is lower. The description adds real modeling context: constant yield and constant price growth assumptions, monthly reinvestment cadence, and the three return values. It does not disclose precision, edge-case behavior (zero yield, zero growth), or whether deposits themselves grow.

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

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

Two tight sentences: the first carries the mechanism and the optional input, the second carries the outputs. No filler, and the core purpose is front-loaded.

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

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

There is no output schema, so naming the three returned values is a genuine completion. The reinvestment frequency and growth assumptions are stated, giving an agent enough to call it correctly. Minor gaps remain around whether deposits are flat or indexed and unit expectations (percent vs fraction) for yieldPct beyond 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 each parameter is already documented, including the 'yieldPct' alias note. The description confirms the default-0 nature of contributions ('optionally adding deposits') but adds no format, unit, or range 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 mechanic: compounding a portfolio with a constant dividend yield and price growth, with monthly reinvestment and optional deposits. The resource (dividend reinvestment) and verb (compound) are unambiguous. It does not differentiate itself from siblings like compound_interest or savings_growth, which model similar accumulation.

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 choose this over compound_interest, savings_growth, cagr, or rule_of_72, all of which appear in the same sibling set and overlap conceptually. The phrase 'optionally adding deposits' hints at a use case but never states it as a selection condition.

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, closed-world, read-only profile, so the bar is lower. Because there is no output schema, the description usefully carries the return semantics (target, gap, months-to-close) and implicitly discloses the model: a fixed monthly contribution with no interest or inflation compounding. It does not state edge behavior for zero monthly contribution, 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?

A single compact clause chain with no filler, and the primary output (the target itself) is front-loaded ahead of the derived gap and timeline values. Nothing could be removed without losing meaning.

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 four-parameter, two-required pure calculator with no output schema, the description covers what the tool returns and how inputs combine. The remaining gap is behavioral edge cases (e.g., monthly = 0 meaning the gap never closes) rather than core information.

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 is 3, but the description adds real meaning by binding each parameter to its role in the formula: expenses times months yields the target, saved determines the gap, and monthly determines the time to close. That is more than the schema's one-line field labels provide.

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

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

The description names the exact resource (emergency fund target) and the three quantities computed: target amount, gap versus savings, and months to close the gap. It is specific and unambiguous, but it never differentiates itself from the many other finance calculators in the sibling list (savings_growth, budget_50_30_20, compound_interest), 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 when-to-use guidance, no statement of prerequisites, and no mention of alternatives such as savings_growth for non-emergency savings projections. The topic implies its use case, but nothing in the text routes an agent between this and its siblings.

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

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

Annotations already establish read-only, non-destructive, closed-world behavior, so the safety profile is covered. The description adds genuinely useful behavior context beyond that: the direction of the result (lower value means more rent per dollar of price), which is the key interpretive trait for this metric.

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, formula first and interpretation second, with 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?

With no output schema, the description correctly supplies the return meaning (a ratio plus its interpretation). It does not mention edge cases such as zero rent or non-numeric input, a minor omission for a pure 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 are documented in the schema, warranting the baseline of 3. The description adds the derivation rule but introduces a gap: it says 'annual gross rent' while the schema parameter is 'Monthly rent', and it never explains that the monthly input is annualized, leaving a small mismatch for the agent to reconcile.

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 metric and the exact formula (price divided by annual gross rent), so an agent knows precisely what is computed. Against a sibling list of ~35 unrelated calculators, this is unambiguous and self-identifying.

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 formula rather than stated: the description never says when to prefer this over related rental metrics (e.g., cap rate or ROI tools). For a single-purpose calculator with a fixed formula, the implied usage is adequate, but no contextual or exclusion guidance is offered.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description usefully adds that output is Fahrenheit-basis with included Celsius-basis totals, which is real behavioral context. However it says nothing about the output format or how results are structured, so it is only mildly additive.

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 no padding, and the core action is front-loaded. The 'Fahrenheit basis' / 'Celsius-basis totals' phrasing is slightly dense but earns its place by conveying units.

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 full schema coverage and annotations handling the safety profile, the description covers inputs and hints at the dual-unit output. It is largely complete, with only the exact return structure unstated, which is acceptable given no output schema exists.

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 five parameters, setting a baseline of 3. The description goes slightly beyond by mapping 'growing, heating, or cooling' to the mode enum and clarifying the temperature basis, adding marginal semantic value.

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

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

States a specific verb (Accumulate) and resource (growing/heating/cooling degree days), naming the three computation modes in plain terms. There are no closely related siblings among the calculators, so no sibling differentiation is needed. Clear but not maximally precise about the computational method.

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 inputs needed (daily high, low, base, day count) but gives no explicit when-to-use guidance or how to choose among the gdd/hdd/cdd modes. Usage is only inferable from the mode enum in the schema. No alternatives or exclusions are offered.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the agent knows this is a pure offline calculation with no side effects. The description adds a rough sketch of the computation chain (conduction, kWh conversion, utility cost), but discloses no behavioral details such as the HDD value source, defaulting behavior for r2, or how results are returned. Adds modest value on top of 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?

A single front-loaded sentence that names the two outputs first and the inputs second, with no filler. It is grammatically a fragment rather than a sentence, but it is dense and wastes nothing.

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 no output schema, the description must carry the return-value burden, and it does name the two outputs (U-value and annual heating saving). However, it omits units for the result, the heating-degree-day assumption behind the saving estimate, and the default behavior of r2, all of which an agent needs to call and interpret this correctly.

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

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

Schema description coverage is 100%, so the schema already documents r1, r2, area, and cost, including that cost=0 disables the dollar estimate. The description adds little beyond restating them and, notably, names 'heating degree days' as an input even though no such parameter exists in the schema, which could confuse the agent. 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 names the concrete outputs (U-value of the upgrade and estimated annual heating saving) and the method (conduction over heating degree days). It is clearly distinguished from numeric siblings like bmr_tdee or roofing, though it never says 'insulation savings calculator' as a plain framing sentence. The purpose is unmistakable but the sentence is phrased as a fragment rather than a statement of what the tool 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?

There is no guidance on when to use this versus any alternative, no prerequisites, and no note on assumptions. Nothing tells the agent what context (climate region, building type) the heating-degree-day value assumes, which matters for interpreting results. The description only lists inputs and outputs.

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

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

The annotations already declare readOnlyHint=true, non-destructive and closed-world, so the safety profile is covered. The description usefully adds the direction of the result ('steps upward'), which is behavioral detail beyond the annotations, but it says nothing about the result when the target is below the source key or the output format. Adequate but with a clear gap.

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

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

A single front-loaded sentence with zero filler. Everything stated earns its place and the action is clear from the first clause.

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 no output schema, the description does state the reported value (semitone steps), which is what an agent most needs for this simple two-parameter calculator. The only gap is the ambiguity about downward transposition and whether the result is always a positive step count.

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 parameters, and the schema already documents fromKey and toKey, so the schema carries the parameter burden. The description adds no extra meaning about the two keys beyond the schema, which matches the baseline 3 for high coverage.

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

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

The description gives a specific verb and resource ('Transpose a musical key') plus the output ('number of semitone steps upward'), so an agent knows exactly what computation happens. The sibling tools are all unrelated finance/health/math calculators, so no sibling differentiation is needed, but the phrase slightly conflates transposition with interval measurement.

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, no prerequisites, and no alternatives named. Usage can only be inferred from the tool name and description; nothing states when-not-to-use or how it relates to any other key/music utility.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds real value by disclosing the underlying formula (Mifflin-St Jeor) and the metric-unit convention, but says nothing about the return value, range of results, or handling of out-of-range 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?

A single front-loaded sentence with the resource named first and qualifiers trailing; nothing is wasted. It is arguably too terse for a five-required-parameter tool, but there is 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?

No output schema exists, so the description should ideally say what comes back (a kcal/day figure) and note that results depend on all five required inputs. Annotations cover the safety side, but the return-value gap leaves it only adequate for a compute tool of this size.

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%, including the activity index legend and the valid ranges for age, height, and weight, so the schema carries the parameter burden. The description only reinforces that inputs are metric, adding little beyond structured data — the baseline 3 applies.

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

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

The description names a specific output (daily maintenance calories / TDEE) and the method used (Mifflin-St Jeor BMR plus activity level), so the agent knows exactly what is computed. It does not, however, distinguish itself from the overlapping sibling bmr_tdee, which appears to compute a closely related quantity.

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 guidance and no mention of the alternative tools (bmr_tdee, calorie, protein_molecular_weight, etc.). The only hint of applicability is the phrase 'using metric inputs', which implies a units precondition but doesn't state when this tool is preferred over bmr_tdee.

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 safety profile (readOnlyHint=true, destructiveHint=false, closed-world), so the description only needs to add modeling context. It does so usefully by disclosing the 'maximum variance proportions' assumption (i.e., p=0.5), which materially changes the numeric result and is not encoded anywhere in the schema.

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

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

A single front-loaded sentence with no filler; all three clauses (what it computes, the confidence levels, the variance assumption) carry information. Nothing is wasted or buried.

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, annotation-backed tool with no output schema, the description covers the computation and its key assumption. It does not state the output's form (e.g., a plus/minus percentage), a minor gap for an agent interpreting the result.

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 'n' and the confidence enum are fully documented in the schema. The description restates the allowed confidence levels but adds nothing about the default (90) or the meaning of the sample-size input, so baseline 3 is appropriate.

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

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

The description gives a specific verb (compute) and resource (margin of error for a survey sample), plus the supported confidence levels and the variance assumption. It is unambiguous, though it never explicitly differentiates itself from the many other calculator siblings, so it lands just below the top tier.

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 phrase 'for a survey sample.' There is no explicit when-to-use statement, no exclusion of related tools (e.g., how this differs from a sample-size or confidence-interval calculation), and no statements about prerequisites for the input data.

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 is a safe, read-only, closed-world operation, so the safety profile is covered. The description adds the output shape (monthly breakdown plus total interest) and the positive-price constraint, which is useful, but it says nothing about default behavior or how missing optional inputs (tax, insurance, PMI, HOA) are treated.

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, zero filler, with the primary output front-loaded and the prerequisite stated last. Nothing is redundant or 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?

There is no output schema, and the description compensates well by naming the returned values (monthly components and total interest). It falls just short by omitting how unspecified optional inputs are defaulted and whether results are amortized figures.

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 eight inputs, including the PMI rate conversion example. The description adds only the 'positive home price' constraint beyond the schema, which meets the baseline 3 for a fully documented parameter set.

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 resource (full monthly housing payment with enumerated components: principal, interest, tax, insurance, PMI, HOA) plus a second output (total interest over the term). An agent can distinguish it from pure-rate siblings, though it never names the nearby va_mortgage alternative to clarify which housing calculator applies.

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 usage-adjacent statement is the precondition 'Requires a positive home price.' There is no when-to-use guidance, no indication of when to prefer this over auto_loan/va_mortgage, and no note on required vs optional inputs.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, fully covering the safety profile for a stateless calculator. The description adds no behavioral detail beyond that (no note on determinism or return format), so it neither helps nor harms.

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

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

A single front-loaded sentence that delivers the tool's full scope with no filler. Every clause earns its place by naming one of the three supported computations.

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 no output schema, the description covers all three modes and the required values. The only omission is what the result looks like (a number, a percentage), which is minor given the simplicity.

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

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

Schema coverage is 100%, but the schema only labels mode as 'Calculation mode (default of)' without decoding the enum values. The description maps each mode to plain English ('X% of Y', 'X is what % of Y', '% change from X to Y'), which is genuine added value beyond the schema.

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

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

The description states a specific verb (Solve) and resource (percentage problems) and then enumerates the three exact computations the tool performs. This implicitly separates it from siblings like discount_percent_off or win_loss_percentage, though no sibling is named explicitly.

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?

Listing the three problem types implies when to reach for this tool, but there is no explicit guidance on when to prefer it over siblings such as discount_percent_off or tip_bill_split, and no exclusions. Usage is inferable rather than stated.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds only the set of output units, which is modest extra context for a pure calculation with no side effects.

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

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

A single front-loaded sentence that names the output first and the inputs second. Every clause carries information; 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?

For a stateless two-parameter calculator with a complete schema and safety annotations, the description covers inputs, computation, and output units. Only minor gaps remain, such as output precision or rounding, which are not critical 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 coverage is 100% and both parameters carry their own unit descriptions ('Area in square metres', 'Force in newtons'). The description merely repeats those units, adding no syntax, range, or unit-alternative information beyond the schema.

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

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

States a specific verb (compute) and resource (pressure) and enumerates the output units (Pascals, kilopascals, psi) plus the two input quantities. It is unambiguous against calculator siblings like bmi or mortgage_payment, though it never explicitly names or contrasts an 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?

Usage is only implied by the formula stated ('force over area'), which does tell an agent the preconditions for calling it. There is no explicit when-to-use, when-not-to-use, or alternative-tool 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 establish this as a safe, non-destructive, closed-world read-only computation, so the bar is lower. The description earns credit by disclosing the computation model: it multiplies average residue mass and adds peptide bond count, which explains why results are 'Estimate'-level approximations rather than exact masses.

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

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

A single front-loaded sentence with the resource and units leading. The trailing 'plus peptide bond count' clause is efficient but ambiguous about whether it is an input or a derived output, a small structural 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 two-parameter pure calculator with full schema coverage and safe annotations, the definition is nearly sufficient; it even names the output units and the extra peptide-bond quantity. With no output schema, the exact response field names and numeric rounding are left unspecified, which is the only real 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% with clear per-field descriptions (residue count range 1-100000, average mass in Da with an example), so the schema does the heavy lifting. The description restates the two inputs but adds no format or unit nuance beyond them, and its mention of 'peptide bond count' is an output, not an input, which risks mild confusion about arity.

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), resource (protein chain molecular weight), units (Da and kDa), and the exact inputs it derives from. The sibling list is entirely unrelated finance/geometry/health calculators, so no differentiation is needed, and an agent can tell instantly what this computes.

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: the input description ('from residue count and average residue mass') tells the agent when the tool is applicable, i.e. when those two quantities are known. There is no explicit when-not guidance or named alternative, but no plausible alternative exists in the sibling set for most cases (e.g. avgResidueMass='monoisotopic or average?' is not addressed).

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

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

Annotations cover the safety profile (readOnly, non-destructive, closed-world), so the bar is lower. The description adds real behavioral value beyond them by disclosing that it returns two values (remainder AND floored quotient) and that it uses floored rather than truncated semantics, which materially changes results for negative operands.

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 with zero filler. 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?

With no output schema, the description correctly names both returned values (remainder and floored quotient), which is exactly what an agent needs here. It does not spell out negative-operand behavior or the divisor-zero case beyond the schema's 'not zero' constraint, leaving a small 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% and the schema already documents 'Dividend' and 'Divisor, not zero'. The description adds only the decimal-input scope note, which mildly extends the schema's number-typed parameters. 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: compute the remainder and floored quotient of a division. It clearly separates itself from the surrounding calculator siblings (interest, mortgage, BMI, etc.), none of which overlap. No explicit sibling differentiation is needed because none competes.

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/when-not statement, but the scope note 'works for decimal inputs, not just integers' implies the tool is usable beyond integer modulo cases an agent might otherwise reach for. Usage is only implied, not stated with alternatives.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=false and destructiveHint=false, so the safety profile is covered. The description adds real value by disclosing the output composition and the 3-bundles-per-square factor, but says nothing about the defaults (pitch/waste of 0) or the shape of the returned values. Solid but modest beyond annotations.

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

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

A single sentence that front-loads the calculation source and then enumerates the derived outputs with their key conversion factor. No filler, nothing that could be cut without losing 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 deterministic four-parameter calculator with full schema coverage and no output schema, the description adequately explains what is consumed and what is produced, including the bundle conversion. Only the defaulting behavior and a note on the overlapping area/pitch siblings are missing.

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

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

Schema description coverage is 100%, so length, width, rise (per 12 run) and waste percent are all documented in the schema itself. The description echoes footprint/pitch/waste without adding syntax, units, or default behavior beyond what the schema already states, 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 resource (roof area from footprint and pitch) plus the concrete outputs it derives (roofing squares, approximate shingle bundles). It is clearly distinct from numeric siblings like square_footage or slope, though it never says so explicitly. A resolver can tell what it computes without reading 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?

No when-to-use or when-not-to-use guidance, and no mention of overlapping siblings (square_footage for raw area, slope for pitch math). Usage is only implied by the name. For a pure calculator this is tolerable but it is a genuine gap.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds useful behavioral context by disclosing that it returns both the rule-of-72 estimate and the exact compound-formula doubling time, which is important since no 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?

The description is two tightly written sentences with no filler. The primary purpose is front-loaded, followed immediately by the required rate constraint.

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

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

For a simple one-parameter calculator with annotations and no output schema, the description is nearly complete: it states what is computed, what is returned, and the valid input range. It could be slightly more explicit about units (e.g., years), but the missing detail is minor.

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 rate parameter is fully documented in the schema. The description restates the 0–30 percent range and frames it as an annual growth rate but adds no format or syntax beyond the schema, 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 uses a specific verb and resource: 'Estimate the doubling time of money at a fixed rate using the rule of 72, plus the exact doubling time from the compound formula.' It clearly distinguishes itself from broader finance siblings like compound_interest by naming the rule-of-72 method and stating the exact dual output.

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

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

The description gives a concrete usage constraint — 'Rate must be between 0 and 30 percent' — which is a prerequisite for correct invocation. However, it does not explicitly say when to prefer this tool over alternatives such as compound_interest or cagr, leaving comparison to inference.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data and the bar is lower. The description adds almost nothing beyond that: it does not state the compounding assumption (annual vs monthly), how the rate is treated, or how contributions are timed, all of which materially affect the projected number.

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

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

A single front-loaded sentence that states the core operation first and qualifies it parenthetically, with zero filler words. Nothing in it is redundant with the title or restates fields unnecessarily.

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?

Wait—assessing relative to None.

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% (rate, years, amount, contribMonthly all documented), so the schema carries the parameter burden and a 3 is the baseline. The description contributes one useful hint by marking contributions as optional, but no format, units, or default guidance beyond what the schema already shows.

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 with scope: 'Project the future value of a lump-sum investment (optionally with monthly additions), including interest earned.' An agent can distinguish it as a projection tool rather than a rate calculator, but it never names the close siblings (compound_interest, simple_interest, rule_of_72) whose scopes overlap, so sibling differentiation is left to inference.

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 verb 'Project' and the mention of lump-sum plus optional monthly additions. There is no explicit when-to-use, no when-not, and no pointer to compound_interest or simple_interest for simpler scenarios, so an agent must infer routing 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=true, openWorldHint=false and destructiveHint=false, so the safety profile is covered. The description adds the return content (interest, total value, annual-compounding comparison), which is useful context beyond annotations, but does not explain assumptions like the rate basis for the comparison.

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

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

A single efficient sentence, front-loaded with the core action. No waste, though it is somewhat sparse for a tool that produces three distinct outputs.

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?

No output schema exists, so the description should frame the return values; it names the three outputs but does not specify how the compounding comparison is defined (same inputs? annual rate?). For a closed-world, read-only calculator with fully documented params this is adequate but not complete.

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

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

Schema coverage is 100% with clear per-parameter descriptions (annual rate percent, term in years, principal), so the schema does the heavy lifting. The description adds no additional parameter meaning or format constraints beyond the schema, so baseline 3 is appropriate.

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

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

States a specific verb (Compute) and resource (simple interest, total value, compounding comparison). It describes the outputs as well. It does not explicitly name compound_interest as the sibling to distinguish against, leaving the simple-vs-compound boundary implicit.

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 compound_interest or the other finance siblings. The agent must infer that 'simple interest' implies non-compounding, with no explicit when/when-not statement.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so safety is covered by structured data. The description adds only the constraint 'Run must be above zero', which is a useful but minimal behavioral note and says nothing about error behavior or units. With annotations carrying the safety profile, a 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?

Two short sentences, zero filler, with the core function and the output formats front-loaded and the single constraint last. Nothing in it is redundant padding.

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

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

There is no output schema, but the description names the return values (degrees, percent grade, ratio), which is the key missing piece an agent would otherwise have to guess. For a two-parameter, side-effect-free calculator this is nearly sufficient; only unit conventions and failure behavior on run <= 0 remain 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 coverage is 100% and both parameters are documented ('Horizontal run, above zero', 'Vertical rise'), so the baseline is 3. The description's 'Run must be above zero' merely restates the schema's own constraint and adds no new semantic detail such as units or accepted ranges.

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 slope from rise and run') and enumerates the three output formats (degrees, percent grade, rise-to-run ratio), which goes beyond a bare name. No sibling tool covers slopes or angles, so sibling differentiation is moot rather than achieved.

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: an agent with a rise and a run can infer this is the right tool, and no competing sibling exists to route away from. However, there is no explicit when-to-use statement or pointer to any alternative (e.g., for hypotenuse/length questions).

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, closed-world, read-only computation, so the description need not restate safety. It adds that the tool accepts up to two spaces and can return a with-waste area and alternate units, which is useful behavioral context, but says nothing about input units or output 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?

A single front-loaded sentence with no filler; the core computation leads and the derived outputs follow.

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 pure-calculation tool with full annotation coverage and no output schema, the description usefully enumerates what is returned. The remaining gap is unit interpretation for length/width, which matters for a square-footage 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 coverage is 100%, so the baseline is 3, but the description does add meaning: 'up to two rectangular spaces' explains that length2/width2 are optional, and 'with-waste area' reveals that waste produces a distinct derived value rather than modifying the base area. Input units remain unspecified in both schema and description.

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 (Compute) and resource (total area from up to two rectangular spaces) plus the unit conversions produced, so the tool's function is unambiguous. It never contrasts itself with adjacent area/material siblings such as roofing, insulation, or ceiling_tile, so it stops short of full sibling differentiation.

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

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

There is no statement of when to use this calculator versus alternatives like roofing or ceiling_tile, nor any prerequisites or exclusions. The agent must infer usage purely from the name and description.

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, openWorldHint=false, and destructiveHint=false, so the safety profile is covered. The description adds genuine behavior beyond the schema by declaring the return contents (each person's share, tip, effective tip rate, collected total) — valuable since there is no output schema.

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

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

Two sentences, zero filler, with the core operation front-loaded and the return payload following. 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?

With no output schema, the description usefully enumerates what is returned, and the inputs are fully covered by the schema and annotations. It stops short of clarifying edge-case behavior (how rounding remainders are absorbed, whether tipOnTax defaults to false), which keeps it from a 5.

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 including the enum values for roundMode and the boolean tipOnTax. The description only echoes 'tax, tip, and optional rounding' and adds no syntax or default-value 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 plus the exact scope: split a bill across a group after tax, tip, and optional rounding. This is unambiguous and cannot be confused with any of the sibling calculators (mortgage, bmi, percentage, etc.).

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

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

The condition 'split a bill across a group' implies when to use it, but there is no explicit guidance on when not to use it, no prerequisites, and no named alternative. For a single-purpose calculator with no competing sibling, implied usage is adequate but nothing more.

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 (read-only, non-destructive, closed world), so the bar is lower. The description adds genuinely useful behavior beyond them: the funding fee is rolled into the payment and no PMI is applied, and it lists the returned values (financed amount, payment, total interest), which matters since there is no output schema.

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

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

Two tight sentences with no waste: the core behavior is front-loaded and the return values follow. Nothing is padded or repeated.

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 pure calculator with no output schema, the description is nearly sufficient: it names the output fields and the funding-fee/no-PMI behavior. It leaves minor gaps such as the default fee handling and output units, but nothing that would cause a mis-invocation.

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

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

Schema description coverage is 100%, so all four parameters (apr, fee, term, principal) are already documented in the schema. The description restates that a funding fee is included but adds no units, ranges, or formatting guidance 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 (calculate) and resource (monthly VA loan payment), plus the defining traits that separate it from a generic mortgage: it includes the funding fee and has no PMI. It does not name the obvious sibling mortgage_payment, so the agent must infer the distinction from the VA-specific framing.

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 VA/funding-fee/no-PMI framing implies when this tool applies, but the description never states when to choose it over mortgage_payment or auto_loan. Usage is implied rather than directed, with no exclusions or 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 cover the safety profile (readOnly, non-destructive, closed-world), so the description is free to spend its words on the one behavior that matters: ties count as half a win. That formula convention is genuine behavioral context the annotations cannot express, though the return format (decimal vs. percent) is left unstated.

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

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

A single sentence that is front-loaded with the action and immediately qualifies the non-obvious input rule. No filler, no restatement of the title or parameter 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?

For a pure, side-effect-free three-input calculation with annotations covering safety and no nested structures, the description supplies everything needed to call it correctly. The only small gap is that the output units (0-1 fraction vs. percentage) are not specified and there is no output schema to fall back on.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description earns above baseline by adding the semantic meaning of the 'ties' parameter — it is not merely a stored count, it is weighted as half a win in the computation, which the schema's 'Games tied (default 0)' does not convey.

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 a winning percentage') and pins down the exact inputs (wins, losses, ties). It clearly separates itself from adjacent calculator siblings like percentage or margin_of_error by naming the domain and the tie-handling rule.

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 when-to-use case is implied by the domain name: an agent knows to call this when it has win/loss/tie counts. However, there is no explicit guidance on when to prefer it over the generic 'percentage' sibling, and no stated prerequisites or limits.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description usefully adds that results include an annual figure and a 30% RPM swing range, which is real value, but it says nothing about precision, rounding, or how the swing band is derived.

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

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

A single dense sentence with the primary output front-loaded and no filler. It reads as a noun phrase fragment rather than a complete sentence, which is a minor structural nit but costs no clarity.

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 no output schema, the description carries the return-value burden and discharges it by stating the three figures returned plus the RPM default. Inputs and default are covered by a schema at full coverage, so an agent has everything needed 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 100%, so both parameters are fully documented in the schema. The description's only parameter detail, RPM defaulting to 2, merely restates the schema's own default annotation, adding no new 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 computation (estimated YouTube AdSense revenue) with its exact inputs (monthly views, RPM) and the outputs produced (annual figure, RPM swing range). Among a sibling set of unrelated calculators, there is no ambiguity about what this tool computes.

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 purpose statement; there is no explicit 'use this when' or steering toward alternatives. For a single-purpose calculator whose siblings are all disjoint, this is adequate but bare.

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