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

The description adds return behavior beyond the annotations: 'Returns: Consent request payload and validation notes.' The read-only and idempotent behavior is already covered by annotations, so the description does not need additional side-effect disclosure. No annotation contradiction.

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

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

The description is front-loaded with a clear purpose statement and use-case sentence, then a compact Args list and return note. It repeats a few defaults already present in the schema, but the structure is scannable and remains appropriately concise.

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 9-parameter builder, the description covers purpose, usage context, all parameters, defaults, and the return payload. It does not explicitly spell out that the periodic frequency fields are conditional, but the 'for PERIODIC' labels plus the schema supply adequate 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 coverage is 100%, so the schema already documents all parameters. The description adds some situational context, such as 'for PERIODIC' and the default purpose code, but it does not substantially go beyond the rich schema 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?

The description states a specific verb and resource: 'Build AA (Account Aggregator) consent request JSON per ReBIT spec.' This clearly distinguishes it from sibling validation/decode tools, which operate on different resources or behaviors.

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's 'Use when setting up data sharing consent for open banking workflows' provides a clear trigger context. It does not explicitly mention when not to use it or point to a validation sibling, but the primary use case is sufficiently scoped.

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 and idempotentHint, and the description adds genuinely useful behavioral details: parallel execution via ThreadPoolExecutor, a 500-item cap, per-Aadhaar results with counts, and consistency with the single-tool Verhoeff algorithm. 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?

The description is well organized with clearly labeled sections: usage, args, returns, and notes. Every sentence earns its place, and the main purpose is front-loaded before implementation 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 only one parameter, a rich output schema, and annotations covering safety, the description provides everything needed: when to use it, input normalization, batch limit, parallelism, and return behavior. Nothing important 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?

The schema covers the parameter at 100%, but the description adds meaningful input semantics beyond the schema by stating that numbers may include spaces or hyphens and reinforcing the max-500 list constraint. This helps the agent prepare valid input.

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

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

States a specific verb and resource: validate multiple Aadhaar numbers. The description adds parallel execution detail, and the word 'multiple' plus batch focus clearly distinguishes it from validate_aadhaar.

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 says to use when batch-validating for KYC, onboarding, or compliance workflows, which gives clear context. It does not explicitly name validate_aadhaar as the single-item alternative, so it falls just short of full when-not/alternatives 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?

Even though readOnlyHint and idempotentHint already indicate this is a safe, repeatable census-style operation, the description adds meaningful behavioral detail: execution uses a ThreadPoolExecutor, batches scale to ~N/10 parallel calls, up to 500 GSTINs are allowed per call, and individual validation errors do not fail the entire batch. This is exactly the kind of context beyond annotations that helps an agent invoke it correctly.

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 compact, well-sectioned with Args/Returns/Notes, and front-loaded with the core action and use case. Every sentence carries useful information: parallel execution, typical use case, limit, configurability, and partial failure behavior. No filler or redundant repetition.

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

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

For a single-parameter validation tool with a full output schema, this description is complete. It tells the agent what the operation does, when to use it, the input format, the call limit, parallelization behavior, and what happens on partial errors. Nothing necessary for correct invocation 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?

The schema already describes the single gstins parameter as a list of GSTINs with a max of 500, and schema coverage is 100%. The description adds an important extra constraint — each string must be 15 characters — and clarifies that results are returned per GSTIN, adding meaningful nuance beyond the schema alone.

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 — validating multiple GSTINs in parallel — and clearly distinguishes this bulk operation from the single-value sibling tools like validate_gstin. The resource and scope are unambiguous: multiple GSTIN values are batch-validated rather than validated one at a time.

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 says to 'Use when batch-validating vendor GSTINs for onboarding or reconciliation' and explains that it replaces many serial calls with a single parallel batch. This gives clear context, though it does not explicitly name validate_gstin as the alternative for single-item validation or mention when a small batch should use the singular path 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, openWorldHint=false, and idempotentHint=true, so the safety profile is covered. The description adds the parallel execution detail but does not clarify what 'validate' means in terms of depth (e.g., format only vs. bank/branch existence) or how results are reported.

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 extremely brief and front-loaded with the essential purpose. The permission tag is redundant with the annotations but does not create meaningful bloat, so the definition remains high-signal.

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 low-complexity, single-parameter, read-only tool, the description plus the input schema and output schema together give the agent enough to select and invoke the tool correctly. No essential dynamic behavior or destructive consequence is left uncovered.

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 parameter description already defines the array of IFSC codes and the 500-code cap. The description's 'multiple' adds little beyond the schema and does not give format examples or additional usage semantics for the single parameter.

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 (validate), a specific resource (IFSC codes), and clearly focuses on multiple codes being checked in parallel. This differentiates it from singular tools like lookup_ifsc and from other bulk validators by naming the exact resource type.

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 'multiple IFSC codes in parallel' clearly signals this tool is intended for batch validation rather than single-code lookups or validation of other identifiers. It does not explicitly exclude lookup_ifsc for single-code checks, but the bulk context is reasonably clear.

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

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

Annotations already declare readOnly and idempotent hints, so the description's main added behavior is the 'in parallel' execution trait, which is meaningful for understanding concurrency/review implications. The '# PermissionTier' tag slightly reinforces the read-only nature but mostly duplicates the 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?

One short active sentence plus a metadata tag, with no filler. The verb and resource are front-loaded, and every token 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?

Given a single simple parameter, rich schema coverage, an output schema, and annotations covering safety and idempotency, the description provides all needed context. 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?

The schema description covers 100% of parameter semantics, including 'List of PANs to validate (max 500)'. The tool description adds no further parameter depth, so baseline 3 is appropriate.

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

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

Description states a specific verb ('Validate'), a concrete resource ('multiple PANs'), and a behavioral nuance ('in parallel'). This unambiguously distinguishes it from single-item siblings like validate_pan.

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?

Implied usage context is clear: use this when validating multiple PANs in parallel, contrasting with single-PAN tools. However, it does not explicitly name the alternative or state when not to use it.

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

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

With annotations already establishing readOnly and idempotent behavior, the description augments them by explaining the concrete calculation rules: specific quarterly due dates with cumulative percentages and a 1% per month interest rule. It also states the return envelope contains the schedule and interest rules, going beyond the bare annotation information.

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 with a one-sentence summary, a usage sentence, and a clear Args/Returns/Notes layout. Every line adds information about inputs, output shape, or the underlying calculation rules, and there is no redundant or fragmented content.

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

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

Given that the output schema already carries return details, the description covers the remaining context needed for a computation of tool: the practical scenario, the fiscal year, the expected due dates, and the interest rule. An agent is equipped to use it without ambiguous assumptions.

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 coverage is 100%, but the description enriches a few parameters: it ties estimated_income to FY2025-26, explains taxpayer_type as 'category for slab selection,' and frames existing_tds as 'likely' deductible TDS. These small nuances clarify intent beyond the schema descriptions alone.

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 quarterly advance tax installment schedule per Sections 234B and 234C.' This clearly identifies the tool's output and differentiates it from siblings like calculate_income_tax or calculate_tds, since it focuses on installment scheduling and specific legal sections.

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 text provides a clear use case: 'Use when planning quarterly tax payments to avoid interest penalties.' This tells the agent when to invoke the tool, though it does not explicitly name alternative tools or situations to avoid, which keeps it a step below full exclusion 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 and idempotentHint=true, so the safety profile is covered. The description adds relevant behavioral context beyond annotations, including Budget 2024 rate rules, STCG/LTCG breakdown expectations, the default 365-day holding period, and the specific return envelope containing tax rates and liability.

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 a summary sentence, Args, Returns, and Notes sections. It is somewhat longer than minimal, but the length is justified by tax context and asset-type coverage. The key usage condition is front-loaded in the opening sentence.

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 fiscal year, usage window, key tax regime, asset types, and output envelope, which is sufficient for a read-only calculator with an output schema. It does not exhaustively explain complex edge cases like indexation thresholds or asset-specific holding period differences, but those are partially covered by parameters and notes.

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 8 parameters at 100% coverage, including descriptions like 'sale proceeds in rupees' and 'CII for purchase year'. The description mostly restates the parameters and adds modest clarification such as 'sale proceeds after expenses' and 'expenses incurred during sale', but it does not materially improve on the schema's 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 opens with a specific verb and resource: 'Calculate capital gains tax for various asset types' and scopes it to FY2025-26. It names the covered asset classes (equity, mutual funds, real estate, gold), which clearly distinguishes this tool from sibling calculators like calculate_income_tax, calculate_tds, and calculate_gst.

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 an explicit 'Use when computing tax liability on sale of equity, mutual funds, real estate, gold, or other capital assets' condition. It does not explicitly exclude or direct to alternatives like calculate_income_tax, but the stated trigger context is clear enough for an agent to select it among the calculation siblings.

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

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

Annotations already indicate read-only and idempotent behavior. The description adds valuable context: 'standard reducing balance formula', a lender-variance caveat, and the year-by-year schedule detail. 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?

The description is well-organized with clear headings, front-loaded usage guidance, and concise parameter notes. Every sentence is purposeful and there is no redundancy.

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

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

Given the read-only annotations and full output schema, the description provides all needed context: use cases, formula, caveats, and parameter constraints. The tool can be invoked correctly without missing information.

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

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

Schema coverage is 100%, so the schema already documents all parameters clearly. The description adds only minor extras like tenure max 360 and the loan_type label, which slightly improves clarity but does not fully warrant more than 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?

States a specific verb and resource: 'Calculate EMI for a loan with year-by-year amortization schedule.' It also distinguishes itself from the many sibling calculators by emphasizing the amortization schedule, which is unique enough.

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 usage contexts: 'Use when computing loan EMIs, comparing loan options, or planning prepayment strategies.' However, it does not mention when to avoid using it or explicitly point to an 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=true and idempotentHint=true, setting the behavioral safety baseline. Beyond that, the description adds valuable statutory context: the ₹15,000 EPF ceiling and the ₹21,000 ESIC applicability threshold. It also hints at output through 'EPF breakdown, ESIC applicability, and totals.'

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 compact and well-organized: purpose in the first sentence, clear usage guidance, argument list, return hint, and domain-specific notes. Every sentence earns its place without 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?

The tool has an output schema, so the return breakdown need not be restated. The description covers purpose, usage scenario, key statutory thresholds, and the employer/employee dimension. It is complete for the intended payroll-cost comparison and deduction contexts.

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

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

The schema already covers 100% of parameter descriptions, so the baseline is 3. The description adds meaningful parameter-level context through the statutory limits, particularly that gross wages determine ESIC applicability and the EPF computation ceiling is ₹15,000. This goes beyond merely restating 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 EPF and ESIC contributions for employer and employee.' It clearly distinguishes itself from the many sibling calculators (e.g., calculate_gratuity, calculate_income_tax) by naming the exact statutory payroll contributions it handles.

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 the tool: 'Use when computing payroll costs, employee deductions, or comparing CTC structures across different salary levels.' This is clear context but does not provide exclusions or explicit alternatives, so it misses the top score.

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 and idempotentHint, so the basic behavior is covered. The description adds useful detail such as the 0.25% senior citizen extra rate and the ₹40,000/yr TDS threshold, but doesn't disclose rounding rules or day-count conventions beyond the schema.

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

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

Purpose is front-loaded and the description is structured into an action sentence, a usage line, parameter notes, and a returns explanation. It is mildly redundant because all argument details already appear in the schema, but it stays readable and doesn't waste words.

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 output schema exists and the input schema is fully self-documenting, the description covers the important usage aspects: when to use, what to expect as a return, maturity with interest breakdown, and TDS. It doesn't cover rounding conventions or edge-case inputs, but these are not critical for a maturity calculator tool.

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

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

Schema coverage is 100%, so the schema already documents all parameters. The description enriches a few semantics: it names the compounding frequency allowed values, and adds the clear '0.25% extra rate' and TDS threshold details that the schema omits. This helps the agent provide more accurate inputs.

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 and resource: 'Calculate Fixed Deposit maturity amount.' It identifies the domain and distinguishes it from sibling financial calculators (RD, PPF, SIP), though it doesn't explicitly call out the nearest sibling for contrast.

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 usage cues with 'Use when projecting FD returns or comparing deposit options.' This tells an agent when the tool is appropriate, though it doesn't mention alternatives like calculate_rd_maturity or explicitly say when not to use it.

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

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

The annotations already state readOnlyHint=true and idempotentHint=true, so the description's job is lighter. It adds helpful behavior context by noting the standard envelope return format, the minimum service requirement, and the ₹20,00,000 tax-exempt ceiling. This is consistent with 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 text is well-structured into Args, Returns, and Notes sections. Every sentence adds information, and it is not bloated. It front-loads the core purpose before diving into arguments.

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 output schema is present and annotations already signal read-only/idempotent, the description covers the important non-obvious constraints (5-year minimum, tax exemption ceiling, coverage threshold). It stops short of describing the exact computation formula, but the tool's own return envelope likely makes that unnecessary.

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 provides 100% coverage with clear descriptions and a decimal/fraction example for years_of_service. The description partially restates the schema, but the Notes add meaning to years_of_service by defining the 5-year minimum and the tax-exempt condition, which is beyond the schema.

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

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

The description states a clear verb and resource: 'Calculate gratuity under the Payment of Gratuity Act, 1972.' This is unambiguous and distinct from the sibling tools, which cover taxes, loans, and validation rather than gratuity calculations.

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

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

It explicitly names use cases: 'computing terminal benefits, comparing CTC packages, or planning retirement benefits' and adds key constraints such as 'Minimum 5 years service required (except death/disablement).' It does not explicitly point to an alternative sibling tool, but no sibling directly overlaps with gratuity.

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 adds value beyond the read-only and idempotent annotations by explaining key behavioral details: amount can be inclusive or exclusive of GST, mutations are not made, and rate classification warnings are given. A minor gap is not being explicit about what happens if invalid GST rates are provided, but overall transparency is strong.

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 a clear purpose line, use context, Args, Returns, and Notes sections. It is fairly concise but includes some vertical space and content that overlaps with the schema, which prevents a perfect 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?

With full schema coverage, an output schema, and annotations signaling read-only idempotent behavior, the description provides ample context: it states the business scenario, explains the optional cess behavior, and warns about rate variability. No critical operational detail 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?

The schema already covers 100% of parameters with clear descriptions, so the description's parameter section adds marginal value. It restates the same meanings (e.g., 'base amount or GST-inclusive amount', 'back-calculate base') without introducing substantially new semantics.

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 the specific verb 'Calculate' and identifies the exact resource: GST breakdown with CGST/SGST/IGST split and optional cess. It clearly distinguishes the tool from siblings like calculate_gst_late_fee by naming the core computation and its 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 explicitly states when to use the tool: 'Use when computing tax for invoices, quotations, or GST compliance.' This provides clear context, though it does not explicitly contrast with sibling calculators like calculate_gst_late_fee or check the xlsx calendar.

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 openWorldHint=false, covering safety and predictability. The description adds that output is a 'Late fee breakdown with CGST/SGST split,' but does not disclose other behavioral details such as penalty calculation cap behavior or edge cases. With annotation coverage, a 3 is appropriate.

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

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

The description is compact and well-structured, with a purpose sentence, usage context, arguments, and return value. Every section is needed and squarely supports tool invocation.

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 has an output schema, annotations, and complete parameter schema, the description sufficiently covers behavior, inputs, and output type. It lacks explicit mention of edge cases such as nil liability fee adjustment, but overall it is complete enough 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?

Although schema coverage is 100%, the description adds meaning by noting that annual_turnover is used 'for cap calculation' and clarifies has_nil_liability as 'True if nil return.' This goes beyond the plain schema descriptions and helps the agent understand how the parameters affect the calculation.

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 immediately states a specific action ('Calculate GST late filing penalty') with a specific resource. This distinguishes it from sibling tools like calculate_gst or calculate_income_tax, and the object of the calculation is clear.

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

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

The description explicitly says when to use it: 'Use when estimating late filing fees or planning compliance.' It does not mention alternatives or exclusion criteria, but the context is clear enough for an agent to select it appropriately among the siblings.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent already knows this is a safe, non-mutating operation. The description adds a brief output summary ('yearly breakdown and break-even analysis') but no additional behavioral caveats or assumptions. There is no contradiction with 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 opening is effective, and the use-when line is front-loaded. However, the description duplicates the entire input schema with a 9-line Args block, and the Returns line overlaps with the available output schema. It is structured and readable, but not every part 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?

The description explains the decision context and outlines the output shape, while the schema covers all 9 arguments with defaults and units. It omits edge-rule details like how negative values or extreme assumptions are handled, but the output schema and full parameter documentation make it complete enough for confident 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?

All 9 parameters already have full schema descriptions with defaults, units, and meanings, so the Args list in the description is largely redundant. Where the description is terse, such as 'Loan tenure', the schema provides the needed clarification.

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 starts with a clear verb and resource: 'Compare buying vs renting financial outcome.' It immediately separates this from sibling tools like EMI, income tax, and GST calculators. The added 'Use when deciding between buying a home or renting' reinforces the exact decision it supports.

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 an explicit trigger condition: 'Use when deciding between buying a home or renting.' It does not mention alternatives or exclusion conditions, but among the sibling tools there is no other buy-vs-rent comparison, so the usage context is sufficiently clear.

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

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

Annotations already provide readOnlyHint and idempotentHint, so the no-side-effect behavior is covered. The description adds useful behavioral detail: the exemption is the minimum of three conditions, government employees use a simplified formula, and the return includes exemption, taxable HRA, and breakdown. This goes beyond the structured fields.

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 front-loaded with the core purpose, followed by a structured Args, Returns, and Notes section. It is somewhat repetitive with the schema but the formula notes earn their place. The overall length is justified.

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 given the tool's moderate complexity covers the calculation rule, the parameter semantics, and the returned envelope. There is also an output schema, so the return shape does not need desktop enumeration. This is sufficient for an agent 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?

Although schema description coverage is 100%, the description adds extra semantic value by explaining metro vs non_metro as 50%/40% of salary and clarifying government employees use a simplified formula. It also restates input units (monthly/rupees), making each parameter's role easier to interpret.

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

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

The description states a specific verb and resource — 'calculate House Rent Allowance (HRA) exemption under Section 10(13A)' — so the agent knows exactly what function is being performed. It also narrows scope to tax-exempt HRA for salary structuring and income tax filing, which clearly separates it from the many sibling tax/income calculator 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?

The description gives clear conditions: 'Use when computing tax-exempt HRA component for salary structuring or income tax filing.' This is actionable and context-specific, though it does not name sibling tools to exclude or state when not to use this calculator.

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

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

Despite having readOnlyHint and idempotentHint annotations, the description adds substantial behavioral detail: slabs, rebate, surcharge, marginal relief, cess, and estimated nature of the result. It also describes the return content, including effective rate, monthly tax, take-home, and regime recommendation. The 'estimate only' caveat is useful for expectancy-setting.

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 slightly longer than necessary because it duplicates the schema's parameter details, but the structure is excellent: purpose first, usage next, algorithm scope, then Args/Returns/Notes. The front-loaded first sentence summarises the tool in one line, and the rest is organized so an agent can skim.

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 there is a full input schema, output schema, and read-only annotations, this description fills the remaining gaps: FY20-26 rate applicability, what calculations are included, what the return envelope contains, and the estimate/caveat. It covers everything needed to decide when to invoke this tool and what result to expect.

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

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

Schema description coverage is 100%, so the schema already explains every param, but the description adds 'old regime only' qualifiers on the deduction no-param title is already clear. The Args block restates some schema text, yet it also clarifies grouping, which helps an agent avoid using these deductions with the new regime.

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 exact verb and resource: 'Calculate Indian income tax for FY2025-26 under old, new, or both regimes.' It quickly distinguishes this from tax-adjacent siblings like calculate_tds or calculate_surcharge by emphasizing income tax and regime comparison. The added 'slab computation, §87A rebate, surcharge with marginal relief, and health & education cess' makes the scope unmistakable.

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 'Use when computing tax liability, comparing regimes, or planning deductions.' It does not name alternatives or give negative guidance, but the 'Use when' clause gives clear context for callers. The old-regime-only notes on deductions additionally guide when certain parameters should be passed.

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 and idempotentHint=true, which cover the safety profile for this pure calculation tool. The description adds that it calculates penalty interest and returns a breakdown, but it does not go deeper into assumptions, formatting, or edge cases. It remains consistent with annotations.

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

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

The description is concise and front-loaded, with the core purpose stated in the first line and a direct usage guideline next. The Args and Returns sections are somewhat redundant with the structured schema, but they remain brief and do not bloat the description.

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 calculation utility with full schema coverage and an output schema. The description provides enough context about when to use it, which sections it covers, and what inputs are relevant. Nothing essential for an agent to select and invoke this tool correctly is missing.

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

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

Schema description coverage is 100%, so the schema already documents every parameter. The description repeats the parameter names and brief meanings without adding new semantics beyond what the schema provides, such as units or calculation rules. This matches 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 opens with a specific verb and resource: 'Calculate interest under Sections 234A, 234B, 234C.' It names the exact tax provisions and clarifies the purpose as computing penalty interest, distinguishing it from sibling calculation tools like calculate_income_tax and calculate_advance_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 description explicitly states when to use this tool: 'Use when computing penalty interest for late tax filing or short advance tax payments.' It gives clear usage context, though it does not explicitly name alternative tools or exclude scenarios where this tool should not be used.

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

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

The annotations already cover read-only and idempotent behavior. The description additionally states the statutory basis (Section 10(10AA)) and the expected output shape (exemption amount and taxable breakdown), adding useful behavioral context beyond the annotations. 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 front-loaded with purpose and usage context, and the Returns line is useful. The Args duplication is somewhat redundant with the schema, and this prevents a 5, but the overall structure is still compact and 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 an output schema present and strong annotations, the description is largely complete: it names the law, the inputs, and the output type. It could benefit from clarifying how the is_government_employee flag impacts the exemption, but the core callable details are sufficiently covered.

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

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

Schema description coverage is 100%, and the Args section mostly repeats the schema text without adding new meaning. The description does not explain key calculation nuances such as how years_of_service converts to months or exactly how is_government_employee changes the exemption, so it stays at 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 opening sentence clearly identifies the verb, resource, and legal basis: 'Calculate tax-exempt portion of leave encashment under Section 10(10AA).' This is specific enough to stand out from the many sibling calculators, such as calculate_gratuity and calculate_income_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?

It gives an explicit and useful 'Use when' condition: when computing leave encashment tax exemption or planning retirement tax. It doesn't name alternatives or state when-not-to-use it, so it misses a 5, but the context is clear in practice.

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 as read-only and idempotent, so no additional safety disclosure is needed. The description adds useful behavioral context by specifying the return shape: 'Charge breakdown with base charge, GST, and total.' It doesn't contradict 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 compact and front-loaded with the purpose and usage context, followed by a flat Args/Returns structure. It is a bit redundant with the schema, but every section earns its place and there is no filler.

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

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

Given the output schema is present and annotations cover the read-only/idempotent profile, the description is largely complete: it names the inputs, the intended use case, and the nature of the result. It could add caveats about charge-schedule assumptions, but nothing critical is missing for basic 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 every parameter. The Args section largely mirrors the schema rather than adding new semantics such as amount ranges, exact transfer_mode formats, or handling of defaults.

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 NEFT/RTGS/IMPS/UPI transaction charges.' This unambiguously identifies the tool's function and distinguishes it from the many validation and other calculate_* siblings without needing to inspect parameters.

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

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

It explicitly states 'Use when estimating bank transfer costs or comparing payment modes', giving agents a clear trigger for selecting it. It does not enumerate when not to use it or name closer alternatives, but the guidance is clear enough for the intended scenario.

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 communicate readOnlyHint and idempotentHint, so the description does not need to restate that this is a safe read-only calculation. The description adds useful behavioral context by naming returned outputs: projected corpus, lump sum, and monthly pension estimate, supplemented by the 'estimate' qualifier. No side effects, mutations, or hidden dependencies are described, which is appropriate given the calculation 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 purpose-first and then includes a usage line, a succinct Args list, and a Returns line. Every sentence is informative and there is no filler, but the Args block largely duplicates the schema and could be trimmed without losing meaning, so it is not a 5.

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 deterministic calculation nature, the readOnly/idempotent annotations, the fully documented schema, and the presence of an output schema, the description is complete enough for reliable usage. It states the input domain, the output nature, and the retirement-planning context. Nothing necessary for correct selection or invocation is missing.

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

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

Schema coverage is 100%, and the description essentially repeats the parameter names and short meanings already present in the input schema. For example, 'annuity_rate: Annuity rate %' adds no information beyond the schema's 'Annuity rate percentage.' The only marginal addition is calling out 'corpus to buy annuity (min 40%)', but that constraint already appears in the schema. This lands at the baseline 3.

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

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

The description opens with a clear, specific verb and resource: 'Calculate NPS corpus and monthly pension at retirement.' This leaves no ambiguity about what the tool does and distinguishes it from siblings like calculate_sip_returns or calculate_sukanya_samriddhi, because it is the only NPS retirement projection tool in the list.

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: 'Use when planning retirement with NPS or projecting pension.' This gives clear context, though it does not explicitly say which alternative tools to use for non-NPS projections or list exclusions, so it does not fully earn 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?

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds useful behavioral context beyond that: it notes the EEE tax treatment, fact that returns come in a standard envelope, and that the interest rate is government-administered and revised quarterly. 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 compact, highly structured, and every section earns its place: purpose, use cases, arguments, return, and notes. The information is front-loaded with the core action and use case before detailed parameter/return details. There is no fluff or 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 a rich input schema, output schema, and annotations, the description covers all necessary decision-making signals: when to use it, key constraints, what it returns, and important tax/rate context. It is sufficiently complete for the agent to invoke the tool correctly without missing critical context.

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 is good, but the description adds meaningful value by specifying constraints not fully in the schema: annual_investment is capped at ₹1,50,000, tenure_years should be one of 15/20/25/30, and the default interest rate is explicitly tied to FY2025-26. This goes beyond the schema descriptions and provides practical limits.

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 PPF maturity amount with year-by-year breakdown.' This clearly identifies what the tool does and differentiates it by the maturation product and the breakdown style, distinguishing it from sibling calculators like FD or RD maturity.

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 explicit use contexts: 'when planning long-term savings, comparing investment options, or calculating retirement corpus.' It does not explicitly say when NOT to use this tool or mention sibling alternatives, but the stated scenarios are clear enough for an agent to select this tool confidently.

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 and idempotentHint, so the description doesn't need to discuss destructive side effects. The description adds a basic return summary ('Presumptive income and total tax payable') but no deeper behavioral context such as calculation assumptions or edge-case handling; a neutral 3 is appropriate.

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

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

The description is fairly concise and front-loads the core purpose before listing parameters. The Args block duplicates schema information, which is slightly redundant, but it is still readable and focused, earning it a 4 rather than a 5.

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 6 parameters, 100% schema coverage, a rich annotation profile, and an output schema, the description is adequately complete. It conveys the main use case, the two schemes, and the expected return. It could add more nuance about how digital_receipt_percent or regime affects the calculation, but it is not incomplete enough to prevent correct tool invocation.

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

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

The schema description coverage is 100%, so the baseline is 3. The narrative Args block mostly restates the schema's parameter descriptions without adding meaningful new semantics about how the parameters affect the calculation. It provides no extra insight 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 clearly states the verb 'calculate' and the resource: tax under the presumptive scheme, with explicit sections (44AD, 44ADA). This separates it from sibling tax calculators like calculate_income_tax or calculate_professional_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?

Explicit guidance is given: 'Use when computing tax for small businesses or professionals under presumptive taxation.' It does not explicitly name alternatives or when-not-to-use, so it is not a perfect 5, but the usage context is clear enough for an agent to select this tool appropriately.

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 and idempotentHint, so the safety profile is covered. The description adds that the tool is state-wise and returns both monthly and annual amounts, which is useful but does not go much beyond the schema. No contradictions.

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 compact, front-loaded with the main purpose, and has a short usage line plus essential args and returns. No unnecessary filler or redundant detail beyond a reasonable reminder of the two key arguments.

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 calculation with two fully documented parameters, output schema present, and annotations covering read-only/idempotent behavior, the description is complete enough for an agent to select and invoke the tool correctly without further clarification.

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 both parameters are already described with units and examples. The description repeats the parameter names without adding substantive semantic detail beyond what the schema provides, so a baseline score 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 opens with a specific verb and resource: 'Calculate state-wise professional tax.' This clearly identifies the tool's unique function among many sibling tax calculators like calculate_income_tax and calculate_tds, and the subject is not confused with any other calculation.

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

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

It explicitly states when to use the tool: 'Use when computing total tax liability including professional tax deductions.' This gives a clear trigger context, though it does not mention alternatives or exclusions; still, it is sufficient to guide an agent toward this 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 indicate read-only behavior and idempotency. The description adds the return value detail ('Maturity amount with total interest earned'), which is helpful but doesn't disclose calculation assumptions or edge cases. This is adequate but not rich behavioral context.

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 concise and well-structured, with a brief action line, a usage note, a parameter list, and a return note. Each section earn its place, and the flow makes it easy for an agent to quickly extract key usage criteria.

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 essential information for invoking the tool: what it does, when to use it, the required parameters, and what it returns. Since the output schema is noted as present, the return-value explanation may be redundant, but the description remains complete for a straightforward calculation tool.

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

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

Schema description coverage is 100%, with each parameter already documented meaningfully in the input schema. The description repeats those parameter descriptions without adding extra context or edge-case information that the schema lacks, so the baseline score 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 uses a specific verb 'Calculate' with a clear resource ('Recurring Deposit maturity amount'), immediately identifying the tool's function. This clearly distinguishes it from siblings like calculate_fd_maturity or calculate_sip_returns without needing to inspect schema details.

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 includes 'Use when projecting RD returns or planning recurring deposits,' which provides a clear usage context. However, it does not explicitly mention alternative tools for similar calculations (e.g., FD or SIP), so it stops short of giving when-not-to-use 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 convey readOnlyHint=true and idempotentHint=true, so the safe, non-mutating nature is covered. The description adds that it returns a standard envelope with tax-optimized structure and deductions, but it does not disclose much behavior beyond what the annotations and output schema already provide. 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 front-loaded with the purpose and usage context, then organized into Args and Returns sections. It is reasonably sized for nine parameters, though the Args list duplicates parameter details already present in the schema.

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

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

Given the rich input schema, annotations, and output schema, the description supplies the missing context: when to use the tool and what the result conceptually contains. All parameters are present and defaults/constraints are handled by the schema, so the description is complete for its scope.

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 input schema already documents every parameter. The description's Args section largely repeats the schema's text and adds no new constraints, formats, or usage semantics 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 clearly states a specific verb and resource: it calculates salary restructuring options for tax optimization. It is readily distinguishable from sibling calculators like calculate_income_tax or calculate_hra_exemption because it targets the overall salary structure and CTC planning, not a single tax computation.

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 explicit use context: 'Use when advising employees on tax-efficient salary structures, comparing restructuring options, or planning CTC optimization.' It does not explicitly list when not to use it or name an alternative sibling tool, but the context is clear enough for an agent to select it.

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

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

The annotations already cover readOnlyHint and isOpenWorldHint, indicating the tool is a safe, deterministic calculation. The description adds that the return is a corpus with wealth gained and inflation-adjusted value, which provides some context, but the description mostly states the mapping rather than exposing new behavioral content like calculation assumptions or response shape. No annotation contradiction.

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 short clear purpose, a usage signal, a preliminary contract, and a return summary. The Args and Returns blocks are slightly redundant with the schema and output schema, but the overall length is appropriate and easy 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?

Given this is a deterministic calculation tool with a readOnlyHint, idempotentHint, a complete input schema, and a known output schema, the description is adequate for an agent to select and invoke it correctly. It identifies the domain, lists the core parameters, and indicates what kind of result the caller should expect.

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 input JSON schema fully documents monthly_investment, expected_annual_return, tenure_years, and inflation_rate. The description repeats these parameters but adds little meaningful semantics beyond naming them, and does not clarify edge cases such as sign, currency, or validation beyond the schema's existing 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?

The description clearly states the tool's purpose: calculating SIP maturity with inflation-adjusted returns, with a specific mention of mutual fund SIP and systematic investment planning. However, within a large family of investment calculators, it does not explicitly differentiate itself from siblings like calculate_step_up_sip or calculate_ppf_maturity, though the focus on SIP and inflation-adjustment gives reasonable 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 explicitly says when to use the tool: when projecting mutual fund SIP returns or planning systematic investments. It provides a clear usage context but does not state when it should not be used or which sibling alternatives might be more appropriate for step-up SIP, PPF, FD, or RD calculations.

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 and idempotentHint, so no side-effect warning is needed. The description adds some output context ('Corpus comparison between step-up and flat SIP') but does not disclose computation assumptions such as timing of annual increments or whether returns are pre-tax; this is plausible but not fully transparent.

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 compact and front-loaded with the core purpose followed by a use-case and expected return. The Args list is slightly redundant with the input schema, but it keeps the description self-contained and readable.

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

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

The tool is simple, fully annotated, has a complete input schema, and has an output schema signal. The description covers the scenario, arguments, and what is returned, so an agent has enough context to select and invoke it correctly.

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

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

All four parameters have complete schema descriptions, so the baseline is 3. The Args section mostly mirrors the schema descriptions without adding units, constraints, or examples, so the description does not meaningfully increase semantic richness 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 a specific verb and resource: 'Calculate SIP with annual step-up increment.' It also clarifies the comparison use case ('step-up SIP vs flat SIP'), which distinguishes it from plain SIP calculators like calculate_sip_returns.

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: 'Use when comparing step-up SIP vs flat SIP or planning salary-linked investments.' However, it does not explicitly name an alternative or state when not to use it, so it misses the exclusion-level guidance needed for a top score.

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

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

Annotations already establish that this is read-only and idempotent. The description adds useful behavioral context by stating the output includes 'interest breakdown and tax status,' which helps the agent understand what the calculation returns. 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 compact, front-loaded with purpose, and organized into clear usage, args, and returns sections. The Args block is somewhat redundant with the schema, but it does not make the description bloated or hard to use.

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 complete parameter documentation, an output schema, and annotations covering read-only and idempotent behavior, the description includes enough contextual guidance for an agent to select and call the tool correctly. Nothing material left missing.

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

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

Schema description coverage is 100%, so the parameter baseline is 3. The Args section in the description largely repeats the schema's parameter descriptions, adding no significant new meaning beyond what is already available.

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 starts with a specific verb and resource: 'Calculate SSY or SCSS maturity amount.' This clearly distinguishes the tool from sibling calculators like calculate_ppf_maturity, calculate_fd_maturity, and calculate_sip_returns by naming the exact schemes it handles.

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 explicit usage context: 'Use when planning long-term savings for girl child (SSY) or retirement (SCSS).' This is clear guidance on when to invoke the tool, though it does not explicitly name alternatives or list when-not-to-use conditions.

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 specify readOnlyHint=true and idempotentHint=true, so the description does not need to repeat that this is non-mutating. It goes beyond annotations by adding relevant rate context: FY2025-26 rates, new regime cap of 25%, and the old regime up to 37%. It also describes the return envelope (surcharge rate, before/after marginal relief, cess base), which adds useful behavioral detail.

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 a short lead statement, usage guidance, an Args block, a Returns line, and a Notes line. Every part adds at least one distinct fact, and no words are wasted on filler. The most important purpose and usage guidance are 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?

Assuming an output schema is present, the description already explains when to use the tool, what inputs are, what the surcharge rates and caps are, and what kind of result is returned. There is no obvious missing context needed to correctly call this tool for an agent.

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

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

Input schema descriptions already cover all three parameters, so the baseline is 3. The description repeats the schema for total_income and base_tax but meaningfully extends the regime parameter by adding the new-regime bracket cap (25%) and the old-regime max (37%). This added combination context is useful for selecting the correct parameter value.

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

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

The description opens with a specific verb and resource: 'Calculate surcharge and marginal relief for a given income and base tax.' It then explicitly distinguishes itself from the full income tax tool by stating it is a standalone calculation. This differentiates it from the sibling calculate_income_tax without needing to open that tool's schema.

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

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

The description gives an explicit usage instruction: 'Use when computing surcharge as a standalone calculation, separate from the full income tax tool.' It even notes that the income tax tool uses this logic internally, which helps an agent choose this tool versus the full income tax alternative. This is direct context, not implied.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds valuable behavioral context: it is scoped to FY2025-26 rates, rates may vary due to DTAA or Form 15G/15H, and the result is a standard envelope with applicability, rate, amount, and net payment. This is not contradicted by 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 appropriately sized for a six-parameter calculation tool, with clearly separated Args, Returns, and Notes sections. It front-loads the core purpose and usage context. There is a stray trailing 'P' in the provided text, which slightly detracts from polish but does not meaningfully harm clarity.

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

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

Given six parameters, full schema coverage, read-only annotations, and an output schema, the description covers the key operational details: purpose, when to use it, parameter roles, and return shape. The main gap is that 'section' refers to 'supported sections' without enumerating them, but the schema's examples and the tool's nature make this acceptable.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters. The description mostly restates the same parameter meanings, though it adds small nuances like 'affects rate' for PAN and payee type and clarifies that aggregate_payments_ytd is prior payments 'to same payee' under the section. This is incremental but does not significantly compensate 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 TDS for a given section and payment amount,' which makes the tool's core function immediately unambiguous. It also clarifies the fiscal year (FY2025-26) and lists concrete payee/payment contexts, clearly distinguishing it from sibling calculation tools like calculate_income_tax or calculate_advance_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 description explicitly states when to use the tool: 'Use when computing withholding tax on contractor payments, professional fees, interest, rent, commissions, or purchase of goods.' It provides clear usage context, though it does not explicitly name alternatives or state when not to use it, so it falls short of a perfect 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?

Annotations already mark the tool as read-only and idempotent. The description adds useful behavioral context by stating that it returns an FI type description, typical fields, and MCP tool pairings. 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?

The description is compact and organized, with purpose, usage, argument, and return sections front-loaded. Minor redundancy exists between 'get MCP tool pairings' and the Returns line, but overall every sentence adds value.

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 single-parameter, read-only decode tool with an output schema and clear return description, the definition covers the necessary ground: what it does, when to use it, what input is expected, and what output to expect. No significant gaps remain for this simplicity level.

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 the fi_type field already documented as 'FI type code (e.g., DEPOSIT, MUTUAL_FUNDS)'. The description simply repeats this example, adding no new semantic depth 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 clearly identifies the tool as decoding an AA Financial Information type, with a concrete outcome: getting MCP tool pairings. This distinguishes it from sibling decode tools like decode_pan_type and decode_state_code.

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 'Use when mapping FI types to validation/calculation tools' gives explicit context for when to call this tool. It does not explicitly mention when not to use it or compare against alternatives, but the usage context is clear enough for a simple decode operation.

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 an open-world hint, so the safety profile is established. The description adds that the tool does not simply decode the URI but also maps it to a validator, clarifying the expected conversion behavior beyond what the annotations alone 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 a single concise sentence that clearly conveys the main purpose and behavior. The appended '# PermissionTier: READ_ONLY' is redundant with the annotations but does not meaningfully bloat the description, and the key information 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?

Given only one parameter, existing annotations, and an output schema, the description is nearly complete. It does not elaborate on how the 'map to validator' result should be used or how it relates to sibling validate_* tools, but the presence of an output schema reduces the need for the description to enumerate return values.

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

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

There is only one parameter, and the schema description covers it completely ('DigiLocker document URI'), so the schema already documents the needed meaning. The description adds no extra information about format, URI structure, examples, or constraints, so a baseline score 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 the specific action ('Decode') on a specific resource ('DigiLocker document URI') and adds that it maps the URI to a validator. This clearly identifies the tool's role and distinguishes it from other decode_* siblings, though it could be slightly more explicit about the final output.

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

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

The description implies a usage context: a DigiLocker URI should be decoded and then routed to a validator. However, it does not explicitly say when to prefer this tool over the many validate_* or other decode_* siblings, and it gives no exclusions or comparative 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 as read-only and idempotent, and the description adds meaningful behavioral context: it performs a Luhn check and returns country, NSIN, security type, and Luhn validation. It does not describe behavior on invalid or malformed ISINs, but for a simple read-only decoder this is a minor gap.

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

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

The description is compact and well-structured with a summary line, a usage line, an args section, and a returns section. There is no filler, and the most important information 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 single-parameter read-only tool with an output schema, the description provides all necessary selection and invocation information. It names the scope, the key validation behavior, and the returned fields, making it 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?

The input schema already documents the single 'isin' parameter fully with a 100% schema description coverage and an example. The description only restates '12-character ISIN' without adding new semantics, so the schema carries the explanatory burden.

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 operation with a specific verb ('Decode ISIN') and expands the abbreviation to International Securities Identification Number. It adds 'with Luhn check,' making the purpose distinct from other validation and decoding tools for PAN, GSTIN, state codes, and Aadhaar. The tool is easy to tell apart from siblings without opening the schema.

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

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

The description explicitly says to use it when validating ISINs, specifically for Indian securities. It gives a clear usage context but does not explicitly name alternatives or state when not to use the tool, so a small amount of inference about sibling decoders/validators remains.

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 the description's 'README_ONLY' permission tag aligns. The description adds meaningful behavioral detail by revealing that the operation depends on the 4th character of the PAN, which is not visible in the schema.

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

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

The description is a single, focused sentence with no wasted words. The permission comment is redundant with annotations but does not significantly harm conciseness.

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

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

For a simple one-parameter read-only decoding tool with a complete schema, output schema, and annotations, the description is sufficient. An agent knows what it does, what input to provide, and has the output schema for the result.

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

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

Schema coverage is 100% and the schema says '10-character PAN'. The description adds semantic value by stating the 4th character is the relevant part, giving an agent insight into how the pan parameter is interpreted.

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 ('decode') and identifies the exact resource and logic: 'PAN entity type from 4th character'. This makes the tool's purpose immediately clear and distinguishes it from sibling tools like validate_pan or decode_state_code.

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 this tool is for decoding entity type rather than validation, but it does not explicitly state when to prefer this over sibling tools like validate_pan or bulk_validate_pan. Usage context is inferable from the tool name and sibling list, but no direct guidance or exclusions are provided.

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

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

Annotations already declare readOnlyHint and idempotentHint, so safety is covered. The description adds behavioral details beyond annotations: it can accept either a two-digit code or a full GSTIN with prefix, and it returns a standard envelope containing metadata. This is useful context without contradicting 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 compact and front-loaded. The main purpose appears in the first sentence, with a usage hint, argument example, and return note in brief structured sections. Every sentence contributes information without unnecessary 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 single-parameter, read-only tool with an output schema and safe idempotent annotations, the description covers the input formats, what data comes back, and when to use it. The output schema handles the return structure, so describing the envelope as 'standard' is sufficient.

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

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

The schema already covers the parameter with a description of '2-digit state code or GSTIN' and length constraints. The description adds concrete examples ('27' and '27AAPFU0939F1ZV') and clarifies that GSTIN prefixes are accepted, enriching the semantic understanding of the value parameter beyond the raw 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 uses a specific verb 'Decode' with a precise resource: Indian GST state code metadata, and specifies the two accepted input forms (two-digit code or GSTIN prefix). It clearly distinguishes itself from siblings like validate_gstin and decode_pan_type by stating it returns canonical state name, abbreviation, capital, and GST zone.

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

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

It explicitly states when to use the tool: 'Use when you need canonical state name, abbreviation, capital, and GST zone mapping.' However, it does not explicitly mention alternatives or exclusions, such as choosing validate_gstin for validation instead of decoding.

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 the tool read-only and idempotent. The description adds useful behavioral context beyond that: results are 'deadlines grouped by month' and the coverage spans ITR, TDS, GST, PF/ESIC, ROC, advance tax, and professional tax. This goes beyond the structured hints 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 compact and scannable, with a front-loaded summary followed by short Args, Returns, and Notes sections. Every line contributes information: scope, use cases, parameters, return format, and covered compliance types.

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

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

Given an output schema exists, the description does not need to detail return fields. It clearly communicates the fiscal year, optional filters, return shape ('standard envelope with deadlines grouped by month'), and regulatory coverage. This is sufficient for an agent to select and call 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?

Input schema descriptions cover 100% of parameters, so the description is not required to carry the full burden. The Args section largely repeats the schema, including category examples and YYYY-MM-DD date formats, without adding deeper semantics such as allowed category enumeration or date boundary behavior. 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 clear verb-resource pair: 'Get India's tax & regulatory compliance calendar for FY2025-26.' It names the exact domain, fiscal year, and deliverable, distinguishing it from the sibling tools, which are mostly validators and calculators rather than calendar/deadline queries.

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 context for when to use the tool: 'planning tax compliance schedules, setting reminders for deadlines, or building financial compliance dashboards.' It does not name alternatives or exclusion criteria, but no sibling offers comparable deadline-calendar functionality, so clear context is sufficient.

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

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

Annotations already cover read-only, idempotent, and open-world behavior, so the description's job is lighter. It adds useful context about data granularity (end-of-day) and market (India), but does not disclose rate limits, result size, or other edge 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?

The description is a single clear, front-loaded sentence with no filler. It communicates the essential scope and resource type efficiently.

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

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

The tool is simple, read-only, and has a full input schema and output schema. The description adds the only missing contextual detail: that this is historical end-of-day data for Indian tickers. No critical information is absent.

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

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

Schema description coverage is 100%, with both symbol and period already explained. The description adds no parameter-specific semantics beyond what the schema provides, so the baseline score 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 clearly states what the tool does: fetch historical end-of-day data for an Indian stock ticker. This is specific enough to distinguish it from the sibling get_stock_quote, which is about current quote data.

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 'historical end-of-day data' gives clear context for when to use the tool, especially relative to get_stock_quote. However, it does not explicitly name alternatives or state when not to use this 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 establish that the call is read-only, idempotent, and open-world, so the bar is lower. The description adds a meaningful behavioral detail: the price is delayed rather than real-time. This informs agent expectations beyond the structured hints.

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 immediately states the action, the object, the delivery latency, and the market scope. There is no filler, and every phrase 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?

Given the simple single-parameter schema with complete explanation, existing output schema, and annotations covering safety/idempotency, this description is fully sufficient for an agent to correctly select and invoke the 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 input schema already covers 100% of the single parameter with a clear description and examples like RELIANCE.NS, INFY.NS, TCS.BO. The tool description does not add extra parameter-level meaning beyond what the schema already provides, 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 uses a specific verb ('Fetch') with a clear resource ('current (delayed) price and summary for a given Indian stock ticker'). It clearly distinguishes itself from sibling get_stock_history by emphasizing current/delayed quote retrieval.

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 'current (delayed)' clearly signals this tool is for current quote lookups, not historical analysis, which is enough context given the sibling get_stock_history. However, it does not explicitly say 'use this for current prices and get_stock_history for historical trends.'

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

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

Annotations already cover the read-only, idempotent, and bounded-result behaviors, so the description only needs to add context. It adds the data source 'RBI master list' and echoes 'READ_ONLY' via PermissionTier, giving minor useful context beyond 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 one clear sentence plus a permission tag. Every part contributes either to what the tool does or which access tier it belongs to, with 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 simple one-parameter lookup tool, the description plus annotations and schema cover the necessary context: the operation, the data source, safety traits, and the accepted input. The output schema exists, so return-value explanation is unnecessary.

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

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

Schema description coverage is 100%, and the parameter description already defines 'Bank name or IFSC code prefix'. The tool description does not need to add parameter-level detail; it only confirms the lookup scope. This meets the baseline but does not go beyond it.

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 verb 'look up' and the resource 'bank details from RBI master list', so an agent knows exactly what entity the tool queries. It does not explicitly call out the closely related sibling lookup_ifsc, but the RBI master-list wording differentiates it from generic IFSC validation enough.

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

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

The description gives a clear context: bank details come from the RBI master list, implying this is the authoritative source for bank identification. It does not explicitly state exclusions or mention lookup_ifsc as an alternative, 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 annotations already signal read-only and idempotent behavior. The description adds meaningful context by noting the data is bundled offline, so agents know it is not a real-time directory, and by describing the return as a standard envelope with matching billers and parameter schemas.

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 with purpose, usage, args, returns, and notes sections, and the most important caveat is placed last in Notes. The Args section somewhat duplicates the schema descriptions, but the overall length is still reasonable and front-loaded with the tool 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 read-only, idempotent lookup tool with 0 required parameters and an output schema, the description provides enough guidance for an agent to invoke it correctly. It covers the use case, filtering options, result shape, and the critical offline-data limitation.

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 with 100% coverage. The description mostly restates the same semantics, such as filtering by category, using 'all' for state, and direct lookup by biller_id. This provides minimal additional meaning beyond the schema.

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

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

The description clearly states a specific action and resource: look up BBPS biller details. The list of supported payment categories further clarifies what the tool covers, distinguishing it from sibling validator and calculator 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?

It explicitly says to use this when setting up bill payments for utilities, DTH, broadband, FASTag, insurance, or mobile recharges. It also warns that the data is bundled offline and directs users to NPCI BBPS for real-time directory lookup, but it does not compare directly with sibling tools like lookups for IFSC, bank, pincode, or HSN.

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

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

The annotations already mark the tool read-only and idempotent, and the description adds useful behavioral context: it returns a standard envelope with exact matches or top 5 keyword matches, uses static master data, and notes GST applicability can vary. It leaves the exact envelope shape undefined, but an output schema is present.

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 compact, front-loaded with the main operation, and organized into Args, Returns, and Notes. Every sentence adds useful information, and there is 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?

For a read-only lookup tool, the description covers the triggering use case, both parameters, return behavior, and an important GST caveat. The only real gap is that both parameters are optional and the description does not state what happens when both or neither are provided.

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 description maps the two parameters to exact-code lookup and keyword search, and it adds concrete details such as valid code lengths and the top-5 match behavior. This goes beyond the schema, which only says 'HSN/SAC code (2-8 digits)' and 'keyword for description search'.

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 a lookup for HSN/SAC codes by exact code or by description keyword. It names the resource and the operation, and the GST classification context distinguishes it from the many validation and calculation siblings.

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

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

'Use for GST classification workflows where users provide a code or only a product keyword' gives a clear, actionable condition for when to invoke the tool. It does not explicitly list alternative tools to avoid, but the context is clear enough to route an 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?

This is an annotation contradiction: the description says the tool 'attempts live lookup at ifsc.razorpay.com with 3s timeout,' which is an open-world/external-network behavior, while annotations declare openWorldHint=false. The description helpfully discloses the fallback, but the metadata is internally inconsistent, so the behavioral signal is unreliable.

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 with a one-line purpose, a usage context, Args, Returns, and Notes. No sentence is wasted, though the Args section partially restates schema information. Overall it is compact and 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?

For a single-parameter lookup tool, the description covers the key agent-relevant details: when to use it, normalized input handling, return envelope, fallback behavior, and timeout. It is only pulled back from a 5 by the contradictory open-world annotation and the lack of explicit routing guidance to bulk or alternative lookup siblings.

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

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

The schema already documents the parameter with example and length constraints, so schema coverage is 100%. The description adds meaningful behavior beyond the schema by stating that input is case-insensitive and that whitespace is trimmed, which is useful for validating user-supplied IFSC codes.

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

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

The description names a specific verb and resource: look up an Indian IFSC code, with a clear distinction from validate-only tools by offering bank branch details. It also signals the bundled dataset plus live fallback, so an agent can distinguish it from bulk/validation sibling tools without opening the schema.

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

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

It clearly states when to use the tool: 'when you need bank branch details from an IFSC code in invoices, onboarding forms, or payment validation workflows.' However, it does not explicitly say when not to use alternatives like bulk_validate_ifsc or lookup_bank, so exclusions are incomplete.

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=true, idempotentHint=true), the description adds meaningful behavioral details: input normalization of spaces/hyphens, the fact that one pincode may map to multiple post offices and all are returned, and the standard envelope with location hierarchy. This gives an agent clear expectations about behavior and edge cases.

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

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

The description is compact and well-organized with a summary, use-cases, Args, Returns, and Notes sections. Every sentence earns its place with no redundancy or filler.

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

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

For a single-parameter read-only lookup with an output schema present, the definition covers the essential context: purpose, when to use, input formatting, output envelope shape, and cardinality notes. Nothing an agent needs to call it correctly is missing.

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

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

The schema already covers the parameter with 100% description coverage, providing the baseline of 3. The description adds value by detailing that spaces/hyphens are accepted and normalized and confirming the 6-digit format, which is useful semantic detail beyond the schema's simple '6-digit pincode'.

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: 'Look up India pincode details and return all post offices for that code.' This clearly differentiates it from sibling lookup tools such as lookup_ifsc, lookup_bank, and lookup_hsn_code, which target different identifiers.

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: 'Use for address normalization, district/state extraction, and GST state crosswalk use-cases.' It does not mention exclusions or alternatives, but the use-cases are specific enough to guide selection among the sibling tools.

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 and idempotent behavior, and the description does not contradict them. The description adds only limited behavioral context: that validation concerns 'structure and flags' and returns a validation result. It does not describe edge cases, error behavior, or what 'flags' means, but the output schema helps cover return-value expectations.

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 short, front-loaded with the core purpose, and structured into purpose, usage, args, and returns. There is some redundancy between the Args section and the schema, but the overall structure remains clean and easy 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?

For a single-parameter validation tool with an output schema and read-only/idempotent annotations, the description covers what is needed for selection and invocation. It states the input, the intended usage moment, and gives a return hint. It does not explain full validation criteria, but this is not essential for choosing the 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 already provides 100% coverage of the single artifact parameter. The description repeats 'Consent artifact JSON from AA response', adding only the minor extra context that it comes from an AA response. This is baseline value rather than substantial enhancement.

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

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

The description uses a specific verb and resource combination: 'Validate AA consent artifact structure and flags.' It clearly distinguishes this from sibling tools like build_aa_consent_request and decode_aa_fi_type. The additional context about verifying artifacts received from AA reinforces what the tool is for.

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 says 'Use when verifying consent artifacts received from AA before processing', giving a clear context for when this tool is appropriate. It does not explicitly mention when not to use it or name direct alternatives, so it falls 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?

Annotations already declare readOnlyHint, openWorldHint, and idempotentHint, and the description does not contradict these. It adds useful behavioral detail: spaces and hyphens are stripped, the validation is limited to format and Verhoeff checksum, and the return envelope includes validity, checksum result, formatted display, and first-digit check. The UIDAI caveat is especially helpful for avoiding expectations beyond the local validation.

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 short, front-loaded with the primary purpose, and organized into Purpose, Use-when, Args, Returns, and Notes. It includes the critical caveat about UIDAI without any filler, and every line contributes actionable information for an agent.

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 single-parameter validation tool with 100% schema coverage, output schema present, and read-only/idempotent annotations, the description is complete. It tells the agent what the tool validates, when to use it, how the input is normalized, what the return envelope contains, and the important limitation that it is not connected to UIDAI. Nothing needed to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so the schema already fully documents the parameter. The description's Args section mostly restates that aadhaar is a 12-digit number and that spaces and hyphens are allowed. It adds that spaces and hyphens are 'stripped' prior to validation, which is slight extra operational detail, but not a substantial semantic addition.

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 identifies the verb ('Validate') and resource ('an Indian Aadhaar number'), and the phrase 'Verhoeff checksum verification' makes its function specific. It also states that it is format/checksum-only and 'not connected to UIDAI', which distinguishes it from identity-lookup style tools. It does not explicitly contrast it with bulk_validate_aadhaar or other related sibling validators, but the purpose 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 gives an explicit usage context: 'Use when checking Aadhaar format and checksum in KYC, identity verification, or government benefit workflows.' It also provides a meaningful limitation with 'Not connected to UIDAI', which warns agents not to use it for live UIDAI verification. It stops short of naming alternatives such as bulk_validate_aadhaar, so it is not a perfect routing guide.

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

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

Annotations already establish the read-only and idempotent behavior, so the description adds useful behavioral detail: spaces and hyphens are stripped automatically, the output is a standard envelope, and there is no public checksum. This helps the agent set correct expectations without contradicting 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 compact, well-sectioned, and front-loaded with the core purpose. Each section (Use when, Args, Returns, Notes) earns its place and provides practical information without filler.

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

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

For a single-parameter, read-only tool with an output schema, this description covers the input contract, normalization behavior, output structure, and a key validation limitation. Nothing essential appears to be missing for a successful invocation.

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

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

The schema already documents the cin parameter fully, but the description adds the operational note that spaces/hyphens are automatically stripped and reinforces the canonical 21-character format. That goes beyond the schema's 'spaces/hyphens allowed' wording and clarifies input normalization.

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: 'Validate and decode an Indian CIN.' It also lists concrete outputs such as listing status, NIC code, state, year, company type, and serial number, which makes the tool's purpose easy to distinguish from sibling validators like validate_pan or validate_din.

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 explicit trigger conditions: use when verifying company registration data or extracting structured fields from a CIN. It doesn't name alternatives or state when not to use this tool, but the context is clear enough for an agent to route correctly.

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

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

Annotations already mark the tool as read-only and idempotent. The description adds valuable behavior beyond annotations: shorter inputs are zero-padded, spaces are stripped, and only format validation is performed, not director status verification. 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?

The description is compact and front-loaded with the core action and use case. The Args block is somewhat redundant with the schema, but every sentence still carries useful information and the total length is appropriate.

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?

This is a simple single-parameter validation tool with an output schema, so no hidden behavior remains. The description fully covers what is validated, input normalization, read-only nature, and the explicitly excluded status verification.

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 has 100% coverage for the single parameter, which is the baseline. The description adds extra meaning by specifying that the 8-digit value is numeric, shorter values are zero-padded, and spaces are stripped—details absent from the schema.

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

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

States a specific verb plus resource: 'Validate an Indian DIN (Director Identification Number) format'. This distinguishes it from sibling tools like validate_cin, validate_pan, or validate_aadhaar, and ties it to MCA compliance.

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 says when to use: 'Use when verifying director identity numbers in MCA compliance workflows.' It also clearly states a limitation ('Format validation only. Cannot verify director status with MCA'), but does not name an alternative tool for the more comprehensive verification.

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?

Given the annotations already declare readOnlyHint and idempotentHint, the description adds meaningful behavioral details: it states the tool is format-validation-only and that non-standard pre-Sarathi formats are handled gracefully. It also discloses auto-stripping of hyphens/spaces. These are not redundant 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 logically organized into Args/Returns/Notes, and is not overly long. The Args section is slightly redundant with the schema, but each other part earns its place. Minor redundancy is not enough to warrant a stronger penalty.

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 complete output schema and useful annotations, the description still contributes important context: what the tool does not do (format validation only), and graceful handling of old formats. This places it above the threshold for a simple tool description, though it could add edge-case behavior or explicit error handling notes.

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

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

The schema already covers the parameter fully (description, type, min/max). The description's Args section adds little semantic value, only repeating the field. However, it does clarify that hyphens/spaces are stripped automatically, which is a small extension beyond the schema text. Baseline of 3 is appropriate overall.

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 ('Validate') and a clear resource ('Indian driving license number') and explicitly says it decodes segments. The scope is narrowed with examples (state/RTO/year), and it is easily distinguished from sibling validators like validate_aadhaar or decode_state_code. The sentence is specific and usable.

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 'Use when' line provides concrete usage context ('verifying DL format, extracting state/RTO/year in KYC workflows') which is above-average guidance. However, it does not explicitly name sibling tools that should be used instead in related cases (e.g., decode_state_code), so it lacks full alternative exclusions.

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 adds no real behavioral context beyond the 'PermissionTier: READ_ONLY' comment, which simply restates the readOnlyHint annotation. It does not disclose whether validation checks format, existence, registration status, or whether it makes network requests, leaving the agent uninformed about practical 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 main description is a single, front-loaded sentence: 'Validate EPF establishment code.' This is concise and does not waste words. The PermissionTier tag is redundant with annotations, but the overall length is appropriate and the key purpose appears first.

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 one parameter, read-only and idempotent annotations, and an output schema, the essential calling contract is covered. However, the description does not clarify what 'validate' means beyond the format hint in the schema—specifically, whether it checks only format or also verifies the code against an authoritative source—so an agent might make incorrect assumptions about the result.

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

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

The input schema already provides the full description for the only parameter, including the expected format (XX/XXXXX/XXXXXX/XXX). The tool description itself adds no extra parameter semantics, so an agent relies entirely on the schema to understand the argument.

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