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

Annotations already establish read-only, idempotent, non-destructive behavior, so the description only needs to add substantive context. It does so by disclosing the exact statutory basis (Sections 208, 209, 211, 234B, 234C), the quarterly percentages, and deadlines, making the calculation behavior predictable. 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?

Two sentences, front-loaded with the core verb and object, and every clause adds information: the legal sections, the quarterly percentages/deadlines, and the shortfall-interest behavior. It is compact without sacrificing specificity.

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

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

For a two-parameter, read-only calculator, the description covers the purpose, legal basis, and key outputs (deadlines and shortfall interest). The main gap is the absence of explicit output-structure details, but the schema fully documents the inputs and the behavior is simple enough to infer.

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

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

Schema description coverage is 100%, with clear descriptions, examples, and patterns for both assessed_tax and as_of_date, so the schema carries the burden. The description does not add parameter-specific meaning beyond implying they feed the statutory calculation, which matches the baseline.

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

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

The description names a specific verb (Calculate), a precise resource (statutory quarterly advance tax installments and interest penalties), and cites the governing statutory sections. It is immediately distinguishable from sibling tax tools like tds, tcs, and indian_income_tax because it is explicitly about advance tax instalments.

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 its use case: computing advance tax installments and related interest. However, it gives no explicit when-to-use/when-not-to-use guidance or alternatives, and with many sibling tax tools an agent must infer that this tool is not for TDS/TCS or general income-tax computation.

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?

Even with readOnlyHint and idempotentHint annotations, the description adds behavioral context: deterministic calculation with zero external side effects, official provider pricing cards as data source, cache/batch discount mechanics, and freshness categories. No statement contradicts 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?

The definition is organized into Description, Behavior, and Usage Guidelines with the main purpose front-loaded. It is slightly verbose and contains a distracting 'pack age' phrase, but every section carries useful selection and invocation information.

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

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

For a deterministic calculation with no output schema, the description adequately names the return products (cost matrix, arbitrage analysis, cache savings, monthly projections), key pricing assumptions, and the routing alternative. Combined with the thorough input schema, an agent can select and invoke this tool 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?

The schema covers all 10 parameters with types, defaults, aliases, and constraints, so the baseline is 3. The description complements this by explaining the cost mechanics (95% cache discount, 50% batch discount, cache hit ratio) but does not add per-parameter syntax 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 opens with a specific verb ('Calculate') and a precise resource ('multi-provider LLM API inference token costs'), then enumerates covered economics: caching, batch discounts, and cross-model cost disparity. This clearly differentiates it from financial/egress siblings and gives an agent an unambiguous purpose.

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 provides explicit when-to-use scenarios ('budgeting AI agent inference costs', 'evaluating LLM providers', 'deciding whether to implement prompt caching or batch inference') and explicitly says 'Do not use for cloud network egress; use cloud_egress_finops instead'. This is model guidance for selection.

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

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

Beyond the readOnlyHint and idempotentHint annotations, the description discloses that the tool is 'Deterministic, idempotent calculation with zero external side effects' and warns that it 'uses ordinary floating-point arithmetic, keeps no dated table of official rates, and has not yet passed our full reference-test suite.' It also reveals the core formula and PE threshold behavior, providing meaningful context beyond structured data.

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 dense but organized into purpose, behavior, and usage paragraphs, with no filler. The only minor structural weakness is that the precision caveat appears before the main purpose statement, which slightly delays the agent's understanding of what the tool does.

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 tax calculator with zero required parameters, all inputs defaulted, and full schema descriptions, the description covers the computation formula, the PE threshold, the gross-up mechanism, and the recommended alternative tool. It does not explicitly describe the output structure, but the computed results—gross amount, treaty savings, and PE alert—are strongly implied.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds value on top by explaining how the parameters relate: 'Gross = Net / (1 - WHT_rate)' and by framing daysInCountry and treaty versus statutory rates in terms of PE alerts and treaty relief savings. It does not need to repeat every parameter's schema description.

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

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

The description names a precise verb and resource: 'Calculate cross-border B2B consulting/software invoice tax gross-up, statutory vs DTAA bilateral tax treaty withholding rates... and Permanent Establishment (183-day) tax audit exposure.' This clearly differentiates it from sibling tax tools, especially because it explicitly invokes feie_nomad_tracker as the alternative for a different use case.

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

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

The 'Usage Guidelines' paragraph is explicit and actionable: 'Use when exporting services cross-border or structuring international client contracts subject to foreign withholding tax. Do not use for digital nomad individual income tax exclusion; use feie_nomad_tracker instead.' This gives both a positive trigger and a named 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 establish readOnly, idempotent, and non-destructive behavior; the description echoes that but adds real value by stating the exact equation Gross - Expenses - Health - SECA Tax - Income Tax = Target Net Cash and explaining how billable hours are derived from vacation weeks and non-billable percentage. 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?

Organized into three efficient sections: overview, behavior, and usage. Every sentence contributes either to understanding the calculation, clarifying side effects, or distinguishing the tool from contractor_parity. No filler or redundant restatement of schema details.

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

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

For a deterministic calculation tool with fully documented parameters and annotations, the description is complete: it gives the computational model, output definition, required date rule-pack behavior, usage context, and sibling exclusion. Even without an output schema, the return value ('hourly billable floor') is unambiguous.

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

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

Schema coverage is 100%, so the baseline is 3. The description goes beyond individual field descriptions by showing how targetNetCash, annualExpenses, healthInsuranceAnnual, vacationWeeks, and nonBillablePercent interact in a single calculation, clarifying the relationship between parameters and the derived hourly floor.

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 opens with a specific verb and resource: 'Solve the exact minimum billable hourly rate required to achieve a target net spendable cash income' and enumerates the contributing factors. It also names the sibling alternative (contractor_parity), so an agent can distinguish this tool without opening its 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?

Provides explicit 'Use when' context for freelancers/consultants/agency owners setting a baseline rate and explicit 'Do not use when' guidance directing the agent to contractor_parity for W-2 salary comparisons. This is clear routing between 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?

Beyond the annotations (readOnly, idempotent, non-destructive), the description discloses the precision caveat: ordinary floating-point arithmetic, no dated official-rate table, and not yet passed the full reference-test suite. It also explicitly states zero external side effects and provides the exact formulas used.

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 well-organized into Precision, Behavior, and Usage Guidelines sections, and each sentence contributes meaningful information. The precision caveat is placed first, which slightly delays the main purpose statement, but the formula detail and routing guidance justify the length overall.

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 4-parameter calculator with no output schema, the description is complete: it covers purpose, formulas, expected behavior, precision limitations, and usage boundaries. The annotations and schema cover side-effect safety and parameter constraints, and 'Returns detailed breakdown' plus the named metrics is sufficient for correct invocation.

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

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

Even though schema coverage is 100%, the description adds real semantic value by defining the relationships between parameters: Unit Contribution Margin = unitPrice - unitVariableCost, Break-Even Units = fixedCosts / CM, and how expectedUnitsSold triggers margin-of-safety and DOL computation.

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 opens with a specific verb ('Calculate') and a precise resource: cost-volume-profit break-even thresholds in units and revenue, contribution margin ratio, margin of safety, and DOL. It also distinguishes itself from the sibling billable_floor by explicitly excluding hourly freelance billing rate minimums.

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 gives explicit when-to-use contexts: pricing strategy, manufacturing and SaaS unit economics, and operational risk appraisal. It also names the alternative tool (billable_floor) for the excluded use case, leaving no ambiguity about routing.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description reinforces these with 'deterministic, idempotent calculation with zero external side effects' and adds the exact formulas and output values. While it doesn't disclose anything beyond annotations, it does add context on computation and returns, which is valuable.

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 well-structured with clear sections for purpose, behavior, and usage guidelines. It front-loads the primary function and keeps each sentence informative without redundancy. The length is justified by the tool's complexity.

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 description explains the return values (nominal CAGR %, real CAGR %, total gains, doubling years) and provides usage boundaries. However, it does not explicitly explain the 'mode' parameter (HISTORICAL_CAGR vs PROJECTION) or when to use PROJECTION mode. Since the schema covers the parameter, this is a minor gap, but for a tool with multiple modes, an explicit mention would improve completeness.

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 all parameters. The description adds meaning by showing how parameters are used in formulas (e.g., finalValue/initialValue, periodsYears, inflationRatePercent), which clarifies their role beyond the schema's field-level descriptions. This is a modest enhancement over the baseline of 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?

The description explicitly states what the tool does: calculates CAGR, real inflation-adjusted growth, and doubling time, with a clear verb and resource. It also differentiates from siblings by naming compound_wealth and sip_investment as alternatives for different use cases.

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 provides explicit when-to-use scenarios (historical portfolio track records, business revenue growth, inflation drag analysis) and when-not-to-use (forward-looking recurring monthly projections), naming the exact alternative tools. This fully satisfies the requirement for usage guidance.

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

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

Annotations already mark readOnly/idempotent/non-destructive; the description adds meaningful behavior beyond that: deterministic calculation, zero side effects, specific pricing tiers, modeling of cache offload, and the exact return categories. No contradiction with annotations exists.

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

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

The description is well structured: a purpose sentence, a Behavior block, and a Usage block. It is slightly wordy in the opening phrase, but each sentence serves a distinct function and the key scoping/usage guidance is visible early.

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

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

For a read-only calculation tool with no output schema, it fully covers what an agent needs: inputs are schema-documented, behavior is deterministic, outputs are itemized (gross costs, post-cache costs, net savings), and usage vs alternatives is explicit.

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

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

Schema coverage is 100%, so the baseline is 3. The description reinforces broad calculation context (tiered rates, cache reduction) but does not add much per-parameter meaning beyond what the schema already provides for as_of_date, cacheHitRatio, and monthlyEgressGB.

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

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

The description names a specific verb ('analyze') tied to a precise resource: AWS/GCP egress pricing versus Cloudflare zero-egress, and states what it produces (monthly/annual savings). It also distinguishes itself from the financial/FinOps sibling cluster, especially via the explicit token-pricing exclusion.

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 gives explicit use cases (cloud architecture budgeting, FinOps reviews, CDN/Cloudflare migration evaluation) and an explicit when-not-to-use rule with the alternative named (ai_token_arbitrage). This is above the typical bar.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, but the description adds valuable context beyond these: 'Standard precision: this calculator uses ordinary floating-point arithmetic, keeps no dated table of official rates, and has not yet passed our full reference-test suite.' It also confirms 'Deterministic, idempotent calculation with zero external side effects.' This discloses reliability caveats and confirms behavior without contradicting 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?

The description is structured with a front-loaded caveat, followed by purpose, behavior, and usage. Every sentence adds value: the precision warning is critical, the formula is essential, and the usage exclusion prevents misuse. It is appropriately sized for a tool with 5 parameters and no output schema, with no redundant 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?

Given the tool's complexity (5 parameters, no output schema) and rich annotations, the description fully covers what an agent needs. It explains the return values ('final accumulated balance, total principal contributed, total compound interest earned, and annual wealth progression milestone table'), provides the formula, and sets expectations on precision. Nothing essential is missing.

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

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

Schema coverage is 100% and each parameter has a clear description (e.g., annualRatePercent: 'Expected annualized investment return rate percentage'), so the baseline is 3. The tool description adds the exact compound interest formula, which clarifies how parameters interact (e.g., n for compoundFrequency, PMT for monthlyDeposit). This goes beyond the schema's individual parameter descriptions and earns a 4.

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 clearly states the tool's purpose: 'Simulate long-term compound interest growth for retirement portfolios, 401(k)s, Roth IRAs, UK ISAs, or European ETF savings plans (Sparplan) with recurring monthly deposits.' It uses a specific verb (simulate) and resource (compound interest growth), and differentiates from the sibling sip_investment by explicitly excluding Indian SIPs with step-up. This makes it unambiguous which tool to choose.

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 provides explicit usage guidance: 'Use for multi-year personal wealth projection and retirement nest-egg simulations. Do not use for Indian mutual fund monthly SIPs with annual step-up; use sip_investment instead.' This clearly states when to use and when not to, and names the alternative tool, leaving nothing 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 cover readOnly, idempotent, and non-destructive behavior. The description adds genuinely useful context beyond that: inputs are validated before dispatch, and results are 'exact deterministic' — a determinism claim not present in the annotations. No contradiction with annotations, and the additive behavioral traits are meaningful for an agent deciding whether repeated calls are safe and reliable.

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

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

A single sentence of roughly 20 words with zero filler. The core concept (universal entrypoint, engine routing) is front-loaded, and the deterministic-results payoff is stated last. 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 dispatcher that routes to 30 engines, the description handles complexity by deferring input details to each engine's schema, and the sibling list supplies valid engine names. It covers the return promise ('exact deterministic results') despite having no output schema. Minor gaps: no mention of error behavior for invalid engine names or unknown inputs, but this is acceptable for a routing tool whose contract lives in the target engines.

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

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

Schema coverage is 100% and both parameters (engine, inputs) are already well documented, including the nested structure and example for inputs. The description reinforces with 'validated inputs' and 'specified engine' but adds no format, syntax, or constraint detail beyond what the schema provides. At full coverage the baseline of 3 is appropriate.

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

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

The description states a clear purpose: a universal calculation entrypoint that dispatches to any of 30 TrueCalci engines and returns deterministic results. It implicitly distinguishes itself from the 31 sibling tools (tds, fd, gst_composition) by being the universal router rather than a specific engine. The name 'compute' is generic, but the title and description recover it with a specific verb (dispatches) and resource (engines).

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 — you route to a named engine rather than calling it directly — but it never explicitly says when to choose this universal entrypoint versus the specific engine tools, nor does it state any exclusion conditions. The 'route to any engine' title and the engine parameter hint at the decision, but there is no direct guidance on selection criteria.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds behavioral context by specifying the returned data (health score, contradiction list, Merkle proof), which goes beyond the annotations. However, it doesn't disclose any potential limitations or edge cases, but for a read-only operation this 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?

The description is a single, information-dense sentence that front-loads the tool's purpose and outputs. There is zero waste; every word adds value. It names the tool, its function, and the exact return types without elaboration.

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 read-only inspector with no output schema, the description adequately conveys what it returns. It does not explain the relationship between the optional 'files' and 'repoId' parameters, but the schema descriptions cover that. The tool is simple enough that nothing critical is missing, though a note on when to use each parameter would improve completeness.

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% (both 'files' and 'repoId' have descriptions), so the schema fully documents the parameters. The description adds no additional meaning about these parameters, such as how they interact or which takes precedence. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states the tool is an inspector for the Drift Score Index, and specifies the exact outputs: health score (0.0-100.0), contradiction list, and Merkle proof receipt. This is specific and distinguishes it from the sibling context_sanitizer_verify_scope, which likely handles verification rather than inspection.

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

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

The description gives no guidance on when to use this tool versus alternatives. There is no mention of when to choose it over context_sanitizer_verify_scope or any other sibling, nor any context about prerequisites or typical scenarios. The tool's name and description imply usage for getting a DSI, but explicit usage guidance is absent.

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 readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is clear. The description adds behavioral specifics: it consults a repository knowledge graph and detects semantic contradictions, zombie routes, and drift. This supplements the annotations without contradicting them.

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 compact sentence that conveys the tool's role and inputs. There is minor redundancy between 'pre-commit semantic contradiction validator' and 'detecting semantic contradictions', but overall it is well-sized and front-loaded for an agent to parse.

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 is complete: the agent knows to pass a map of relative file paths to content strings. However, there is no output schema and the description does not explain what the tool returns or how to interpret the validation result, which is a meaningful gap for a validator 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?

The schema fully describes the single 'files' parameter with an example, so schema_description_coverage is 100%. The tool description adds no additional parameter-level meaning, so it remains at the baseline of 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?

The description states a specific action: it pre-validates proposed code and documentation edits against a repository knowledge graph before files are written, detecting semantic contradictions, zombie routes, and drift. This clearly identifies the tool's purpose and resource. However, it does not explicitly differentiate itself from the sibling tool context_sanitizer_get_dsi, so it stops short of a 5.

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

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

The description gives clear usage context through 'pre-commit' and 'before files are written', telling the agent this is a pre-write validation step. It does not mention when not to use it or compare it to alternatives, but the timing guidance is concrete and actionable.

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 readOnly/idempotent/destructive false, but the description adds substantial detail: deterministic, zero external side effects, lists all computed tax items, and specifies exact return contents (net spendable cash, tax breakdowns, effective rates, breakeven hourly rate). This exceeds the annotation-based baseline and fully discloses 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?

The description is moderately long but well-structured: a clear purpose sentence, a behavior paragraph listing computes and returns, and a usage guideline paragraph. It is front-loaded with the core purpose. Each sentence carries information; there is little waste.

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 12 parameters, 4 required, and no output schema, the description compensates by specifying all return outputs and behavior. It also gives usage conditions. The as_of_date param is explained in the schema, and the description confirms rule-pack selection implicitly. No critical omission for correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not restate individual parameters but frames them as inputs to a breakeven calculation, adding aggregate context. This is acceptable but does not add per-parameter meaning beyond the schema's comprehensive descriptions.

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

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

States a specific verb ('Calculate') and resource ('tax liabilities, statutory benefits, and net take-home cash') distinguishing W-2 vs 1099 and solving the exact breakeven rate. It also names a sibling (billable_floor) as the alternative context, clarifying its unique purpose.

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 states when to use ('deciding between a W-2 salaried offer and a 1099 contractor contract') and when not to ('solo freelancer baseline rate setting without a W-2 benchmark'), pointing to a specific alternative tool. This is direct and actionable guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context: it discloses that compounding is fixed by statutory rule pack, that TDS thresholds are analyzed, and that the computation is rule-based. The schema's compounding_convention parameter also reinforces the fixed-convention behavior. 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?

Two sentences with zero waste. The first sentence states the core function and the second adds the key statutory context. Every clause earns its place, and the most important information (what it calculates) is front-loaded.

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

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

For a read-only calculation tool with 100% schema coverage and no output schema, the description is nearly complete. It covers the product scope, compounding conventions, and TDS analysis. The only minor gap is that it doesn't describe the return value shape, but since there is no output schema and the tool is a calculator, the agent can infer a numeric result. The statutory context provided is sufficient for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds value by explaining the statutory basis (RBI Master Direction, Section 194A) and clarifying that compounding_convention is read-only and fixed. This goes beyond the schema's own descriptions, which already note the statutory constraints. A 4 is appropriate because the description reinforces and contextualizes the parameter semantics without needing to repeat schema details.

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 ('Calculate') and resource ('Bank and Corporate Fixed Deposit maturity amount and interest returns'), and enumerates the compounding conventions and TDS threshold analysis. This clearly distinguishes it from sibling tools like home_loan_emi or sip_investment, which address different financial products.

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 when to use this tool: when an agent needs FD maturity or interest calculations, including TDS threshold analysis. It doesn't explicitly name alternatives or exclusions, but the specificity of the FD domain and the mention of statutory thresholds provides clear context. A small gap is the lack of explicit 'use this instead of X' guidance.

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

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

Beyond the annotations (readOnlyHint, idempotentHint), the description states the calculation is deterministic and side-effect free, evaluates the 330-day threshold, applies the statutory cap, computes tax liability on excess income, and flags aggressive state domicile rules. The annotations already cover safety, so this additional operational detail is genuinely valuable.

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 organized into three labeled sections (overview, behavior, usage guidelines), with no filler. Some redundancy exists between the overview's $130,000 for 2025 and the behavior section's repeated cap values, but otherwise every sentence earns its place given the tool's complexity.

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 tool with six parameters and no output schema, the description conveys the core computation, eligibility threshold, caps, and state-risk flagging. It does not describe the exact output shape or the interplay of qualifyingDaysInTaxYear with proration, but the schema covers those fields and the description gives enough context for correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning to key parameters: it specifies the 330-day threshold for daysOutsideUSInRollingPeriod, the statutory cap values for 2024 and 2025, and the high-audit states for stateDomicile. It does not discuss filingStatus or qualifyingDaysInTaxYear explicitly, but the schema already covers those well.

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 opens with a specific verb and resource: it tracks IRS Form 2555 FEIE eligibility, the 330-day Physical Presence Test, the statutory exclusion cap, and sticky domicile audit risks. This clearly distinguishes it from sibling tools, especially because the usage guidelines explicitly name b2b_withholding_risk as the alternative for foreign corporate withholding tax.

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

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

The Usage Guidelines section explicitly states when to use the tool (US citizen digital nomads and expats evaluating Section 911 exemptions) and when not to use it, naming the sibling tool b2b_withholding_risk for foreign corporate withholding tax. This gives the agent a decisive routing rule with no ambiguity.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the description correctly reinforces these with 'Deterministic, idempotent calculation with zero external side effects.' It adds useful behavioral context beyond annotations: what fee components are modeled and what the returned ranked table contains. No contradiction exists.

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

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

The description is appropriately structured into purpose, behavior, and usage guidelines. Every sentence earns its place: the first gives the high-level result, the second defines deterministic behavior and output, and the third routes the agent to or away from the tool. No filler or redundancy.

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

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

For a read-only, idempotent calculator with a fully described 3-parameter schema, the description is complete. It explains what is modeled, which providers are included, what the returned ranked table contains, and when to prefer an alternative. Even without an output schema, an agent has enough to select and invoke the tool 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%: invoiceUsd, as_of_date, and targetCurrency already have clear descriptions, defaults, and an enum. The tool description does not need to repeat parameter-level details, so baseline 3 applies; it adds no specific parameter meaning beyond the schema, but nothing is 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 opens with a specific verb-resource pair: 'Quantify cross-border payment fee drag and calculate net landed local currency across 6 global payout rails.' It names the rails explicitly and contrasts with contractor_parity, so an agent can distinguish this tool from its siblings without inspecting schemas.

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

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

The 'Usage Guidelines' section states exactly when to use the tool (international freelancers, remote workers, cross-border vendors choosing a payout rail or invoicing in USD) and explicitly says when not to use it (domestic US employee vs contractor parity), naming the alternative tool. This is model guidance.

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

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

Annotations already establish readOnly, idempotent, and non-destructive behavior; the description adds the exact calculation components: hallmark adjustments (24K/22K/18K/14K), statutory GST 3%, making charges, and regional unit conversions. This goes beyond annotations but stops short of describing output shape or the silver-input discrepancy.

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 that front-loads the main purpose and packs the feature list without fluff. The comma-separated list is efficient, though it reads slightly like a feature dump rather than structured guidance.

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

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

With rich schema descriptions and annotations, the agent has the parameter and safety context to invoke the tool. The description's calculation scope fills the behavioral gap, but the unbacked 'Silver' claim and absence of any output-format hint leave minor gaps.

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 covers 100% of parameters, including examples, patterns, enums, and defaults, so the baseline is 3. The description adds domain context (GST 3%, making charges, conversions) but no parameter-specific detail beyond what the schema already provides.

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

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

The description opens with 'Calculate Gold and Silver commodity valuation' and enumerates specific sub-computations (purity, GST, making charges, conversions), which is a clear verb+resource statement. It distinguishes this tool from the tax and investment siblings by subject matter, though no sibling is named. The mention of 'Silver' is unsupported by the input schema, which only includes gold-specific parameters, slightly diluting clarity.

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 use for gold valuation calculations, and the sibling list contains no other gold-specific valuation tool, so the agent can infer applicability. However, there is no explicit when-to-use or when-not-to-use guidance, no alternative tool references, and the unsupported 'Silver' claim muddies the boundaries.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior, and the description consistently supports that by saying the tool 'calculates' and 'computes' rather than mutating anything. It adds beyond the annotations by disclosing the rate schedule and that it 'enforces statutory turnover thresholds,' which tells an agent the tool will apply eligibility limits during calculation. The only omission is the precise failure mode when a threshold is exceeded.

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 front-load the core action and resource, then pack the differentiating category rates and threshold behavior into the second sentence. There is no filler or 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 calculation-only tool with no output schema, the description makes the output concept ('quarterly tax liabilities') clear and covers the input categories and thresholds that determine the computation. It would be slightly more complete if it described the output shape (e.g., total liability or per-category breakdown), but the core invocation contract is present.

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

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

Schema coverage is 100%, so the baseline is adequate, but the description adds extra meaning by mapping category values to concrete rates (trader/manufacturer 1%, restaurant 5%) and by clarifying that turnover parameters feed statutory threshold enforcement. It does not fully spell out how 'as_of_date' behaves beyond the schema's rule-pack note, but the added mapping is genuinely useful.

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 opens with a specific verb ('Calculate') and a well-defined resource ('statutory GST quarterly tax liabilities under the Composition Scheme'), and immediately distinguishes itself from the sibling 'gst_regular' by naming Section 10 of the CGST Act. It also names the three supported categories and their rates, so an agent cannot mistake it for a generic GST 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?

The phrase 'under the Composition Scheme (Section 10 of CGST Act)' provides clear context for when this tool is appropriate, and the turnover-threshold mention signals the main eligibility constraint. It does not explicitly name 'gst_regular' as the alternative or state when not to use it, so it stops short of a 5.

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

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

The description discloses deterministic, idempotent behavior with no side effects, which aligns with the idempotentHint and destructiveHint annotations. It further adds what a plain annotation can't: the engine refuses unknown rates, exclusive vs inclusive mode adds or extracts tax, and lists the return fields. This is rich behavioral context beyond 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?

The description is structured with a purpose sentence followed by clear 'Behavior' and 'Usage Guidelines' sections. Every sentence earns its place—no fluff, and the purpose is front-loaded before behavioral and usage details.

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 10 parameters, 100% schema coverage, and no output schema, the description compensates by listing the return fields (taxable value, CGST, SGST, IGST, cess, total tax, invoice total). It also clarifies the rate-rule-pack constraint and mode semantics, so an agent has everything needed to call it correctly.

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

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

Schema description coverage is 100%, so all 10 parameters are already documented in the input schema. The description adds only marginal value (e.g., explaining exclusive/inclusive mode, which the schema already covers for calculation_mode). Since the schema does the heavy lifting, the baseline 3 is appropriate.

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

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

The description states a specific verb (calculate) and resource (Indian GST under the regular scheme), and immediately distinguishes intra-state (CGST+SGST) from inter-state/export/SEZ (IGST) supplies. It names the sibling gst_composition, which disambiguates it from other tools without needing to inspect schemas.

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

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

The description explicitly states when to use it (registered person under the regular scheme) and when not to (composition-scheme taxpayer), and names the alternative gst_composition. This is clear routing guidance that leaves no inference to the agent.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the description's statement about deterministic, side-effect-free behavior adds little beyond annotations. However, it does disclose the return fields (monthly EMI, total payment, total interest percentage, first-year amortization breakdown) and the exact formula used, which are not covered by annotations or schema.

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

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

The description is organized into three focused paragraphs: purpose, behavior, and usage guidelines. It is front-loaded with the core action and includes the formula for transparency without being verbose. It could be slightly more compact by omitting the formula, but it earns its place.

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

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

With no output schema, the description adequately explains the return values (monthly EMI, total payment, total interest percentage, first-year amortization breakdown) and the calculation formula. It also names the alternative for edge cases. It does not mention potential errors or edge conditions, but for a deterministic calculation tool, the provided information is sufficient for correct invocation.

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

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

Schema description coverage is 100%, and each parameter is well-documented in the schema (e.g., principal pattern, interestRatePercent decimal string, as_of_date selection of rule pack, tenureYears default). The description does not add significant parameter-level meaning beyond what the schema provides, so the baseline of 3 applies.

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

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

The description opens with the verb 'Calculate' and names the specific resource: reducing-balance monthly EMI, total interest payable, and amortization schedule for home, auto, or personal loans. It clearly distinguishes from the sibling mortgage_piti by specifying that US residential mortgages are out of scope, so an agent can differentiate without inspecting other tools.

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 states when to use ('general global reducing-balance loans and consumer debt') and when not to ('US residential mortgages requiring property tax, hazard insurance, and PMI escrow'), and names the alternative tool (mortgage_piti). This leaves no ambiguity about selection criteria.

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 mark readOnly, idempotent, and non-destructive, and the description reinforces this with 'Deterministic, idempotent calculation with zero external side effects.' It goes beyond annotations by disclosing exact slab rates, the 87A rebate threshold, the 4% cess, and that it returns a side-by-side comparison plus a lower-tax determination.

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 well-structured with clear purpose, Behavior, and Usage Guidelines sections. It is front-loaded with the main purpose, and the slab-rate detail is dense but earns its place as necessary behavioral transparency. There is no filler or redundancy.

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

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

For a complex tax-comparison tool with no output schema, the description is remarkably complete: it specifies the assessment year, slab rates, rebate, standard deduction, cess, output behavior, and excluded use cases. An agent has enough information to invoke the tool correctly and interpret what it will return.

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 parameters are already well documented in the schema. The description adds useful tax context but does not provide additional parameter-specific meaning beyond what the schema already states for ctc, as_of_date, and isSalaried.

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 opens with a specific action and resource: 'Compute Indian personal income tax liability comparing... the New Tax Regime ... against the Old Tax Regime.' It names concrete statutory details (Section 87A rebate, ₹75,000 standard deduction, FY 2025-26 slabs), clearly differentiating it from tax siblings like tds, advance_tax, and tax_in.

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 provides explicit 'Use when computing personal income tax or payroll deductions for Indian residents and salaried professionals' guidance. It also gives a clear exclusion and alternative: 'Do not use for US federal/state taxes; use contractor_parity or solo_401k_shield instead.' This leaves little ambiguity about when to invoke the tool.

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

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

Beyond the readOnly and idempotent annotations, the description adds valuable behavioral context: it is deterministic, refuses rather than guesses when state is missing, and explains that regional units have state-dependent sizes. It also discloses the return structure (target value, square foot baseline, and 7-unit standard breakdown), which annotations do not provide.

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

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

The description is well-organized into labeled sections with the core action front-loaded. It is concise overall, though the requirement to specify state for regional units is stated in both the Behavior and Usage Guidelines sections, creating minor redundancy.

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

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

The description covers the central complexity of state-dependent regional units and the refusal behavior, and explains return values despite no output schema. However, it offers little context about the required 'as_of_date' parameter beyond the schema's terse 'statutory rule reference date' text, so an agent unsure how to choose that date gets limited guidance.

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 adds meaningful semantics by explaining why 'state' is conditionally required and that universal units resolve nationally, which helps the agent understand the relationship between from_unit and state. This goes just beyond the schema without fully documenting every conditional combination.

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 opens with a specific verb and resource: 'Convert Indian regional and universal land measurement units', and further scopes it by legal framework and states. This clearly differentiates it from the finance/tax-focused sibling tools and leaves no doubt about what the tool does.

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

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

There is an explicit 'Usage Guidelines' section instructing to specify 'state' for traditional units like bigha or katha to avoid ambiguous multi-fold variance. It gives clear context but does not name alternative tools or enumerate when not to use this tool; however, the sibling set is unrelated enough that this is a minor gap.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds substantial behavioral detail beyond that: 'Deterministic, idempotent calculation with zero external side effects', explains the calculation formula, conditional PMI logic (under 20% down until 78% LTV), and lists the return components. This goes far beyond the annotations and no contradiction exists.

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

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

The description is efficient and well-structured: purpose, behavior, and usage guidelines are separated. It is front-loaded with the main purpose and then adds necessary detail. Every sentence earns its place without redundancy.

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

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

For a complex tool with 8 parameters, no output schema, and conditional PMI, the description covers the core functionality, returns, and usage context. It mentions the amortization schedule, lifetime interest, and PMI thresholds. It does not explicitly mention edge cases like negative values or currency handling, but these are likely covered by schema validation. Overall, it is quite complete.

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

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

Schema description coverage is 100%, so baseline is 3. The description does not repeat parameter meanings but does add context about how they interact, e.g., 'down payment is under 20%' and '78% LTV threshold', which aids understanding. However, it does not provide per-parameter details beyond the schema, so it stays at baseline.

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

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

The description clearly states the tool's purpose: 'Calculate monthly US mortgage payments broken down into PITI...' with a specific verb (calculate) and resource (US mortgage payments). It also distinguishes from sibling home_loan_emi by specifying 'US mortgage' and later naming the alternative for international loans.

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 contains an explicit 'Usage Guidelines' section: 'Use for US residential home purchase financing and refinancing scenarios. Do not use for international reducing-balance loans without escrow/PMI; use home_loan_emi instead.' This provides clear when-to-use, when-not-to-use, and names the alternative tool.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint; the description adds meaningful context beyond that: deterministic behavior, zero external side effects, the Newton-Raphson iteration count/tolerance, and the warning about standard precision and unpassed reference tests. This is rich behavioral disclosure.

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 paragraphs: caveat first, then behavior/formula, then usage. Every sentence carries information (precision warning, algorithm detail, return values, sibling exclusions) with no filler. Efficient for the tool's complexity.

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 tool with no output schema, the description explicitly lists returned values (NPV, IRR percentage, PI, payback period) and explains input meaning. Combined with 100% schema coverage, it covers what an agent needs to call and interpret 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%, so all three parameters are already documented. The description repeats the NPV formula but adds no new parameter semantics beyond the schema. Baseline 3 applies because 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?

States a specific verb ('Compute') and resource (NPV, IRR, discounted payback period), and explicitly differentiates from the sibling compound_wealth by naming the alternative use case. An agent can tell this is for capital budgeting rather than simple interest compounding without opening other schemas.

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

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

Provides explicit when-to-use scenarios ('capital investments, M&A valuations...') and a direct when-not-to-use directive ('Do not use for simple compound interest projections... use compound_wealth instead'). No inference needed.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds valuable behavioral context beyond annotations: it states the operation is 'free, no credits', which is a cost behavior, and lists the specific data returned (checksums, citations). It does not contradict annotations and provides meaningful supplemental disclosure.

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 fluff: the first states the primary function and cost, the second details the output contents. The most important information is front-loaded, and every phrase earns its place. Structure is clean and easily scannable.

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 single optional parameter, no output schema, and read-only annotations, the description adequately covers what an agent needs: what the tool does, cost, and what data will be returned. It does not describe pagination or error cases, but for a simple metadata-listing tool this is a minor gap. The presence of a broad sibling list does not add complexity that this description fails to 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 fully documents the single optional engineId parameter, including example values and purpose. The description does not add any extra meaning about the parameter—it focuses on the tool's overall output. With the schema carrying the weight, a baseline of 3 is appropriate.

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

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

The description states a specific verb ('Lists') and resource ('official rate tables each calculator uses'), making the tool's purpose immediately clear. It also differentiates this from sibling calculator tools by framing it as a metadata/status tool, not a computation tool. The mention of concrete contents (hash checksums, citations) further sharpens the scope.

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

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

The description implies usage ('Lists the official rate tables each calculator uses') but does not explicitly state when to choose this over sibling calculators or when not to use it. There is no mention of alternatives or a decision context, leaving the agent to infer that this is for inspecting rate tables before running calculations. This is adequate but lacks explicit guidance.

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

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

Annotations already mark the tool read-only and idempotent, and the description adds independently valuable behavioral constraints: the ₹1,50,000 deposit ceiling, the 7.1% p.a. rate, monthly 5th-day balance compounding, and Section 80C tax-exempt treatment. An agent can predict the simulation rules precisely.

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 entire description is one dense, front-loaded sentence that begins with the core action and packs each subsequent clause with a binding rule. There is no filler or 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?

Between the annotations, the fully documented schema, and the description's statutory rules, the agent has almost everything needed to call the tool correctly. The only real gap is the absence of an output schema or any statement of the return shape, so the returned value (maturity corpus vs. schedule) remains slightly ambiguous.

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 input schema already documents all three parameters at 100% coverage with clear descriptions, including the ceiling and default tenure. The prose description enriches the domain context (rate, compounding, tax status) but does not add per-parameter meaning on top of the schema, so the baseline of 3 is appropriate.

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

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

The description names the action ('Simulate'), the exact instrument ('Public Provident Fund'), and the scope ('15-year statutory compound wealth accumulation under Ministry of Finance notifications'). This is specific enough to distinguish PPF from finance siblings like fd, sukanya, and sip without needing to open their schemas.

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

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

When to use the tool is implied by the resource-specific language—PPF, sovereign, Section 80C—so an agent can infer the use case. However, the description never states explicit conditions, exclusions, or alternatives, e.g., when to prefer sukanya or fd instead.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds behavioral detail beyond those: it explains the deterministic calculation flow (splitting profit into W-2 wages and K-1 distributions, applying 15.3% FICA to salary only, deducting employer-half FICA, subtracting CPA and payroll fees, computing breakeven). This gives the agent a clear model of what the tool computes without contradicting any annotation.

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 well-structured into Purpose, Behavior, and Usage Guidelines, front-loading the core purpose. It is somewhat verbose but every sentence contributes meaning—no filler. The length is justified by the tool's complexity, and the structure aids scanning.

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 calculation tool with no output schema, the description explains the key outputs (net tax savings, breakeven threshold) and the input context. It covers the legal basis, calculation steps, and usage boundaries. It could be slightly more explicit about the exact output fields, but overall it is complete enough for an agent to call it correctly.

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

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

Schema description coverage is 100%, so each parameter is already documented with type, default, and description. The tool description does not add direct parameter-level semantics beyond what the schema provides, though it gives context for netProfit and as_of_date indirectly (e.g., 'net business profit' and 'rule pack'). Baseline of 3 is appropriate given the high schema coverage.

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

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

The description opens with a specific verb and resource: 'Evaluate S-Corporation tax election viability' and enumerates the concrete outputs (reasonable officer salary split, SECA/FICA payroll tax shield, administrative overhead costs, net tax savings). It explicitly references IRS Rev. Rul. 74-44, anchoring its domain. It differentiates from siblings by naming solo_401k_shield as the alternative for retirement contribution limits, so an agent can disambiguate.

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

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

The Usage Guidelines section explicitly states when to use ('US small business owner, single-member LLC, or high-earning freelancer considering electing S-Corp status to reduce self-employment taxes') and when not to ('Do not use for retirement account contribution limits; use solo_401k_shield instead'). This leaves no ambiguity about selection among the large sibling set.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds value by specifying the exact compounding formula, the monthly compounding model, the step-up behavior ('dynamically increases monthly installment each 12-month cycle'), and the return values (maturity amount, invested capital, capital gains, year-by-year accumulation). No contradictions 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?

The description is well-structured with labeled 'Behavior' and 'Usage Guidelines' sections, and the purpose is front-loaded. It is efficient, though the phrase 'Deterministic, idempotent calculation with zero external side effects' partially repeats annotations already present, which prevents a top score.

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

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

For a read-only, idempotent calculator with 100% schema parameter coverage, the description provides complete usage context, an explicit formula, step-up behavior, and return output description. There is no output schema, but the description compensates by listing what is returned. No significant gaps remain.

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?

Input schema covers all 5 parameters with descriptions, achieving 100% coverage, so the baseline is 3. The description adds meaningful context for stepUpPercent by clarifying it takes effect per 12-month cycle, and it defines the overall calculation context around the parameters. This goes slightly 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 opens with a specific verb and resource: 'Calculate Systematic Investment Plan (SIP) mutual fund maturity wealth' with an optional annual percentage step-up. It clearly distinguishes from sibling compound_wealth by naming what this tool is not for (lump sum US 401(k)/Roth IRA compounding).

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 states when to use: 'Use for mutual fund SIP investments, recurring deposits, and goal-based financial planning' and when not to: 'Do not use for US 401(k) / Roth IRA compounding with lump sum; use compound_wealth instead.' This routes the agent to the correct tool without ambiguity.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description reinforces this ('Deterministic, idempotent calculation with zero external side effects'). It adds substantial behavioral context beyond annotations: the exact calculation steps (employee elective deferral limits, employer profit-sharing percentages for different entity types, statutory caps, and marginal tax rate multiplication), and even clarifies a common pitfall (the rejected 'llc' entityType). This is exactly the kind of additional context that helps an agent trust and correctly use the tool.

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 structured with clear labels ('Behavior:', 'Usage Guidelines:') and the primary purpose is front-loaded in the first sentence. It is a bit long, but every sentence contributes: the calculation logic, statutory caps, entity type caveat, and usage alternative all earn their place. It avoids fluff and maintains focus, though it could be tightened by removing the redundant 'zero external side effects' phrase that duplicates annotations.

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 a complex financial calculation with six parameters and no output schema, so the description carries the burden of explaining the return value. It does state that it 'returns net cash saved' and describes the computation pipeline, which is sufficient for an agent to understand the output. It also covers statutory limits, entity type rules, and catch-up eligibility, addressing the main edge cases. Minor gaps: it doesn't specify the exact output format (e.g., a single number vs. an object), and it doesn't mention error handling for invalid inputs, but these are not critical given the schema's explicit requirements.

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 goes beyond the schema by explaining how parameters interact: it specifies that entityType changes the profit-sharing percentage (20% for sole prop/LLC, 25% for S-Corp), that isAge50Plus unlocks the $7,500 catch-up, and that marginalTaxRatePercent is used to compute the cash tax savings. This adds meaningful semantic value, though the schema descriptions are already quite detailed. A 4 is appropriate—not a 5 because the schema already covers the basics, but the description enriches understanding of parameter relationships.

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 opens with a specific verb ('Maximize tax-deferred retirement sheltering') and resource ('Solo 401(k) vs. SEP-IRA contribution limits'), then details the exact computation (elective deferral + profit-sharing, capped at IRS Notice 2023-75 limits) and the output (net cash saved). This clearly distinguishes it from siblings like compound_wealth, which is explicitly named as the alternative for investment growth modeling. No ambiguity remains about what the tool does.

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

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

The description states precisely when to use it ('Use when an owner-only business, independent contractor, or partner wants to optimize pre-tax retirement deductions') and when not to ('Do not use for multi-year exponential compound investment growth modeling'), naming the specific sibling tool to use instead (compound_wealth). This leaves no inference to the agent.

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

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

The description goes well beyond the annotations by disclosing the exact calculation formulas (net burn = grossBurn - revenue, runway months = cashOnHand / netBurn, SAFE equity % = safeInvestment / postMoneyCap) and the deterministic, side-effect-free behavior, which aligns with readOnlyHint and idempotentHint. It fully explains what happens internally.

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 three-paragraph structure is efficient: the first paragraph lists core outputs, the second explains the math and safety, the third gives usage boundaries. Every sentence adds new information; no fluff or repetition. It is front-loaded with the purposes and then details the mechanics.

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

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

Given the complexity (9 parameters, no output schema), the description is quite thorough: it covers purpose, formulas, usage, and even mentions the 'shuffle waterfall'. The only minor gap is that it does not explicitly describe the exact output format (e.g., whether it returns a single JSON object with multiple fields), but this is implied by the listed calculations. The description is still strong overall.

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?

While the input schema provides descriptions for every parameter (100% coverage), the description adds crucial semantic context by explicitly connecting parameters through formulas (e.g., how cashOnHand and monthlyGrossBurn combine to yield runway). This helps the agent understand the relationships and intent behind each field, far beyond a bare listing.

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 opens with a precise list of three distinct calculations (runway exhaustion date, SAFE conversion dilution, and option pool shuffle waterfall), naming specific resources and formulas. It clearly distinguishes this tool from financial cousins like npv_irr, so an agent can immediately recognize its scope.

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

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

Explicitly states when to use it ('venture capital fundraising planning, startup cash runway tracking, and cap table dilution modeling') and when not to ('Do not use for discounted cash flow or IRR project appraisal'), and directs the agent to the correct sibling (npv_irr). This is textbook guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so safety is covered. The description adds behavioral specifics beyond the schema: compounding at 8.2% p.a., a 21-year maturity schedule, Section 80C EEE tax exemption, and adherence to Government of India statutory guidelines. This gives the agent useful context about how the calculation behaves without contradicting 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?

Two concise, well-structured sentences. The first front-loads the verb and scheme; the second packs the key calculation parameters. No filler or redundant phrases beyond minor contextual color.

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

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

Given the read-only, idempotent annotations and 100% schema coverage, the description provides sufficient context: it names the scheme, the rate, the maturity, and the tax benefit. It slightly lacks an explicit statement of output format (e.g., whether it returns a maturity schedule or a single value), but the phrase '21-year maturity schedule' implies the output shape. An agent can call it correctly without major gaps.

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

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

Schema description coverage is 100%, so all three parameters (girl_age, as_of_date, yearly_deposit) already have meaningful descriptions. The tool description adds context about the computation (rate, maturity, tax exemption) but does not add new meaning to the parameters themselves. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Simulate'/'Computes') with a specific resource ('Sukanya Samriddhi Yojana') and includes distinguishing details (girl child education, Section 80C EEE exemption, 21-year maturity) that separate it from sibling calculators like compound_wealth, ppf, or fd. No ambiguity about what the tool does.

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

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

The usage context is implied: this is the tool for SSY simulation. However, the description provides no explicit when-to-use guidance, no exclusions, and no mention of alternative sibling tools (e.g., ppf, compound_wealth) that might also be relevant to small savings or compounding queries.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so safety is covered. The description adds useful context about the specific tax law sections, standard deduction, and rebate thresholds, which goes beyond the annotations. However, it does not disclose any additional behavioral traits such as output format or potential external dependencies.

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

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

The description is two sentences and front-loads the purpose. It packs specific statutory details efficiently without wasted words. It is slightly dense but remains clear and focused.

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 has 5 parameters and no output schema. The description explains the computation and mentions the dual-regime comparison, implying the output likely includes both results. However, it does not specify the exact return format or how the as_of_date parameter affects the computation. Given the complexity and lack of output schema, more detail would improve completeness.

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 parameters are documented in the schema. The description adds context about Chapter VI-A deductions (mapping to 80C/80D) and the dual-regime nature, but it does not add syntax or format details beyond what the schema provides. The baseline of 3 is appropriate when the schema carries the parameter documentation.

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 clearly states the tool computes Indian personal income tax under specific acts and performs a dual-regime comparison. It is specific about the verb and resource, but it does not explicitly differentiate from the sibling 'indian_income_tax' or 'tax_in_new'. The title 'old regime' conflicts with the dual-regime description, but the description 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?

The description provides no guidance on when to use this tool versus alternatives like 'tax_in_new' or 'indian_income_tax'. It does not state conditions or exclusions, leaving the agent to infer usage from the description alone.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds meaningful behavioral context by specifying the statutory regime and the included deductions/rebate, which tells the agent what the computation will incorporate.

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 sentence that front-loads the core action and resource, then adds the key statutory details. Every part earns its place, with no filler or redundant restatement of the tool name.

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 computation tool with no output schema, the description gives enough context to invoke it correctly: the regime, the included deductions, and the input scope are clear. It does not explicitly describe the return value or mention exclusions like surcharge/cess, but the schema and annotations cover most operational needs.

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 three parameters. The description mentions standard deduction and Section 87A rebate, which loosely relates to is_salaried and gross_income, but it does not add parameter-level detail beyond what the schema provides.

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

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

The description uses a specific verb ('Compute') and names the exact resource: Indian Personal Income Tax under Section 115BAC New Concessional Regime. It also identifies the key calculation components (standard deduction and Section 87A rebate), which clearly distinguishes it from generic tax siblings like indian_income_tax or tax_in.

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

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

The phrase 'New Concessional Regime' and 'Section 115BAC' imply this tool is for the new regime, but the description does not explicitly state when to use it versus sibling tools like indian_income_tax or tax_in. There is clear context but no explicit exclusions or alternative routing.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The definition adds meaningful behavioral context beyond this: the nature parameter discloses that there is no default 'because a default would choose a section on the caller's behalf,' as_of_date selects 'the rule pack in force on that date,' and buyer_pan_status discloses that missing/invalid PAN returns INSUFFICIENT rather than an understated number. No contradiction exists between the read-only annotations and the pure-calculation 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 dense sentences front-load the core purpose ('Calculate statutory TCS under Section 206C') before the scope detail, with no filler or redundancy that fails to earn its place. Given the 16-value enum and multi-section statutory complexity, the word count is efficient and well ordered, though the double mention of 206C is slightly repetitive.

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 high-complexity tool — 16 nature enums, date-dependent rate packs, and a refusal edge case — the definition covers statutory scope, both required parameters, and the buyer_pan_status edge behavior. With no output schema present, the one meaningful gap is that the return format is never described, so an agent cannot predict whether the result is a single number or a structured breakdown.

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 schema already carries the load. The parameter descriptions are unusually rich — amount is pinned to INR with a pattern, nature explains section-selection and no-default semantics, as_of_date explains rule-pack selection, and buyer_pan_status discloses the refusal behavior. The main description adds value beyond the schema by mapping the enum space back to statutory context (the ₹50 lakh threshold, the 206CC higher-rate mention), justifying a score above baseline.

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

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

The description opens with a specific verb ('Calculate') and a precise resource: statutory Tax Collected at Source under Section 206C of the Income-tax Act, 1961, and it pins the applicable period (AY 2025-26 / FY 2024-25). It further enumerates the exact coverage scope (goods above ₹50 lakh, scrap, timber, liquor, minerals, LRS, overseas tours), which sharply distinguishes it from a generic tax calculator. It stops short of a 5 because it never explicitly names the closest confusable sibling (tds), so differentiation relies on statutory terminology rather than an explicit exclusion.

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 covered-category list and the 206C/206CC statutory citations strongly imply when the tool applies, and the nature parameter's 'State it exactly; it is not inferred' gives the agent a clear invocation instruction. However, there is no explicit when/when-not statement, no named alternative (e.g., routing TDS matters to the tds tool), and no exclusion scenarios, so an agent must infer routing from statutory context rather than explicit guidance.

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

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

The description goes beyond the annotations (readOnlyHint=true, idempotentHint=true, destructiveHint=false) by disclosing specific behavioral traits: it supports higher deduction rates under Section 206AA for missing PAN and evaluates precedence between 194Q and 206C(1H). These are concrete behaviors that an agent needs to know. It does not contradict any annotation, and the added detail enriches the safety and scope profile beyond what the structured hints convey.

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, information-dense sentence that front-loads the core purpose ('Calculate statutory TDS') and then efficiently lists the supported sections and specific behaviors. Every phrase earns its place; there is no filler. The structure allows an agent to quickly grasp scope without wading through redundant detail.

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 tool with 7 required parameters and no output schema, the description covers the statutory scope and key behaviors but omits the return format (e.g., whether it returns a rate or an amount) and does not explicitly mention edge-case refusals (e.g., non-resident payments) that are documented only in the schema. Given the complex statutory context and the absence of an output schema, the description is adequate but not fully complete—it leaves an agent to infer the call's outcome.

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 input schema already covers all parameters with detailed descriptions at 100% coverage, so the baseline is 3. The description adds only marginal parameter-related meaning: it mentions sections that map to payment_type (e.g., 194C for contract) and the PAN-related sections (206AA) that tie to pan_available, but it does not elaborate on parameter syntax or interactions beyond what the schema already states. It does not meaningfully compensate for any gap, but none exists.

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 opens with a specific verb ('Calculate') and a precise resource ('statutory Tax Deducted at Source (TDS) under the Indian Income-tax Act, 1961'), then enumerates the exact statutory sections supported (194C, 194J, 194Q, 194H, 194I, 206AA, 206C(1H)). This unambiguously identifies the tool's function and distinguishes it from other tax tools in the sibling list (e.g., tcs, advance_tax, gst_composition).

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 clearly implies usage for TDS calculations by naming the supported sections, but it does not explicitly state when to use this tool versus alternatives like tcs, advance_tax, or indian_income_tax. There is no mention of exclusions (e.g., 'for TCS use tcs') or conditions that would route an agent to a sibling. The guidance is implicit rather than explicit, so it meets a baseline but not the bar for clear differentiation.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, so the safety profile is known. The description adds value by spelling out deterministic behavior, zero external side effects, the exact formulas for both modes, and the rounding to 2 decimals. It does not contradict annotations, though it could further clarify what 'statutory rate verification' means in practice.

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 well-organized into purpose, behavior, and usage sections without repetition. It is slightly verbose with the formula details, but every sentence serves a functional role (modes, formulas, output, usage boundaries). It could be trimmed, but it remains efficient and front-loaded with the main purpose.

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 tool with 4 parameters and no output schema, the description explains the expected return values (net, tax, gross rounded to 2 decimals), the modes, and the input date requirement. It omits error handling or edge cases, but for a deterministic calculator with schema coverage, it is adequately complete to guide correct invocation.

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

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

Schema description coverage is 100% and each parameter already has a clear description (mode enum semantics, amount meaning per mode, date pattern, rate bounds). The description reinforces the meaning of amount and mode via formulas but does not add genuinely new parameter-level semantics beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states a specific verb+resource ('Calculate European Value Added Tax and global sales taxes') and elaborates with two modes (add/remove) and rate verification. It distinguishes the tool from tax siblings by specifying European VAT and global sales tax scope, and even names tip_splitter as the tool to use for tipping scenarios, making differentiation explicit.

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

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

Explicit use cases are listed ('e-commerce, international invoicing, retail pricing, and VAT compliance calculations') and a clear exclusion is given ('Do not use for restaurant tipping and bill splits') with a named alternative ('use tip_splitter instead'). This is exactly the when-to-use and when-not-to-use guidance the rubric rewards.

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