SendPay free business calculators

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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint=false, so the safety profile is covered. The description adds nothing beyond restating inputs — notably it does not say whether the result is rounded up to whole units or how the per-month framing interacts with the fixed_costs input, which is the one behavior an agent would want to know.

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 output stated first and the inputs after; nothing is redundant. The phrasing 'from fixed monthly costs, price, cost per unit and payment fee percent' is slightly listy but earns its place by mapping to the four parameters.

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 the description does carry some burden for the return value — it does say it yields 'how many sales a month,' which is adequate. Missing are rounding behavior and how the payment fee is netted against price, both of which matter for 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 description coverage is 100% and every parameter is documented there with units and defaults (payment_fee_percent default 0). The description merely lists the same inputs in prose and adds no format, unit, or edge-case semantics beyond the schema, 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?

Names the specific computation (units sold per month to cover fixed costs) and the inputs driving it, so an agent can tell it apart from sibling calculators like profit_margin_calculator or roi_calculator. It stops short of an explicit contrast with those siblings, but the verb+resource+output is clear.

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 nature of a break-even calculation; there is no statement of when to prefer this over profit_margin_calculator or hourly_rate_calculator, nor any prerequisite. For a self-evident arithmetic tool this is minimum viable, not misleading.

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 closed-world, so safety is covered. The description adds real value beyond them by disclosing that the tool performs three distinct computations, including the reverse gross-up ('what to charge to receive the full amount after fees'), which an agent would not otherwise know to expect. It still omits rounding/currency conventions.

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 with no filler, front-loading the core computation and packing the three outputs into a tight parenthetical plus clause. Nothing could be cut without losing an output mode.

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 must signal the return shape, and it does by naming the three results. With only one required parameter and full schema coverage, little else is needed. Minor gap: no statement of rounding or currency assumptions for a money tool.

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

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

Schema description coverage is 100%, including defaults and examples for fixed_fee and percent_fee, so the schema carries the burden. The description only restates that the fee is percentage plus fixed, without adding syntax or interaction detail. Baseline 3 applies when the schema is this complete.

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 ('work out') and resource (card payment fee) and enumerates the three results computed: fee, net proceeds, and gross-up amount. It clearly distinguishes itself from checkers and generic calculators by naming the fee structure (percentage plus fixed fee). It does not explicitly differentiate from percentage_calculator, which is the nearest overlapping sibling.

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: use when you need card processing fee math. There is no explicit statement of when to prefer this over percentage_calculator or vat_calculator, and no exclusions or prerequisites. An agent can infer the fit from the resource name, but must make the choice 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 readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds real substance beyond that: what is being validated (22 digits, both check digits) and that the identifier decomposes into bank, branch and account segments. It stops short of saying what a failed check returns.

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 sentence, zero filler, with the resource and its defining constraints front-loaded. Nothing is repeated for 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?

For a one-parameter validator with no output schema, the description covers the input constraint and hints at the returned decomposition (bank, branch, account). Missing only the outcome semantics – what an invalid CBU returns and whether components are always present – which is a modest gap 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?

With a single parameter at 100% schema description coverage, the schema already carries the burden and states 'The CBU or CVU, 22 digits.' The description restates the same 22-digit constraint and adds the check-digit notion, so it neither adds much nor leaves a gap.

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 (check) and a specific resource (Argentine CBU or CVU), with the format constraints that define the resource. The 'Argentine' qualifier implicitly separates it from iban_checker and the other identifier checkers in the sibling list, though it never names them.

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

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

Usage is only implied by the verb 'check' – an agent can infer this validates an identifier, but the description never says when to reach for it over iban_checker or swift_code_checker, nor what to do with an invalid result.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the description's job is to add computation semantics — and it does, disclosing that compounding is monthly and that the deposit stream is optional. It also names the returned figures, which matters since no output schema exists. It does not say whether deposits land at the start or end of each month, which is the main remaining ambiguity.

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 with zero filler: the core mechanic (monthly compounding, optional deposit) comes first and the return values are packed into the same line. Nothing is repeated from annotations or 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?

For a four-parameter pure-computation tool with no output schema, the description supplies both the compounding convention and the three expected return values, which is most of what an agent needs. Only timing of deposits and rounding/currency conventions are left unstated.

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

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

Schema description coverage is 100%, so all four parameters (including bounds like the 60-year cap and 100% rate cap) are already documented. The description only adds that the deposit is 'optional' and recurring monthly, which the schema states as 'Added each month. Default 0.' 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 the specific computation (savings growth with monthly compounding and an optional monthly deposit) and enumerates the three outputs, which distinguishes it from the loan/mortgage/ROI siblings. It lacks an explicit verb phrase like 'Calculate', but the resource and result set are unambiguous.

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 'savings growth' framing, but the description never says when to prefer this over loan_repayment_calculator, mortgage_calculator, or roi_calculator, nor does it state any prerequisites or exclusions. An agent must infer routing from the name alone.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds behavior beyond that by disclosing that it performs check-digit validation and returns an issuer/issue decomposition — significant given 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?

A single well-formed sentence, front-loaded with the action and resource, with zero filler. Every clause (identifier type, check digit, issuer/issue split) contributes 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 one-parameter validator with full annotation coverage, the description covers the input constraint, the validation performed, and the shape of the result. The only omission is what happens on an invalid check digit (error vs. boolean), which is a minor gap without an output 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?

There is one parameter with 100% schema description coverage, so the schema already documents the 'cusip' argument and its 9-character form. The description repeats the 9-character constraint but adds no format, casing, or padding 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 specific verb ('check') and resource ('9-character CUSIP'), plus the extra behavior of splitting into issuer and issue. It clearly is not isin_checker or sedol_checker because it names the CUSIP identifier explicitly, though it doesn't call out those siblings by name.

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: use it when you have a CUSIP to validate. There's no explicit when-to-use/when-not, no mention of alternatives for other identifier formats, and no guidance on what to do with an invalid result.

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

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

Annotations already declare read-only, idempotent, non-destructive, closed-world, so the safety profile is covered. The description adds genuine behavioral context the annotations do not: there are two distinct outputs, and the second depends on supplying both optional inputs. It does not state rounding or currency assumptions, which is a minor residual 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 sentence with zero filler, front-loading the primary result before the secondary one. No redundant restatement of the tool name or the annotation flags.

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, pure-computation tool with no output schema and full annotation coverage, the description is nearly sufficient: it explains what is computed and makes the conditional nature of the second result clear. Only rounding/currency conventions are left unstated.

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

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

Schema description coverage is 100%, so all four parameters are already documented in the schema. The description restates the roles of price, discount_percent, unit_cost and units, adding only the relationship 'to keep the same profit'; it gives no units, precision, or validation guidance beyond the schema's minimum/maximum constraints.

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: computes sale price after a percentage discount, plus an optional extra-units-to-hold-profit result. The profit-preservation half distinguishes it from a plain percentage calculator, but it never names a sibling tool to route against.

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

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

Usage is only implied: the phrase 'given unit cost and units normally sold' tells the agent when the second output becomes available. There is no explicit when-to-use, when-not-to-use, or pointer to percentage_calculator / break_even_calculator as alternatives, which matters given 20 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 readOnly, idempotent, non-destructive and closed-world, so safety is covered. The description adds useful behavior beyond them: it searches a large external catalog and 'Returns matching tools with links,' telling the agent what comes back in the absence of an output schema. It does not mention whether a no-match result is possible or how results are ranked.

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 verb and resource in the first clause, and ends with the decision rule. The parenthetical list of 170+ tool categories is dense but serves query formulation; slightly longer than strictly needed.

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

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

For a one-parameter, read-only catalog search with full annotations and no output schema, the description covers scope (170+ tools, which domains), the return shape (matching tools with links), and the routing condition. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema coverage is 100% and the query parameter already documents itself with examples matching the description's phrasing. The description's category list loosely hints at good query terms but adds no real syntax or format guidance beyond the schema. Baseline 3 applies.

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

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

States a specific verb (Search) plus the exact resource: SendPay Business's library of 170+ free calculators, checkers and generators. The enumerated domains and examples (invoice generator, VAT, card fees, IBAN, forex) make it unmistakably a catalog search, clearly distinguished from the single-purpose sibling calculators like vat_calculator or iban_checker.

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 final sentence gives an explicit routing rule: 'Use it when the user needs a calculator or tool that is not offered directly here.' That both states when to use it and implicitly names the alternative path (the direct sibling tools), leaving little inference required.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so safety is covered. The description adds real value beyond them: the cost model (free to build, publish and keep), the absence of a card requirement, the optional later upsell (shop cart, card payments), and the return shape (a link). It does not say whether an account must be created or whether the link expires, which keeps it below 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?

Three sentences, correctly front-loaded with the usage trigger before the product pitch, and the return value is stated last. The middle sentence is partly promotional ('free to build, publish and keep, no card needed') but that framing is genuinely useful for setting user expectations about cost and commitment.

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

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

The tool is simple: one optional parameter, no output schema, read-only annotations. The description covers the trigger, the offer, the cost/commitment terms, and what is returned (a link). Nothing an agent needs in order to call it correctly or set user expectations 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?

There is a single optional parameter, business_type, and schema coverage is 100%, so the schema already carries the meaning including an example value. The description never mentions the parameter or what it influences. With full schema coverage 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 concrete outcome (a free business website with a link to start) and names the audience segments (business, shop, side hustle). It is clearly distinguishable from every sibling, which are all calculators and validators. The only weakness is that the action itself is implicit — it never says plainly 'this returns a signup/publish link' as a verb, though 'Returns the link to start' largely covers it.

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

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

It opens with an explicit trigger: 'Use when the user wants a website for their business, shop or side hustle.' That is a clear condition for selecting this tool. It does not state when NOT to use it or point at an alternative, but no sibling offers a comparable capability, so the omission is low-risk.

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 that this is a read-only, idempotent, non-destructive, closed-world calculation. The description adds useful context about the calculation basis—after business costs and time off—but does not disclose assumptions such as tax treatment, rounding, or output format.

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

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

The description is a single focused sentence with no wasted text, and the main output and basis of the calculation are front-loaded. It is appropriately sized for a simple calculator whose parameters are fully documented in 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?

Given full schema coverage, rich read-only annotations, and no output schema, the description provides enough context: what is calculated, for whom, and which factors affect the result. Return values are implied as hourly and daily rates, and no additional behavioral explanation is needed.

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

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

Schema description coverage is 100%, so all five parameters are already documented in the input schema. The description mentions target income, costs, time off, and hourly/day output, but adds no syntax, default, or constraint 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 gives a specific output: the hourly and daily rate a freelancer or sole trader should charge to reach a target yearly income after costs and time off. It clearly distinguishes this calculator from generic financial siblings, though it does not explicitly name alternatives.

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

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

It implies the audience and scenario (freelancers or sole traders setting rates), but gives no explicit when-to-use guidance, exclusions, or comparison with sibling calculators. The context is clear enough to infer usage, but not to guide between 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 readOnly, idempotent, closed-world and non-destructive, so safety is covered. The description adds the meaningful behavioral limit that annotations cannot express: a pass means format-valid only, not account existence. Missing only return shape (boolean vs. message/warnings).

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, no waste, with the capability statement front-loaded and the scoping caveat immediately after. Nothing repeats the name or title verbatim.

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

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

For a one-parameter read-only validator with no output schema, the description covers what is checked and what a positive result does not guarantee — the two things an agent must know to avoid over-trusting the result. Only the response format (boolean vs. structured result) is left unstated.

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

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

Single parameter with 100% schema coverage ('The IBAN, spaces allowed'), so the schema already handles formatting tolerance. The description adds nothing about the parameter and nothing is missing; 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 ('Check') and resource ('IBAN'), and pins down the exact validation semantics: country length plus mod-97 check digits. It also delimits scope negatively ('does not confirm that the account exists or who owns it'), so the agent knows precisely what class of tool this is.

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

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

The scope line tells the agent when this tool is inappropriate (identity/ownership verification requires something else), which is genuine usage guidance. It stops short of naming a sibling (e.g. swift_code_checker, cbu_checker) or saying 'call this before attempting a payment', so routing is implied rather than explicit.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and a closed-world scope, so the safety profile is covered. The description adds the meaningful behavioral limit that only well-formedness (structure + Luhn) is evaluated, not existence or lookup, but says nothing about the response shape or error behavior.

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

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

One sentence, front-loaded with the verb and resource, with the validation criteria appended as clarifying detail. Nothing is redundant and 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 one-parameter, read-only validator the description covers input and scope, but with no output schema it should say what comes back (a boolean? a per-segment failure reason?). An agent can call it but cannot predict how to interpret a failure.

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

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

Schema coverage is 100% for the single 'isin' parameter, so the schema already documents it. The description's decomposition (2-char country code + 9-char national code + check digit) usefully explains why 12 characters are expected, but adds no format/whitespace/prefix handling rules beyond that.

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 ('check') and resource ('ISIN'), and pins it to ISO 6166 while enumerating the three validated components (country code, 9-character national code, Luhn digit). This distinguishes it in substance from cusip_checker/sedol_checker/lei_checker, but it never names those siblings explicitly, so the differentiation is 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?

Usage is inferred rather than stated: 'is well formed' quietly scopes the tool to syntactic/checksum validation, which implies it should not be used to confirm an ISIN actually exists or to resolve it to an instrument. No explicit when-to-use, prerequisites, or named alternatives 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 declare readOnly, idempotent, non-destructive, closed-world, so safety needs no restatement; the description instead adds the substantive scope limit that only format is validated, not registration status. What is still undisclosed is the result shape (a boolean pass/fail versus a list of failed rules) for a tool 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?

Two sentences with no filler: the validation rule comes first and the scope caveat second. Both are front-loaded information an agent needs before calling.

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

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

The input side and the boundary of the check are fully covered, and annotations carry the safety profile. However, with no output schema, the description leaves the agent guessing what an unsuccessful check looks like (false, an error, or a reason string), which matters for a validation tool whose entire value is its verdict.

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%, with the schema already stating 'The LEI, 20 characters.' The description's mention of MOD 97-10 adds interpretive value but is a restatement of the length constraint rather than new parameter guidance, 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 ('Check that a Legal Entity Identifier (LEI, ISO 17442) is well formed') and pins down the exact rule applied (20 characters, MOD 97-10 check digits). An agent can immediately tell this apart from the identifier checkers in the sibling set (cusip_checker, isin_checker, iban_checker) because the identifier standard 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?

Provides an explicit when-not boundary: 'Does not confirm the LEI is registered; GLEIF's search does,' and names the alternative that handles that case. This routes the agent away from a false expectation that a pass means the entity exists.

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 the safety profile is fully covered. The description adds the meaningful constraint that this only applies to fixed-rate loans, but it does not state payment timing assumptions (e.g. end-of-period monthly payments) or that the result ignores fees.

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 leads with the returned values and ends with the required inputs, 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?

There is no output schema, so the description correctly carries the burden of naming the three return values, which it does. It leaves out assumptions about rounding and payment timing, which are the remaining gaps for a financial calculator.

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

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

Schema description coverage is 100%, so the three parameters are fully documented in the schema, and the description only restates them in prose (amount, APR, term in months). No extra syntax or format guidance is added, 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?

The description names the exact outputs (monthly repayment, total repaid, total interest) and the inputs (amount, APR, term in months), which makes the purpose concrete. It does not distinguish itself from sibling mortgage_calculator, so an agent has to infer that this is the generic consumer-loan version against the property-specific one.

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 'fixed-rate loan' and the presence of an APR-in-months-term input set. There is no explicit when-to-use, when-not-to-use, or routing to mortgage_calculator, which is the obvious alternative.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered without description help. The description adds that multiple derived metrics are returned in one call, but says nothing about currency, rounding, payment timing, or the annuity assumption behind 'monthly repayment'.

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 no filler, and the outputs are front-loaded ahead of the input list. It reads as a noun-phrase fragment rather than a sentence, but 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?

There is no output schema, so the description's enumeration of return values is genuinely necessary and it delivers them. For a four-required-param pure calculation with full schema coverage and complete annotations, the only real gap is the unaddressed overlap with loan_repayment_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 of the four parameters carries its own description plus min/max bounds, so the schema does the heavy lifting. The description only restates the field list (price, deposit, rate, term) without adding format, unit or convention guidance beyond the schema.

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

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

The description names the specific computed outputs (monthly repayment, loan-to-value, total interest, interest-only payment) and the exact inputs, so an agent knows precisely what it produces. It does not, however, distinguish itself from the near-identical sibling loan_repayment_calculator, leaving the agent to guess which to pick.

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

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

Usage is only implied: an agent can infer this is the tool for mortgage scenarios from the enumerated outputs. There is no explicit when-to-use statement and no mention of the obvious alternative, loan_repayment_calculator, which is a real ambiguity given 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 already declare readOnlyHint, idempotentHint, non-destructive and closed-world behaviour, so safety is covered. The description's only extra contribution is that this is a pure three-formula arithmetic tool. It does not say what unit the result is in (percent vs decimal) or how division-by-zero for 'what_percent' or 'change' with a zero base is handled.

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 count of operations and then the mode-to-formula mapping. No filler, no repetition of the title.

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

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

For a three-parameter pure arithmetic tool with full schema coverage and no output schema, the description covers what is needed to select a mode and pass arguments. The one meaningful omission is the shape/units of the returned value, which matters for chaining results.

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 maps x and y to each mode precisely. The description's formula phrasing largely restates that mapping, so it adds little beyond what the schema provides. Baseline 3 applies when the schema does the heavy lifting.

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 specific resource (percentages) and enumerates the three supported computations with concrete formulas, so an agent knows exactly what it computes. It does not differentiate against neighbouring numeric tools (profit_margin_calculator, roi_calculator, vat_calculator), but the operation itself is unambiguous.

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?

Each mode string is paired with a plain-language statement of the question it answers, which is effectively selection guidance for the only real choice the caller makes. It stops short of saying when to prefer this tool over a sibling like roi_calculator or discount_calculator.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world behavior, so safety is covered. The description adds the dual-mode behavior, but says nothing about what happens if both price and target_margin_percent are supplied, or about rounding/precision of results.

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 sentence with no wasted words, and the primary mode is front-loaded before the alternate mode. The semicolon construction is slightly dense but still readable.

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-function calculator with 100% schema coverage, full annotations and no output schema, the description tells the agent both what it computes and the alternate mode. Only the conflict case (both price and target margin supplied) is left 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%, including the note 'Give this or target_margin_percent', so the schema already carries parameter meaning. The description restates the same price-vs-target-margin choice without adding syntax, precedence rules, or edge-case behavior.

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 computational resource (profit, margin, markup) and states both input modes: cost+price, or cost+target_margin_percent. An agent can distinguish it from roi_calculator or percentage_calculator by the margin/markup framing, 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?

The two modes imply when to use it (compute metrics from a known price, or derive a price from a target margin), but there is no explicit when-to-use / when-not-to-use guidance and no routing to alternatives such as roi_calculator for investment returns.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so safety is covered. The description adds the important behavioural fact that a third output, the yearly rate, only appears conditionally when months is given, which is not visible anywhere else given 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?

A single front-loaded sentence with the core computation first and the conditional output last. No filler, no repetition of the title.

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

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

For a three-parameter pure calculator with full schema coverage, the description covers inputs, outputs and the conditional annualized result. Only minor gaps remain, such as the sign convention if returned is less than cost, which is reasonably inferable.

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; the description still earns extra by clarifying that months drives an additional annualized-rate output rather than merely filtering the result. It also frames cost as amount put in and returned as the total amount got back, reinforcing the schema wording.

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 computation and its outputs: profit and ROI % from amount invested and amount returned, plus a yearly rate when months is supplied. It is clear enough to distinguish from generic siblings, though it never explicitly contrasts with profit_margin_calculator, which is the nearest neighbour.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no sibling is named. Usage is only implied by the described inputs and outputs, which an agent must infer selects this tool over profit_margin_calculator or break_even_calculator.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds real value by disclosing that it validates both format and check digit (i.e., a checksum, not just a regex). However, it says nothing about how the verdict is returned or whether it errors vs. returns false on invalid input, and there is no output schema to fill that 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 tight sentence with the key constraint (7 characters) and the validation scope front-loaded. Nothing is repeated from the title and no sentence is wasted.

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

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

For a one-parameter read-only validator this is nearly sufficient — the input contract is clear. The remaining gap is the result contract: with no output schema, the description should say whether the call returns a boolean, a validity message, or the recomputed check digit, since that affects how an agent consumes the answer.

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 there is only one parameter, so the baseline is 3. The description adds meaning the schema lacks: it identifies what a SEDOL is (a UK/Irish security identifier) and constrains the input to exactly 7 characters, protecting against ISIN (12-char) or CUSIP (9-char) confusion.

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 ("Check") and a precisely scoped resource ("7-character SEDOL (UK/Irish security identifier)") plus the two things validated: format and check digit. It is distinguishable from siblings such as isin_checker or cusip_checker by the identifier named, though it never explicitly contrasts itself with them.

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

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

Usage is implied rather than stated: an agent can infer it should call this when holding a 7-character SEDOL rather than an ISIN/CUSIP. There is no explicit when-to-use/when-not-to-use statement and no mention of the sibling checkers as alternatives, so routing relies on the identifier name alone.

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

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

Annotations already cover read-only, idempotent, closed-world semantics, so the description only needs to add what they don't. It does: the absence of a bank directory warns that a syntactically valid code may not map to a real institution, and the component breakdown previews the result 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?

Two short sentences, front-loaded with the verb and result, with the scope caveat last. Nothing is wasted, though the second sentence is a fragment that could have been folded in.

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, describing the four parsed components is exactly the right compensation, and the no-directory caveat sets expectations. It stops short of saying what happens on an invalid or malformed code, which is the main remaining gap for a checker 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?

There is a single parameter with full schema coverage ('SWIFT/BIC code, 8 or 11 characters'), so the schema carries the weight. The description adds no length, format or example detail beyond it, which is the expected baseline for a one-param tool.

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

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

States a concrete verb (check well-formedness) plus a parsing result (split into bank, country, location, branch), so the agent knows both the validation and decomposition behavior. The closing note 'Has no bank directory' differentiates it from directory-lookup-style validators and from siblings like iban_checker.

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 'Has no bank directory' line implies the scope (format-only, no existence check), which is useful routing information, but it never states explicitly when to choose this over iban_checker or lei_checker, nor what a failing check returns. Usage is inferable rather than spelled out.

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

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

Annotations already cover safety (readOnlyHint, idempotentHint, destructiveHint=false, openWorldHint=false), so the description's added value is the trust boundary: the result is a format/checksum verdict, not a registration confirmation. That is exactly the caveat an agent needs before reporting an outcome to a user; it doesn't discuss failure modes for malformed input, but the gap is modest.

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

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

Two sentences, no filler, with the capability stated first and the scope limitation second. Every clause earns its place.

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

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

For a one-parameter boolean-style checker with full schema coverage and annotations carrying the safety profile, this is nearly complete. The one omission is any statement of the return value (valid/invalid plus reason), which no output schema supplies, though the result shape is largely predictable for this kind of 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% and the schema already documents the single parameter including the optional "GB" prefix. The description nonetheless adds accepted input shapes (9 digits, 12 with a branch, GD/HA prefixes), which tells the agent what counts as well-formed input beyond the type declaration.

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 ("Check") and resource ("UK VAT number") plus exactly what is validated: format and check digits. It does not name the nearest sibling (vat_calculator, which computes VAT amounts), so an agent must infer the distinction from the tool names alone.

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

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

Explicitly bounds the scope with "Does not confirm registration; HMRC's service does." That is a real when-not condition that prevents misuse as an authoritative validator. It stops short of naming a sibling alternative, but the exclusion is clear enough to route the call correctly.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered elsewhere. The description adds useful domain context in the UK rate figures, but says nothing about rounding/precision of results or how the two amounts are derived, which is the real behavioral gap for a calculator.

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 sentence covering both directions of the calculation plus a short rate note; the primary purpose is front-loaded and nothing is padded. 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?

There is no output schema, yet the description never says what comes back - presumably net, VAT amount and gross figures - nor what precision to expect. For a pure calculator with safety fully covered by annotations, the return-shape omission is the main remaining 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 each parameter documented including the mode enum and rate defaults, so the baseline is 3. The description's mention of 20% and 5% largely restates the schema default and adds no new parameter-level meaning.

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

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

States a specific verb+resource pair ('Add VAT to a net price, or remove VAT from a gross price') and names both operating modes, so an agent can tell this is a computation tool rather than the sibling uk_vat_number_checker. It stops short of explicitly referencing that sibling, so it lands at 4 rather than 5.

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

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

The two modes are framed conditionally ('net price' vs 'gross / VAT-inclusive price'), which tells the agent which mode to pick for a given input. There are no named alternatives or exclusions, which keeps it at 4.

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