financial-calculators

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds useful behavioral context that the resulting link auto-calculates on open, which is not conveyed by annotations or schema.

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

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

The description is front-loaded with purpose, followed by a concise prerequisite instruction and a concrete example. Every sentence and the example earn their place without redundancy.

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

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

Given the rich schema, annotations, and the presence of an output schema, the description provides everything needed: purpose, prerequisite routing to list_calculators, and a concrete input-to-URL example. No important invocation details 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 every parameter is already documented in detail, including lang formatting effects and currency exceptions. The description adds only an illustrative example mapping inputs to a URL, which does not add semantic meaning beyond the schema.

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

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

The description states a specific verb and resource: 'Build a deep link to a SmartMoney77 calculator with pre-filled values that auto-calculate on open.' It clearly distinguishes this link-building tool from siblings like list_calculators and the individual calculator tools by naming the action and 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?

It explicitly routes the agent to 'Use list_calculators first to find the slug and its parameters,' which is clear prerequisite guidance and points at a sibling tool. It does not state when not to use this tool, but the context for invocation is clear.

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 it a safe, idempotent, closed-world read. The description adds real behavioral context beyond them: the image is 'rendered on our servers', the share-modal link serves three download sizes, and the caption is localized with attribution. It also notes the results are one call rather than multiple round trips.

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

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

One dense but well-formed sentence front-loads the outcome and enumerates the returns, followed by a compact scope statement and a single inline example. It is slightly long but every clause carries distinct information; no filler.

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

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

With an output schema and full annotation coverage already present, the description supplies everything else an agent needs: the four artifacts produced, calculator coverage, and a call example. Only the relationship to build_calculator_link as a lighter alternative is left implicit.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds a concrete worked example payload and cross-references build_calculator_link for param naming, which helps an agent construct the nested params object correctly.

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

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

The description states a specific verb and resource ('Build everything needed to share a SmartMoney77 calculation on social media') and enumerates the exact deliverables: deep link, 1200x628 image URL, share-modal link, and localized caption. It is clearly distinguishable from the calculator compute tools, though it never explicitly contrasts itself with the nearest sibling build_calculator_link beyond borrowing its param names.

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?

'Works for all 31 calculators' scopes the tool but gives no when-to-use guidance, no prerequisites, and no statement of when to prefer build_calculator_link (link only) over this heavier share-pack call. Usage is implied by the phrase 'share on social media' 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 cover read-only, idempotent, non-destructive and open-world traits, so the description adds genuine context beyond them: USD-only constraint, the shared 'yearly low/high average' pricing model with SmartMoney77, and the per-asset reproduction link returned. Useful behavioral detail, though auth/rate-limit or error behavior is absent.

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

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

Front-loaded with purpose, scope and output in three dense sentences plus a worked example. The inline asset enumeration is somewhat redundant with the schema but is still readable and earns its place as a quick reference.

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

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

Given an output schema exists, the description needn't explain return values, yet it still previews the ranked result and reproduction link. Combined with the example and pricing methodology, an agent has everything needed to invoke 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 the baseline is 3, but the description adds value with a concrete example payload showing how amount, buy_year and assets combine and clarifying the ranked output order. The asset slug list duplicates the schema, which slightly blunts the added 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 and resource ('run the same what-if-I-had-invested calculation across 2-8 assets and rank them by final value'), which cleanly separates it from the single-asset historical_investment_return and from compound_interest. The asset universe and ranking output are named up front.

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 'across 2-8 assets and rank them' (i.e., pick this when comparing multiple assets), but the description never explicitly says when to prefer it over historical_investment_return or compound_interest, nor does it state exclusions. Adequate but with a clear routing gap.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds genuinely useful domain behavior beyond that: monthly compounding, contributions at the end of each month (ordinary annuity), and that a SmartMoney77 link is returned alongside the value.

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

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

The purpose and key convention are front-loaded, and the worked example earns its space by illustrating the exact semantics of the inputs and output. The sentence is long but contains no filler or repetition of schema content.

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

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

With an output schema present, the description need not enumerate return fields, and it still notes the returned link. Compounding frequency, contribution timing, and rate interpretation are all resolved, leaving only sibling routing as a gap for an otherwise self-contained calculator.

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

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

Schema description coverage is 100%, so all five parameters (initial, monthly, rate, years, lang) are already documented in the schema, including defaults, bounds, and language/formatting behavior. The description adds only the annuity-timing nuance, not per-parameter meaning, so the baseline 3 applies.

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

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

The description states a precise verb and resource ('project the future value of an initial amount plus monthly contributions at a given annual return') and pins down the compounding convention. The worked example with concrete numbers makes the function unmistakable and distinguishes it from siblings like compare_investments or fire_number.

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 calculation described, but there is no explicit guidance on when to choose this over siblings such as cost_of_waiting, latte_factor, or compare_investments, nor any stated preconditions. The mention that it returns a SmartMoney77 link hints at the follow-up flow but is not framed as 'use this when...'.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so safety behavior is covered. The description usefully adds an interpretive claim about results (the gap comes mostly from compounding, not extra contributions), but says nothing about permissions, limits, or computation assumptions beyond the return rate.

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

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

Two sentences, front-loaded with the purpose before the example. The embedded JSON example is compact and directly usable, though the qualitative result claim consumes space that could have carried usage guidance.

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 6 fully documented parameters, an output schema, and complete annotations, the description needs only to frame purpose and scenario, which it does. Minor gaps are the absence of sibling routing and of any caveats about assumptions in the comparison model.

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

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

Schema description coverage is 100%, with each parameter documented including constraints (retire must exceed compare, compare greater than start). The example reinforces the parameter roles but adds no semantics beyond what the schema already provides, so the baseline 3 applies.

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

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

States a specific verb (compare) and resource (investing the same monthly amount at an early vs later age) and frames the outcome as 'what the delay costs by retirement'. It is clearly distinguishable in substance from siblings like compound_interest, though it never names an alternative to differentiate 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?

There is no statement of when to choose this tool over compound_interest, compare_investments, or latte_factor, and no prerequisites or exclusions are given. The example implies the intended scenario but does not guide tool selection.

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, idempotent profile, and the description adds genuine context on top: it discloses the error condition (payment below first month's interest) and the shape of the result (months plus total interest). It stops short of discussing rounding or edge cases.

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

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

Two sentences, front-loaded with the core purpose, followed by a concrete worked example and the single failure mode. No filler; every element 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 an output schema present and annotations covering safety, the description only needs to add behavioral and usage context, which it does via the example and the error note. The monthly 'purchases' input is left to the schema, which is acceptable given full coverage.

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

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

Schema description coverage is 100%, so all five parameters are already documented in the schema, including the purchases field and the lang enum. The description's example anchors the three required inputs but adds no syntax or meaning beyond the schema, so the baseline 3 applies.

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

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

States a specific verb+resource: calculating time-to-payoff for a credit card balance and the total interest paid. The scope (fixed monthly payment and APR) is precise enough to separate it from siblings like compound_interest or cost_of_waiting without opening 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?

Usage is implied by the narrow domain (paying down a card balance), and one failure condition is noted, but there is no explicit when-to-use/when-not guidance or named alternative among the many calculator 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 declare a pure read-only, idempotent, non-destructive, non-open-world calculation, so the safety profile is covered. The description adds the deterministic input→output mapping via the worked example, but says nothing about edge cases (e.g. zero contribution → infinite time) or limits beyond what the schema constrains.

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

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

Two sentences, front-loaded with the computed outputs and followed by a single compact worked example. 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?

An output schema exists and annotations carry the safety profile, so the description needn't explain return values or side effects. Parameters are fully documented, and the example confirms the calculation semantics — nothing essential is missing.

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

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

Schema coverage is 100%, so the schema already documents every parameter, making 3 the baseline. The worked example goes beyond the schema by showing how expenses, savings, contribution, and target combine into concrete outputs, adding interpretive 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 (Calculate) and resource (emergency fund coverage: months covered, target, gap, months to close). The listed outputs make it unmistakably distinct from siblings like fire_number or compound_interest without opening their schemas.

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

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

The example implies the scenario (given expenses/savings/contribution/target, compute coverage and path to target), so usage is inferable. However, it never states when to prefer this over fire_number, compound_interest, or cost_of_waiting, nor any prerequisites, so guidance is only implied.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds the method disclosure (4% rule) and the secondary output (years of saving), but says nothing about language handling, formatting side effects, or determinism beyond what annotations imply.

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

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

Two sentences, purpose first, concrete example second — zero filler and nothing repeated from the schema. Well front-loaded for a quick selection decision.

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

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

With a full output schema and 100% parameter documentation, the description only needs to frame the calculation, which it does. It is close to complete; the only omission is routing guidance relative to the many sibling calculators.

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

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

Schema coverage is 100%, so every parameter including lang, rate and withdrawalRate is already documented in the schema. The example illustrates expenses/saving/current meaningfully but adds no syntax 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 (calculate) and a well-defined resource (FIRE target) and spells out the two outputs: the target and years of saving. The FIRE concept is distinct enough to separate it from siblings like compound_interest or emergency_fund, though it never names 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 worked example ({expenses, saving, current} → fireNumber), which shows the intended call shape but not when to pick this over cost_of_waiting or compound_interest. No when-not conditions or prerequisites are given.

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

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

Annotations already state readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds what is returned, but no additional behavioral details such as error behavior or special conditions. This is adequate with annotations present, but not exceptional.

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 consists of two sentences, with the first sentence stating the resource set and scope and the second providing a concrete JSON example. There is no filler and the key action is front-loaded.

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

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

For a simple tool with one optional parameter, a clear purpose, and an output schema, the description is sufficient. It lists the kinds of guides returned, says it works for one or all tools, and gives an example. No missing information is necessary for correct invocation.

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

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

The schema description already fully documents the single 'tool' parameter, including the omit-for-all behavior and the list of valid values. The description's example illustrates usage but does not add semantics beyond what the schema already provides. Baseline 3 applies due to 100% schema coverage.

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

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

The description names a concrete deliverable (standard prompt template, argument template, output-interpretation guide, resources) and clearly identifies the tool as a discovery helper. This distinguishes it from the calculator siblings, which perform calculations rather than return usage guidance.

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

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

The phrase 'so you can call them correctly without guessing' clearly indicates when to use this tool: before invoking other SmartMoney77 tools when usage details are unclear. It doesn't explicitly exclude alternatives like list_calculators, but the context is sufficiently clear.

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 read-only, idempotent, non-destructive and open-world traits, so the bar is lower. The description still adds real context: the pricing methodology (same yearly low/high averages as the site calculators), a hard USD-only currency constraint, and the shape of what comes back (units, value, profit, return, CAGR, link).

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

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

Purpose is front-loaded, followed by data-source, currency and asset scope, then a concrete example. The enumeration of 17 asset slugs is the only verbose stretch, but it is load-bearing because it defines valid values.

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

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

With an output schema present (no need to explain return values), full schema coverage, and annotations covering the safety profile, the description supplies everything else an agent needs: data source, currency restriction, valid assets, and a combined-parameter example.

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

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

Schema description coverage is 100%, so all five parameters including lang and sell_year are already documented, making 3 the baseline. The description restates the asset list and gives a worked example combining asset/amount/buy_year, which adds modest value but no syntax or constraint detail beyond the schema.

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

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

States a specific verb and resource: computing what a past investment would be worth today or in a later year, with the added scope that it uses yearly low/high average prices. This differentiates it somewhat from a generic growth calculator, but it never names the overlapping siblings (compound_interest, compare_investments) it must be chosen over.

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 concrete example and the 'past investment' framing, so an agent can infer when it applies. There is no explicit when-to-use, when-not-to-use, or alternative-tool guidance despite several overlapping financial calculators in the sibling list.

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

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

Annotations (readOnlyHint, idempotentHint, destructiveHint=false, openWorldHint=false) already make clear this is a safe, side-effect-free computation. The description adds little behavioral context beyond that, though the worked example implicitly reveals the shape of the result (realValue, equivalentNeeded) and the fact that it's a pure calculation with no state change.

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

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

Two sentences, front-loaded with the core purpose and followed by a compact numeric example that earns its space by defining the two outputs. No filler or repetition.

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

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

An output schema exists, so return values needn't be spelled out, and annotations cover the safety profile; parameters are fully documented in the schema. The description supplies purpose and an illustrative example, leaving only sibling differentiation and language-formatting behavior unaddressed.

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 amount, rate (default 3), years (1-80), and the lang enum with formatting implications. The example ties amount/rate/years to outputs but adds no semantics beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific dual purpose with a concrete verb and resource: computing real purchasing-power loss to inflation and the nominal amount preserving buying power. The worked example ({amount:100000, rate:3, years:10} → realValue ≈ 74,409, equivalentNeeded ≈ 134,392) makes the output tangible. It doesn't name or contrast against nearby siblings such as compound_interest or cost_of_waiting, so it stops short of 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?

Usage is implied by the example and the purpose framing, but there is no explicit when-to-use or when-not-to-use guidance, and no routing to alternatives like compound_interest or cost_of_waiting, which are adjacent concepts an agent could confuse with this one.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds the qualitative shape of the result ('the low-fee portfolio ends materially higher'), which is useful framing but not a precise disclosure of what the output contains. With annotations carrying the behavioral burden, this lands at the minimum-viable level.

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

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

Two sentences, front-loaded with the purpose, followed by a compact example that doubles as a usage illustration. No filler. Slightly dense in the example, but every element 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?

An output schema exists, so return values need not be described, and the annotations cover the safety profile. The main gap is that the description does not say whether lowFee must be lower than highFee or how fees interact with the gross 'rate', which an agent might need when constructing inputs. Otherwise it is complete for a read-only calculator.

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

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

Schema description coverage is 100%, and each field (portfolio, monthly, highFee, lowFee, years, rate, lang) is already documented with defaults and ranges in the schema. The example in the description illustrates typical units and magnitudes, but adds no syntax or constraint detail beyond what the schema states, so the baseline of 3 is correct.

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 concrete verb and resource: compare the long-term cost of a high vs low management fee on a portfolio with monthly contributions. It is clear enough to distinguish from generic siblings like compound_interest or inflation_check, but it never explicitly contrasts itself with those alternatives, which is what would be needed for 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?

Usage context is only implied by the example input. There is no statement of when to pick this over compare_investments or compound_interest, and no prerequisites or exclusions. It is adequate to infer intent but the agent gets no routing guidance.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so safety is covered. The description adds genuinely non-obvious behavioral context: the exact monthly-cost formula, the ordinary-annuity convention (contributions at month end), and a worked example showing the expected magnitude of output.

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

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

Front-loaded with the core purpose, then the formula and a compact example; every sentence carries information. It is dense but not padded, and the modeling assumption is stated rather than 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?

An output schema exists, so return values need not be explained, and the description supplies the remaining essentials: the calculation model, the annuity timing convention, and a sanity-check example. Only the choice of defaults vs siblings is not addressed.

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

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

Schema coverage is 100%, so baseline is 3, and the description goes further by tying parameters together in a formula (cost × perWeek × 52 / 12) and a concrete example ({cost:5, years:30, rate:8, perWeek:5} → ~108/month). This clarifies how cost and perWeek interact, which the individual schema entries do not.

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 subject: calculate the lifetime cost of a small recurring daily expense and the invested alternative, with concrete examples (coffee, cigarettes, takeaway). The purpose is unambiguous, though it never names the closest siblings (cost_of_waiting, compound_interest) to disambiguate scope.

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 scenario described ('small recurring daily expense') implies when the tool fits, but there is no explicit when-to-use guidance and no routing against nearby calculators like compound_interest or cost_of_waiting. 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 cover read-only, idempotent, and non-destructive behavior. The description adds value by specifying the output content (slug, accepted URL parameters, languages/currencies) and providing an example that shows how the 'group' filter changes the result. It does not overstate capabilities, and the safety profile is consistent with annotations.

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

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

Three sentences with no filler: first sentence states the purpose and outputs, second gives direct usage guidance, third provides a concrete example. The most critical information (what it does, when to use it) is front-loaded, and every sentence earns its place.

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

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

For a simple list tool with one optional parameter and an existing output schema, the description is complete. It tells the agent what the tool returns (slug, URL parameters, languages/currencies), when to call it (before build_calculator_link), and how filtering works via the example. No critical information 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?

The schema already provides a comprehensive description of the 'group' parameter with enum values and defaults (100% coverage). The description adds an explicit example that maps 'history' to 'what if I had invested' tools, which deepens understanding beyond the schema. This incremental value justifies a score above the baseline.

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

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

The description states a specific verb ('List'), a specific resource ('every SmartMoney77 calculator'), and the exact attributes returned (slug, URL parameters, supported languages/currencies). It clearly distinguishes from siblings by focusing on enumeration rather than calculation or link building, and explicitly references build_calculator_link as the dependent tool.

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

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

Directly instructs when to use the tool: 'Call this before build_calculator_link.' This gives a clear use case and implies it should not be used after building a link. The example with the 'group' parameter further clarifies how filtering affects the output, reinforcing appropriate usage.

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