jp-statutory

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered without the description. The description adds genuinely non-structured context: the call is free, and it returns payment config, error codes, and rate limits — useful in an x402/pay-per-call ecosystem. It stops short of saying whether the catalog is cached or how often it changes.

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 telegraphic sentence with the resource front-loaded and the cost signal last; nothing is wasted. The fragment style ('Free.') is slightly clipped but still unambiguous and appropriately sized for a zero-arg tool.

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

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

With zero parameters, rich annotations, and an output schema that already documents return values, the description needs only to identify the resource and its scope — which it does. Enumerating the returned categories (prices, payment config, error codes, rate limits) is a helpful bonus rather than a requirement.

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 tool takes zero parameters, so per the rubric the baseline is 4 and there is nothing for the description to disambiguate. No parameter detail is required or missing.

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 resource (Mart402 product catalog) and enumerates what it contains: products, prices, payment config, error codes, rate limits. An agent can tell this is a discovery/metadata endpoint rather than a data-processing tool. It does not distinguish itself from the one plausible sibling, search_x402_services, which is a minor gap.

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

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

The only usage signal is the trailing word 'Free,' which implies a cost advantage over paid x402 siblings but never states when to call this versus search_x402_services. There is no statement of prerequisites, ordering, or when-not-to-use.

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 a genuinely behavioral fact not present in annotations: the call is free and requires a receipt_id issued by a prior paid response. It omits whether receipts expire or whether the re-fetched payload is identical, but with annotations carrying safety this is solid.

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

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

One sentence, front-loaded with the action and resource, with the clarifying parenthetical placed after the essential information. 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, so return values need not be described, and annotations cover the safety semantics. The description supplies purpose, parameter provenance and cost behavior; only minor operational details (receipt lifetime, pagination/error behavior on an invalid id) are absent.

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 its 'rcpt_...' format. The description's provenance note ('from a paid response') largely restates the schema's own wording, so it adds little beyond the structured field. 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 ('Re-fetch a previously paid result') plus the selection key ('by receipt id'), and adds the key differentiator that this path is free. No sibling tool overlaps, so an agent can identify this as the free retrieval path for a paid result without opening the schema.

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

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

The description tells the agent the precondition (you must hold a receipt_id) and where that id comes from ('every paid response carries receipt_id'), which implies the when-to-use condition: retrieving a result already paid for rather than paying again. It does not explicitly name an alternative or a when-not-to-use case, but the context 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 readOnly/idempotent/non-destructive/closed-world, so safety is covered. The description adds genuinely useful behavioral context beyond that: the payload is a *recorded* production response, it is free, and it is flagged with sample:true, which tells the agent the data is illustrative and not live processing of its own input.

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

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

The first sentence is well front-loaded and earns its place, but the trailing 'Available: ...' clause reprints all 28 enum members that already appear in the schema, roughly doubling the length with zero added 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?

An output schema exists, so return values need not be explained, and the single parameter is fully documented. The description covers what the sample is, where it comes from, and how it is flagged, leaving only minor gaps (e.g. whether the sample corresponds to the same shape as the live paid call).

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 single 'product' parameter is a fully enumerated, documented string, so the schema carries the semantics. The description's product list simply restates the same enum values verbatim and adds no syntax, format, or selection meaning beyond it — baseline 3.

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 ('Free recorded sample response for a paid product') and makes the scope explicit: it returns a preview of the exact response shape rather than doing the work. This cleanly separates it from the paid sibling tools (document_pipeline, enrich_company, ocr_image, etc.), which an agent can distinguish without opening either 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?

Gives a clear selection context: 'see the exact response shape before paying anything', i.e. call this when previewing a paid product's output rather than invoking the paid tool. It does not name an explicit alternative or a when-not-to-use condition, so it falls short of the top band.

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?

Goes beyond the annotations by disclosing cost ($0.01/call), determinism, sourcing (cites primary sources), and the billing policy that errors and unverified rules are never charged. That is genuinely useful context an agent cannot infer from readOnlyHint/idempotentHint alone, and it explains why readOnlyHint=false for what looks like a pure calculation.

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

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

Two sentences, purpose front-loaded, and the second sentence packs cost, determinism, and the error-billing policy without padding. Slightly fragmentary phrasing but no wasted 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?

An output schema exists so return values need not be described, and all parameters carry schema descriptions. The main remaining gap is routing guidance against the many jp_* payroll and tax siblings, which the description does not address.

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

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

Schema description coverage is 100%, so the schema already documents all eight parameters in detail. The description only adds the link between the withholding lookup and previous month salary, which is marginal value over 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?

Names a specific resource and computation: net bonus pay, broken into social insurance and withholding tax, with the rate-table basis stated. An agent can tell it apart from jp_payroll_net by the bonus scope, though no sibling is explicitly named.

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, when-not-to-use, or alternative selection guidance. The parenthetical '(based on previous month salary)' hints at a prerequisite but the description never says to use jp_payroll_net for ordinary salary or jp_social_insurance for standalone SI lookups.

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?

Beyond the annotations, the description discloses pricing ($0.003/call), determinism, primary-source citation, and a billing policy that errors and unverified rules are never charged. That is meaningful behavioral context for a paid endpoint. It does not explain the readOnlyHint=false flag or payment handshake flow, which the schema's x_payment field covers instead.

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?

Capabilities are front-loaded, followed by price, guarantees, and the mode contract — a sensible priority order. The mode mapping duplicates text already present in the schema's mode description, which is minor redundancy rather than noise.

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 full schema coverage, the description need not explain return values, and it covers all five modes and their required inputs. Only the optional x_payment flow and defaults like saturday_off are left entirely to the schema, which is acceptable.

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% across all 10 parameters, so the schema already documents each field including the mode enum. The description's mode-to-param mapping adds orientation but is largely a repeat of the mode parameter's own schema description, so baseline 3 is appropriate.

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

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

The opening sentence names specific capabilities: Japanese holidays, business-day arithmetic, statutory filing deadlines with holiday shift, and wareki conversion. No sibling (jp_payroll_net, jp_consumption_tax, jp_social_insurance, etc.) covers holiday calendars or day arithmetic, so an agent can route here unambiguously.

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 mode-to-parameter contract ('add -> from, days; between -> from, to; holidays -> year; deadline -> kind, base_date; wareki -> date') tells the agent exactly how to configure a call for each use case. It gives clear context but no explicit when-not or alternative-tool guidance, since no sibling offers overlapping functionality.

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 openWorldHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is partly covered; the description adds the per-call cost ($0.03/site) and the source constraint (page must be the company's own site, not a directory/lookup). It does not state in prose that a payment header is required for actual execution, though the price mention and the x_payment schema field imply the paid flow. No contradiction 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 dense sentences with no filler: cost, capability, and routing rule all front-loaded. The opening fragment ('Japanese company site to a standard profile JSON') is grammatically elliptical, which costs a point but does not obscure meaning.

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

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

An output schema exists, so the description is not obligated to explain return values, and annotations cover the safety hints; the field list and the enrich_company routing make it sufficient for correct invocation. The only minor gap is that the prose never says the call is payment-gated, leaving that entirely to the x_payment schema description.

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 a baseline of 3 applies, but the description adds real selection semantics for the url parameter — it must be the company's OWN site, not a name or domain query — which the schema's generic 'Absolute http(s) URL of the input' does not convey. The x_payment parameter is left entirely to the schema, which is acceptable given its detail.

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

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

Names a specific transformation (page -> standard profile JSON) and enumerates the exact output fields (name, address, representative, capital, contact), so the agent knows precisely what it gets. It also explicitly contrasts itself with the sibling enrich_company, making the two tools distinguishable without opening either 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?

States the selecting condition ('when you have the URL of a Japanese company's OWN site') and the negative case with the alternative to use instead ('for name/domain lookups use enrich_company (country_hint: jp)'). This is explicit when-to-use / when-not-to-use routing that most definitions lack.

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?

Beyond the annotations (idempotentHint=true, destructiveHint=false), the description discloses cost ($0.01/call), the billing guarantee that errors and unverified rules are never billed, and that output is deterministic and cites primary sources. Those are meaningful behavioral traits an agent cannot get from the annotation block; only the x402 payment mechanics are left to the schema.

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

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

Purpose, pricing, guarantees, and mode routing are front-loaded and the whole thing is compact. The only waste is the long 'Required by mode...' clause, which duplicates the schema's mode description almost word-for-word.

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 nine parameters, nested objects, an output schema, and annotations, the description supplies the missing commercial context (price, billing rules, deterministic sourcing) plus mode routing. It is nearly complete; a hint about as_of selecting the rules version and the uncharged x_payment discovery flow would close the gap, though the latter is covered in the schema.

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

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

Schema description coverage is 100%, so the schema already documents every parameter, including the mode->parameter mapping. The description reproduces that mapping verbatim rather than adding syntax, formats, or defaults that the schema lacks, so this is the baseline 3 case.

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?

It names a specific domain (Japanese consumption tax) and enumerates concrete capabilities: per-rate invoice rounding, qualified-invoice validation, simplified taxation, and the 20% special case. That scope cleanly separates it from neighbors like jp_crypto_tax, jp_retirement_tax, and verify_invoice, so an agent can pick it without opening the schema.

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

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

The mode->parameter mapping implicitly tells the agent which mode fits which input shape (invoice lines vs. document vs. taxable sales), which is real routing guidance. However, it never states when to prefer this tool over alternatives such as verify_invoice or quote_parse, nor any prerequisites, so usage 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 cover the safety profile (idempotent, non-destructive, openWorld), and the description adds genuinely useful behavioral context beyond them: per-call cost ($0.05/call), determinism, primary-source citation, and the billing guarantee that errors and unverified rules are never charged. It stops short of describing rate limits or the output shape, but the pricing/billing disclosure is the key unknown for a paid call.

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 compact sentences, front-loaded with the purpose before cost and correctness claims. Every clause carries information, though the closing billing/guarantee language leans slightly promotional.

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 schema fully documents all parameters. Combined with annotations covering safety and the description covering cost, determinism, and verification basis, 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 schema already documents all seven parameters, including the x_payment header and its unpaid-requirements behavior. The description adds method-level semantics (fees deductible, what counts as a disposal) but no per-parameter syntax or format detail 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?

The description states a specific computation (Japan crypto-asset realized income) with the two supported cost methods (total_average, moving_average) and defines what counts as a disposal (sell/spend/exchange). This clearly distinguishes it from the other jp_* tax calculators in the sibling list without the agent needing to open 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?

It names the two available methods but gives no guidance on when to pick total_average vs moving_average, nor any prerequisite or when-not-to-use condition relative to siblings like jp_consumption_tax or jp_retirement_tax. Usage is only implied by the tool's domain.

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 declare the safety profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false, openWorld=true), so the description's real value-add is the pricing ($0.02/call), the determinism guarantee, source citation, and the notable no-charge-on-error/unverified-rule policy. That is concrete behavioral context an agent could not derive from the annotations.

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

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

One dense sentence fragment with the core analysis front-loaded, followed by pricing and reliability terms. Every clause carries information; only the parenthetical threshold pair could be trimmed, and no filler is present.

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-value explanation is unnecessary, and the description covers scope, cost and reliability. Gaps are minor: supported rule years/jurisdiction scope and the x402 payment flow (which is documented in the schema rather than the description) are not restated.

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

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

Schema description coverage is 100%, so the schema fully documents year, as_of, x_payment and annual_income_yen — baseline 3. The 1.06M/1.30M figures in the description add interpretable meaning about what thresholds the income value is tested against, but no format 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 analysis (income-wall analysis) over a named domain: Japanese tax, social insurance (1.06M/1.30M) and spousal/student-dependent thresholds. An agent can distinguish it from jp_social_insurance or jp_payroll_net by the 'walls' framing, but the description never names those siblings to sharpen the distinction.

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

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

The description characterizes the domain of the computation but gives no when-to-use or when-not guidance and names no alternatives among the many jp_* calculation siblings. Cost and billing behavior are covered, but tool selection is left entirely to inference from the topic.

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 declare it is idempotent and non-destructive, but the description adds genuinely useful behavioral facts the annotations cannot: a $0.005 per-call cost, deterministic output, primary-source citation, and a billing policy that errors/unverified rules are never charged. That pricing and billing behavior is material for a pay-per-call service; it stops short of describing result format or rate limits.

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, with the cost and billing guarantee packed economically into the second. 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?

Annotations and an output schema exist, so return values need not be explained. The description covers purpose, cost, and billing policy, but is silent on what distinguishes the two payment methods or how prepayment interacts with them, which is the kind of nuance an agent would benefit from.

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. The description echoes the two enumeration values (level payment/principal) and mentions prepayment effect, but adds no format or semantic detail beyond what the schema already documents.

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 resource (mortgage) and its outputs: schedules under level payment/principal methods, total interest, and prepayment effects. This clearly separates it from the adjacent Japanese-finance siblings (jp_payroll_net, jp_consumption_tax), though it never explicitly names an alternative 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?

There is no statement of when to use this tool versus siblings, nor any prerequisite or exclusion. The agent can infer the domain from 'mortgage schedules', but no routing guidance is provided.

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

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

With annotations covering safety hints, the description still adds real behavioral context: a concrete price ($0.015/call), a determinism guarantee, primary-source citation, and a billing policy that errors and unverified rules are never charged. The schema's x_payment field covers the payment handshake. It loses a point for not clarifying that this is a side-effect-free calculator while readOnlyHint=false, which could make an agent wonder whether calling it mutates anything.

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?

Pricing and the two modes are front-loaded ahead of the parameter requirements, and the whole thing is compact. The final clause restates the `mode` enum description word-for-word, which is dead weight in an otherwise efficient definition.

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 a present output schema (no need to explain returns), full schema coverage, and annotations covering hints, the description supplies the remaining essentials: cost, billing policy, mode selection, and the statutory basis. The only residual gap is the internal structure of the `hours` object, which is minor for a paid, deterministic 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 baseline is 3, and the description's mode sentence is a near-verbatim duplicate of the `mode` property description rather than added meaning. Crucially it does not explain the shape of the nested `hours` object or how regular vs. overtime hours are distinguished, which is the one place the schema ('Hours worked') is genuinely ambiguous.

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

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

Names a specific computation (overtime premium pay under Labor Standards Act Art.37, plus Article-36 limit check) with the legal basis, which is an unusually concrete verb+resource statement. It even enumerates the two internal capabilities. It stops short of 5 because it never distinguishes itself from payroll-adjacent siblings such as jp_payroll_net or jp_payslip_audit, leaving the agent to infer which tool owns overtime math.

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 mode breakdown ('pay' vs 'check36') tells the agent which parameters each path needs, which is functional routing. However, that is parameter guidance rather than use-case guidance: there is no statement of when to pick this tool over a sibling, no prerequisites, and no exclusions. Usage is implied, not stated.

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

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

Annotations only cover safety/idempotency; the description adds real behavioral context beyond them: deterministic output, primary-source citation, per-call cost ($0.02), and the billing guarantee that errors and unverified rules are never billed. It still doesn't explain whether the call requires a payment header or how rules-version selection interacts with as_of.

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 tight sentences with zero filler, front-loaded on the core transformation. 'Exact NTA Beppyo-5 table' is unexplained jargon, but it is brief and signals sourcing rather than 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?

An output schema exists, so return values need not be described, and the schema covers parameters fully. The remaining gap is that the payment-gated nature of the call (x_payment header required) is not stated in the description, which matters for a paid 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%, so the schema already documents all 8 parameters including age, as_of, and x_payment. The description adds no parameter-level syntax or defaults beyond what the schema provides, so baseline 3 applies.

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

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

States a concrete transformation (annual gross -> net take-home) and names the tax components it accounts for, so the agent knows exactly what the tool computes. It does not, however, differentiate itself from close siblings like jp_bonus_net (which also handles bonus input) or jp_payroll_suite.

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 gross-to-net framing, and the x_payment behavior (omit it to get payment requirements without being charged) is useful, but there is no explicit when-to-use/when-not guidance and no named alternative for overlapping payroll 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 supply the safety profile (non-destructive, idempotent, open-world), so the bar is lower, and the description still adds the essential behavioral fact that the call costs a flat $0.05 — a charging trait not captured by any annotation. It does not detail the payment flow, but the x_payment parameter schema already explains the charge/quote 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?

Two short sentences, front-loaded with the resource and scope, with the pricing fact trailing. Every clause earns its place; 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 present, return values need not be explained, and annotations cover the safety profile, so the description needs only purpose and pricing — both delivered. The one gap is the absence of sibling routing guidance for a tool that overlaps heavily with jp_payroll_net and jp_social_insurance.

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% across all 7 parameters, including the age-gated rules and payment header, so the schema carries parameter semantics fully. The description only adds the parenthetical '(+bonus)', which slightly anticipates the annual_bonus_yen parameter but adds little beyond the schema.

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

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

States a specific resource (Japan payroll) and enumerates what it computes: net salary, social insurance, income walls, and bonus. The phrase 'in one call' hints it consolidates the sibling calculators (jp_payroll_net, jp_social_insurance, jp_bonus_net), but it never names them, so the differentiation from those siblings is left 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?

'in one call' implies this is the combined/all-in-one option versus the single-purpose siblings, which is a usable hint. However, there is no explicit when-to-use or when-not-to-use guidance, and no statement that it should be chosen over jp_payroll_net when the full breakdown is wanted.

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

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

Annotations cover safety (idempotent, non-destructive), but the description adds valuable context beyond them: pricing ($0.02/call), determinism, primary-source citation, and a billing policy (errors and unverified rules are never billed). The x_payment parameter and its no-charge path reinforce the payment model. Return format is left to the output schema, which is acceptable.

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 dense sentences, front-loaded with the core purpose, followed by pricing and guarantees. Every clause carries information; no filler. Could be marginally tighter but is well-structured and appropriately sized.

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 present, return values needn't be described, and the schema plus 100% coverage handles parameters. The description supplies the behavioral context an agent needs (determinism, pricing, billing policy). The main gap is the absence of sibling routing guidance, which the crowded namespace makes notable.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters including the nested payslip object and the x_payment header. The description does not add any parameter-level meaning (no format, defaults, or interaction details beyond the schema), so the baseline 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 states a specific verb (audit) and resource (Japanese payslip) and details the operation: recompute statutory premiums and withholding tax from official tables and diff against actual amounts. The per-item verdict taxonomy (match/explainable/mismatch) further distinguishes it from siblings like jp_payroll_net or jp_social_insurance, which compute rather than audit.

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

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

The description implies usage (auditing an existing payslip against statutory tables) but never states when to pick this over the crowded sibling set (jp_payroll_net, jp_social_insurance, jp_payroll_suite). It offers no explicit alternatives or when-not conditions, leaving routing to inference.

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

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

Annotations already declare idempotent=true, destructive=false and openWorld=true, so safety is partly covered. The description still adds real behavioral value beyond the schema: per-call pricing ($0.02), determinism, primary-source citation, and a no-charge-on-error policy, plus the x_payment parameter documents a dry-run payment-requirements flow.

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 tight, front-loaded fragments with no filler; the core computation leads and pricing/behavioral caveats follow. Every sentence earns its place, though the terse fragment style slightly reduces readability.

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 100%-covered schema and an output schema present, return values need no explanation and the description wisely omits them. It covers rules and billing behavior adequately; the only notable gap is routing guidance relative to sibling tax tools.

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 explains all five parameters including the payment header, disability and officer flags. The description references years-of-service deduction logic but adds no syntax, format, or edge-case detail beyond that, 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 the resource precisely (retirement income tax) and the specific computation enclosed (deduction by years of service, half-taxation rules, withholding rounding), so an agent knows exactly what output to expect. It does not, however, differentiate itself from the dense cluster of jp_* payroll/tax siblings (e.g. jp_payroll_net, jp_consumption_tax), leaving the agent to infer the boundary.

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

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

There is no when-to-use guidance, no prerequisites, and no named alternative among the many sibling tools that also compute Japanese income taxes. The agent must guess whether this is the right tool versus jp_payroll_net or jp_payslip_audit.

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

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

With annotations already declaring idempotentHint=true and destructiveHint=false, the description adds material context the annotations cannot: a per-call price ($0.01), deterministic results, primary-source citation, and a no-charge guarantee for errors or unverified rules. It does not explain the x402 payment handshake beyond what the x_payment schema field covers, which keeps it short of 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?

Two compact sentences, purpose front-loaded, followed by cost and reliability claims. Every clause carries information; the only slight redundancy is that billing behavior is partly repeated by the schema's x_payment field.

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 no prose, and annotations cover the safety profile. The description supplies cost, determinism, and sourcing, but omits the one thing an agent still needs: routing guidance versus the other jp_payroll* tools.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters including age-gated care insurance and the as_of rules-version selection. The description's 'Kyokai-Kenpo grade table (FY2026)' and 'monthly premiums' only loosely gloss monthly_remuneration_yen and the rules version, 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 a specific resource (monthly social insurance premiums) and its authoritative source (the official Kyokai-Kenpo grade table, FY2026), which is enough for an agent to tell it apart from jp_consumption_tax, jp_mortgage, or jp_payroll_net. It never states the verb explicitly ('calculates'), so it is clear rather than maximally precise.

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

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

There is no guidance on when to choose this over siblings such as jp_payroll_net or jp_payroll_suite, nor any prerequisite or exclusion stated. The only selection signal is the implied 'Japan social insurance' domain carried by the name.

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