SecureLend Market

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

The description reinforces the existing annotations by stating it does not access external data or create/modify/delete records. It adds the 'pure calculation' framing and loan type scope, but no additional behavioral details like precision, rounding, or authentication requirements, so it adds only modest value beyond 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 in the first sentence. The second sentence adds important context about side-effects and scope without unnecessary detail. Every sentence earns its place and there is no fluff.

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 is complete for a pure calculation tool: it states the purpose, applicable loan types, and the absence of side effects or external data access. The output schema covers return values. However, it does not explicitly exclude mortgages despite a dedicated sibling tool, and it does not clarify the standard amortization model, leaving minor ambiguity.

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 has 100% description coverage for all three parameters, which already define units and constraints. The tool description rephrases them as 'principal, interest rate, and term' but adds no extra semantic detail beyond what the schema provides, so it meets 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 clearly states the verb 'calculates' and resource 'installment loan', and lists concrete outputs (monthly payment, total interest, total cost). It scopes to user-supplied principal, interest rate, and term, differentiating from sibling comparison tools by emphasizing it is a pure 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?

The description states it performs a pure calculation without external data, implying when to use it versus comparison tools. It lists applicable loan types, providing clear context. However, it does not explicitly reference alternatives like calculate_mortgage_payment 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?

Annotations already set readOnlyHint=true and destructiveHint=false, so the description's 'Pure calculation using user inputs — no external data is accessed' adds valuable context about side effects and data privacy. It does not contradict annotations and reinforces the safe, self-contained nature of the operation.

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 only two sentences: the first front-loads the purpose and scope, the second adds a clear behavioral note. It is concise, free of fluff, and every sentence earns its place.

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

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

For a 6-parameter tool with an output schema available, the description provides sufficient context: what it calculates, the inputs, and the pure-calculation nature. The 'optional' inaccuracy is a minor gap, but the description overall is complete enough for an agent to know when and how to 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?

Although the schema provides 100% description coverage with units and examples, the description calls tax/insurance figures 'optional' while the schema marks propertyTaxRate and homeInsurance as required. This contradicts the schema and adds no helpful semantic beyond what the schema already provides, so it is misleading.

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 'Calculates' and names the exact resource 'full PITI mortgage payment', enumerating the input components. This distinguishes it from sibling 'calculate_loan_payment' by explicitly including taxes and insurance, making the purpose 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 implies use when a user supplies property value, down payment, interest rate, term, and tax/insurance figures for a mortgage payment estimate. It notes 'Pure calculation using user inputs — no external data is accessed', giving useful context, but it does not explicitly name alternative tools 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?

Discloses that results may include partner data (aligning with openWorldHint), notes conditional availability of bonuses/APY, and explicitly states the tool does not open accounts, directing users to provider website. Adds behavioral boundaries beyond annotations.

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

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

Three sentences with clear structure: action, return info, boundary. No filler or redundant text.

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?

Covers filtering parameters, result contents, partner data caveat, and post-search action. With output schema present and simple parameter set, description is sufficiently comprehensive.

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 already describes both parameters fully (industry, monthlyTransactions). Description only restates them as optional criteria, adding no semantic detail beyond 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?

Uses specific verb 'Search' with resource 'business banking accounts', clearly distinguishing from sibling tools like compare_business_loans. Explicitly states it does not open an account, reinforcing its read-only search purpose.

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

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

Implicitly indicates usage for comparing business banking accounts by stating matching criteria, but lacks explicit alternatives or exclusions. Satisfies clear context without explicit '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 indicate read-only and non-destructive behavior; the description adds useful context that results may include partner integrations and that applications are directed to the issuer's website. This goes beyond what annotations alone convey.

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

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

Three tightly written sentences with no filler: the first states scope and criteria, the second details return information, and the third clarifies non-application behavior. Every sentence earns its place.

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

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

With an output schema present, return values need no explanation. The description covers search scope, optional filters, data sources, and next steps, making it complete for a search 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 covers all three parameters with full descriptions (ranges, units, meaning). The description only restates them as optional criteria, adding no additional semantic detail beyond the schema.

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

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

Description clearly states it searches SecureLend's product database for business credit cards, using a specific verb and resource. It distinguishes itself from siblings like compare_personal_credit_cards and compare_business_loans by scoping to business credit cards only.

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

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

The description implies use when the user wants to compare business credit cards and explicitly notes that it does not submit applications. However, it does not name sibling tools as alternatives, so guidance is clear but not fully explicit.

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

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

Beyond the annotations (readOnly, openWorld), the description adds critical behavioral details: results may change over time, offers may come from third-party integrations, and the user is redirected to the lender's platform to complete the application. This meaningfully extends the annotations without 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 four sentences long, each adding distinct value: what it does, what it returns, result variability, and the next step. It is front-loaded with the core purpose and contains no fluff, making it 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?

Given the presence of an output schema and annotations, the description covers the essential context: search criteria, return contents, variability, and post-search workflow. It does not explain edge cases or error behavior, but that is not critical for this search tool. Overall, it is sufficiently complete.

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

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

While the schema descriptions fully cover each parameter, the description introduces a criterion 'time in business' that is not present in the schema, and omits the 'state' parameter. This inconsistency could mislead the agent about available parameters. The description adds no new semantic value beyond the schema and actively introduces confusion.

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

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

The description uses a specific verb ('Search') and clearly identifies the resource (SecureLend's lender database) and the scope (business loan offers matching user criteria). It distinguishes this from sibling tools that compare other product types like banking or credit cards.

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

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

The description clearly implies when to use this tool: when the user needs business loan offers. It provides context by listing the matching criteria and the outcome of the search. However, it does not explicitly name alternatives or state when not to use it, 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?

Beyond the annotations (readOnlyHint, openWorldHint), the description adds valuable behavioral details: results may change over time, may include third-party offers when enabled, and user completes application on the lender's platform. These explain the tool's dynamic nature and hand-off flow, which are not captured by annotations alone.

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 three sentences, front-loaded with the primary purpose, followed by brief behavioral notes. No unnecessary words, and every sentence contributes to agent understanding.

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 search action, expected outputs (rates, terms, eligibility), dynamic results, third-party source possibility, and the application flow. With the output schema and annotations already present, this is a complete picture for a compare tool. Missing minor details like required parameters are already in the schema.

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

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

The schema provides full coverage (100%) for all 7 parameters, including descriptions and constraints. The description only mentions 'matching the user's criteria,' which adds no specific parameter-level meaning. Since schema already documents parameters, 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 clearly states it searches SecureLend's lender database for commercial mortgage offers (purchase or refinance), with a specific verb ('search'), resource ('lender database'), and scope ('commercial mortgage'). It distinguishes from siblings like compare_personal_mortgages and compare_business_loans by mentioning the commercial mortgage focus and the lender database.

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 context is explicit: this tool is for commercial mortgage offers, purchase or refinance. However, it does not explicitly mention when not to use it or point to alternative tools (e.g., compare_personal_mortgages). The context is clear enough for an agent to infer usage, but lacks explicit 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 valuable context beyond the annotations, including that results may change over time, may include offers from SecureLend and authorized third-party integrations, and that users are directed to complete applications on the lender's platform. These details align with readOnlyHint and openWorldHint annotations and enhance transparency.

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 efficiently structured, with the purpose front-loaded and each sentence serving a distinct role. There is minor redundancy in referring to 'SecureLend's database' twice, but overall it avoids 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 schema and output schema, the description is complete enough for an agent to understand what the tool does, key caveats about data volatility, and the user flow after selection. It covers essential behavioral notes without needing to restate structured schema 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?

The schema provides 100% parameter coverage, so the description doesn't need to add much. It lists the criteria (loan amount, vehicle type, credit score, state) that map to the schema parameters but introduces no new parameter-level details beyond the existing 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 clearly states 'Search SecureLend's lender database for auto loan offers matching the user's criteria', using a specific verb and resource. It explicitly identifies the domain (auto loans) and distinguishes it from siblings like compare_personal_loans and compare_business_loans.

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

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

The description implies its use for comparing auto loan offers by naming the specific loan type and criteria. It does not explicitly exclude alternatives or name when-not-to-use cases, but the scope is clear from the description and sibling context.

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, but the description adds valuable context with 'Pure calculation using user inputs — no external data is accessed.' This reinforces the safety profile and goes beyond the annotation hints. No contradictions with annotations exist.

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

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

The description is two sentences, with the primary purpose front-loaded in the first sentence and the second sentence efficiently clarifying the pure-calculation nature. No extraneous words or redundant repetition of schema details.

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

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

Given 12 parameters and an output schema, the description does not need to explain return values. It effectively states the tool's scope and data handling, making the tool selectable and invocable. Minor gap: it does not mention alternative tool usage, but the unique purpose mitigates this.

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% (all 12 parameters have descriptions), so the bar is set at baseline 3. The description summarizes key parameter groups (price, down payment, terms, residual value) but does not add syntax or format details beyond the schema. It provides a helpful high-level context without compensating for any missing parameter info.

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 phrase 'Calculates and compares the total cost of leasing versus purchasing a vehicle,' which clearly identifies the tool's function and resource. It also distinguishes from sibling tools by focusing on the lease-vs-purchase decision, which is not covered by other compare_* 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 provides clear context: it applies to comparing lease vs purchase over the same time period and explicitly states it uses user-supplied inputs. While it does not name alternatives or exclusions, the tool's unique scope makes its usage context clear enough.

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 this as read-only, open-world, and non-destructive. The description adds useful behavioral context: results may change over time, may include third-party offers, and the tool ends by redirecting the user to the bank's own platform. This goes beyond the annotation signals 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?

Three focused sentences deliver purpose, result contents, dynamic behavior, and user flow with no filler. The first sentence front-loads the main action and resource.

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 parameter set (one optional array), output schema present, and strong annotations, the description is complete: it covers what is searched, what is returned, potential variability, and the follow-up action on the bank's site.

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

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

With 100% schema description coverage, the schema already documents the 'features' parameter. The description reinforces that features are used for matching and that returned accounts include features, but it does not add substantial syntax or formatting details beyond the schema.

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

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

The description opens with a specific action ('Search SecureLend's lender database') and clear resource ('personal banking accounts'), distinguishing it from sibling tools focused on credit cards, loans, or savings accounts. It also states the output includes fee structures, features, and eligibility indicators, which clarifies its function.

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 clear context that this tool is for comparing personal banking accounts based on desired features, and notes the subsequent redirect to the bank's platform. It does not explicitly name alternatives or exclusions, but the domain distinction from sibling compare tools is evident.

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=true, and destructiveHint=false. The description adds behavioral context beyond these annotations by stating that results may change over time and may include third-party offers when enabled, and that the application process happens on the issuer's own platform. This gives the agent useful expectations about volatility and workflow.

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 three sentences with no unnecessary words. The first sentence states the core action, the second describes outputs, and the third adds time/third-party context and the application flow. Every sentence contributes meaningful information.

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

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

Given the tool's low complexity (two simple optional parameters), full schema coverage, strong annotations, and an output schema, the description fully covers the tool's purpose, expected results, result variability, third-party involvement, and downstream user action. No critical information seems missing 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?

The input schema already provides full descriptions for both parameters (creditScore and rewardsType) with ranges and enum values, giving 100% schema coverage. The description merely names these criteria without adding additional syntax, constraints, or format details. Thus the description adds no significant semantic value 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 uses the specific verb 'Search' and clearly identifies the resource as 'SecureLend's lender database for personal credit card offers.' It specifies the matching criteria (credit score, preferred rewards type) and distinguishes itself from sibling tools by focusing on personal credit cards, not business cards or loans.

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

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

The description clearly implies when to use the tool: when a user needs personal credit card offers based on credit score and rewards preferences. It does not explicitly name alternatives or exclusions, but the context is unambiguous given the sibling tool names. It could be improved by explicitly directing users to business card tools for business needs.

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 openWorldHint=true, and the description adds that results 'may change over time' and may include third-party offers, reinforcing the open-world behavior. It also details the redirection to the lender's platform, which is a valuable behavioral trait beyond what annotations 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 three sentences: first states the core function, second summarizes outputs, third adds context and process flow. It is front-loaded with the action and contains no redundant or filler text.

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

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

With an output schema present and annotations covering safety, the description provides sufficient context about the search, return contents, and process flow. It does not explicitly differentiate from sibling tools like get_offer, but overall coverage is strong for an agent to invoke it correctly.

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

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

Schema coverage is 100%, so all parameter descriptions exist in the schema. The description mentions the criteria in passing but does not add new meaning or dependencies 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 opens with 'Search SecureLend's lender database for personal loan offers', using a specific verb and resource. It explicitly names the matching criteria (loan amount, purpose, credit score, state) and clearly distinguishes from sibling tools like compare_car_loans by focusing on personal loans.

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

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

The description implies usage for comparing personal loan offers and outlines the post-search flow (user selects lender, completes application on lender's platform). It does not explicitly mention alternatives or exclusions, but the context is sufficiently clear from the name and the described process.

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

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

Annotations already mark readOnly and openWorld; the description adds context that results may change over time, may come from third-party integrations, and that the user is redirected to the lender's platform for application. This goes beyond the structured hints and sets expectations for non-deterministic, externally sourced data.

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

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

Four sentences, front-loaded with action and scope, followed by returns, caveat, and next step. No redundant filler; all sentences contribute to understanding the tool.

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

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

Given output schema and full annotation coverage, the description covers purpose, return contents, variability, third-party sources, and post-search workflow. It could mention exclusions (e.g., unsupported states), but the existing schema and annotations make the description sufficiently complete.

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

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

Input schema has 100% description coverage for all 7 parameters. Description restates selected parameters (property value, loan amount, credit score, state, loan type) but doesn't add new semantics beyond the schema or explain relationships like how downPayment affects offers. 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 clearly identifies the tool as searching SecureLend's lender database for residential mortgage offers (purchase or refinance) and enumerates returned data (rates, terms, payments, closing costs). It distinguishes from siblings like compare_business_mortgages via 'residential' and 'personal' wording.

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

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

States when to use: when the user wants residential mortgage offers (purchase or refinance) and describes the follow-up workflow to the lender's platform. It does not explicitly name alternative tools for business mortgages or other loan types, but the 'residential' scope implies the boundary.

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 open-world, and the description adds valuable behavioral context beyond that: results may change over time, may include third-party offers when enabled, and the user is directed to the bank's platform to apply. This gives a fuller picture of what the tool does and what the user should expect.

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 three sentences with no filler. The first sentence states purpose, the second explains the result payload and dynamic nature, and the third describes the user handoff. Every sentence earns its place.

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

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

With a single optional parameter and an output schema present, the description covers the tool's scope, return values, dynamic behavior, third-party integrations, and the application flow. The only gap is the misleading APY mention, which prevents a perfect completeness score.

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 only parameter, initialDeposit, with a clear USD description. However, the description also mentions 'desired APY' as a matching criterion even though no APY parameter exists in the schema. This can mislead the agent into expecting a second input that isn't available, creating confusion rather than adding 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 action ('Search SecureLend's lender database') and clearly identifies the resource ('savings accounts') with matching criteria and return payload. This makes the tool's purpose obvious and distinguishes it from sibling comparison tools targeting other account types.

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

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

The description clearly states the exact use case: comparing savings accounts based on initial deposit and desired APY. Although it doesn't name alternative tools or exclusions, the context is specific enough for an agent to know when to select this tool among the many compare_* 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?

The description adds valuable behavioral context beyond the annotations: results may change over time, may include third-party integrations, and the user is redirected to the lender's own platform. This aligns with readOnlyHint=true and openWorldHint=true without 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 three sentences, each earning its place: purpose, return contents, and important caveats. It is front-loaded with the core action and remains concise with no fluff.

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 annotations cover safety, the description sufficiently explains the search flow, return contents, and post-search behavior. Minor gaps: it does not explicitly note optional parameters, but overall it is complete enough for an AI 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?

Schema description coverage is 100%, so the schema already documents all five parameters. The description adds little extra meaning and even mentions 'enrollment status,' which is not a parameter in the schema, creating a minor inconsistency.

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 searches SecureLend's lender database for student loan offers, using specific criteria (loan amount, degree type, credit score, enrollment status). It distinguishes itself from sibling tools like compare_personal_loans or compare_car_loans by explicitly focusing on student loans.

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

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

The description makes it clear that this tool is for comparing student loan offers, and the user is directed to complete the application on the lender's platform. It does not explicitly name alternatives or state exclusions, but the context is strong enough for an agent to infer when 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, which the description aligns with. It adds value by explaining the cache retrieval, pre-filling behavior, and the non-submission side effect, which goes beyond the annotations.

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

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

Two sentences, front-loaded with the core purpose and followed by a crucial caveat. No unnecessary 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?

With an output schema present and clear annotations, the description fully covers the tool's purpose, behavior, and limitations. It is complete for the tool's complexity.

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 describes both parameters with 100% coverage. The description reiterates the offerId/sessionId distinction but does not add significant new meaning 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 retrieves a cached offer and search inputs to display a pre-filled form, with an explicit note that it does not submit. This distinguishes it from sibling submit tools and other display tools like display_prequalification_form.

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

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

It provides clear context for when to use ('before confirming submission') and explicitly states what it does not do ('does not submit an enquiry'). However, it does not name alternative tools or provide explicit when-not-to-use guidance beyond the non-submission statement.

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 destructiveHint=false. The description adds the behavioral nuance that the tool 'only renders the form' and delegates data storage/forwarding to submit_prequalification_details. This goes beyond the annotations by explaining the tool's side-effect-free nature and its role in a larger workflow. 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 two sentences long, front-loads the purpose, and then clarifies behavior and the relationship to a sibling tool. There is no redundant information or fluff. Every sentence contributes 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?

Given that an output schema exists and the parameter schema already documents all parameters, the description adequately covers the tool's role, side-effect profile (with annotations), and the submit workflow. It is complete for an agent to understand when and how to invoke this form-display 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 has 100% description coverage for all four parameters, so the baseline is 3. The description itself does not add any parameter-level detail beyond what is in the schema; it only mentions 'prefill data' generically. Thus it neither elevates nor degrades the semantic clarity provided by 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 tool's function: 'Displays a form to collect application prefill data required to continue an enquiry.' It uses a specific verb ('displays') and resource ('form'), and distinguishes itself from sibling tools like display_offer_form and display_upload_documents_form by specifying 'prequalification' and the workflow with submit_prequalification_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 provides clear context: 'This tool only renders the form. When the user submits, the form calls submit_prequalification_details...' This tells the agent when to use this tool (to display the form) and hints at an alternative for submission. However, it does not explicitly state 'use this when X' or 'do not use this for Y', 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?

The description goes beyond annotations by detailing the widget's behavior: it calls submit_documents to create a record and obtain a presigned S3 upload config, then uploads directly from the browser. This clarifies side-effect flow and the S3 storage destination, adding value over the readOnlyHint and destructiveHint 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 two sentences long, front-loaded with the main purpose, and provides essential flow details without extraneous information. Every sentence contributes value, making it concise and well-structured.

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 presence of an output schema, one optional parameter, and comprehensive annotations, the description covers the tool's purpose and workflow sufficiently. It mentions the integration with submit_documents and S3, but could be slightly more explicit about when to invoke it in a user interaction, though this is a minor gap.

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

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

Schema description coverage is 100%, with the only parameter 'applicationId' already documented as 'Pre-fill the application ID for the document upload form.' The tool description adds no additional meaning to the parameter, so baseline 3 is appropriate.

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

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

The description clearly states the tool displays an upload form for supporting documents, and explains the subsequent submission flow. It distinguishes from sibling display forms (e.g., display_offer_form, display_prequalification_form) by specifying the document upload purpose, and differentiates from submit_documents by describing the widget behavior.

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 the use case: display an upload form for supporting documents. It mentions that submit_documents is called on submission, which hints at a division of labor, but it does not explicitly state when to use this tool versus alternatives or provide exclusion criteria. There is no direct naming of alternatives as a contrasting choice.

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 substantial behavioral context beyond annotations: requires explicit user confirmation, creates a persistent lead record, lenders review independently, and it doesn't collect sensitive data. This elaboration on side effects and data handling significantly enhances transparency beyond the raw readOnly/destructive 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 five sentences and front-loaded with the core action, but there is slight redundancy between 'records a loan enquiry' and 'creates a persistent lead record'. It is relatively concise but could be tightened without losing meaning.

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

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

Given the complex nested schema and output schema, the description covers the workflow, data collection boundaries, and user interaction flow. It doesn't mention error scenarios or response specifics, but the output schema fills that gap. Overall, it is complete for an agent to understand the tool's role.

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 with descriptions. The description adds little parameter-specific detail beyond mentioning 'multiple selected lenders', which aligns with the providers parameter. It doesn't clarify formats or relationships 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 'records' and 'submits' with the resource 'loan enquiry' and 'multiple selected lenders', making the tool's purpose obvious. It distinguishes itself from siblings like get_offer (singular) and compare_* tools by emphasizing the multi-lender submission workflow.

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

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

The description implies usage for multi-lender submissions after explicit user confirmation, but it doesn't explicitly state when-not-to-use or reference alternatives such as get_offer. This is implied usage rather than explicit guidance.

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

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

Annotations already indicate a write operation (readOnlyHint=false) and potential destructiveness (destructiveHint=true). The description adds valuable context beyond annotations: it requires explicit user confirmation, creates a persistent lead record, does not collect sensitive personal data, and explains the post-submission workflow. No contradictions with annotations.

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

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

The description is four sentences and front-loads the main action. It is mostly efficient, though the final sentence ('Creates a persistent lead record') partially overlaps with the first sentence ('Records a loan enquiry'). It earns its place by adding persistence and database context, so overall it is concise without being minimal.

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

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

Given the tool's complexity (multiple product types, nested applicationData variants) and the presence of an output schema, the description provides sufficient high-level context. It explains the workflow, user confirmation, and privacy stance. It does not detail return values, but the output schema covers that. The description could be slightly more explicit about when to prefer this over get_multiple_offers, but it remains fairly complete.

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

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

Schema description coverage is 100%, so the schema already thoroughly documents all parameters and nested properties. The description does not add parameter-specific details, but it clarifies the overall purpose and mentions that sensitive data is not collected, which indirectly helps interpret the applicationData content. Baseline 3 is appropriate given the schema's completeness.

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 records a loan enquiry and submits it to one selected lender on the user's behalf. It uses a specific verb with a resource (SecureLend's system, one lender) and distinguishes itself from siblings like get_multiple_offers by emphasizing 'one selected lender' and the post-submission flow.

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

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

The description provides clear context for when to use the tool: after explicit user confirmation, for submitting to a single selected lender. It implies alternatives through the phrase 'one selected lender' (contrasting with get_multiple_offers) and notes the user will later apply on the lender's platform. However, it does not explicitly list when-not-to-use alternatives.

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

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

The description adds meaningful behavioral context beyond the annotations: it reveals the tool generates a secure presigned URL and creates a persistent record, aligning with destructiveHint=true. It does not mention other side effects, but the core mutation is clearly disclosed.

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 main purpose but contains redundancy, repeating 'creates a persistent document record' and the upload-enabling concept. A tighter single or two-sentence version would be more effective.

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 tool's core behavior, usage trigger, and persistence aspect. Since an output schema exists, explaining return values is unnecessary. Minor redundancy does not harm completeness.

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

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

All three parameters are fully documented in the schema with names, types, and descriptions (100% coverage). The description itself does not add parameter-level detail, 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 clearly identifies the tool's function: generating a secure presigned URL, recording metadata, and creating a persistent document record. It distinguishes from siblings like display_upload_documents_form by specifying the post-selection upload action.

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 it is called by the document upload widget after the user selects a file, providing clear context. It does not name alternatives or exclusions, but the trigger condition is well-defined.

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 include destructiveHint=true, but the description does not explain any destructive or side-effectful behavior beyond 'submits' and 'forwards'. It adds useful context about not collecting sensitive data or underwriting, and emphasizes consent, but the destructive annotation is not addressed. Since no contradiction exists, a score of 3 reflects the added context without full transparency.

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 four sentences and around 80 words. It front-loads the main purpose, includes an IMPORTANT condition, and adds scope clarification. While slightly repetitive with 'prequalification', every sentence contributes useful information, making it reasonably 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?

Given the tool's complexity (17 top-level params, deep nesting, large schema), the description covers key preconditions and limitations but omits important operational details such as idempotency, what happens on repeated calls, or the implications of destructiveHint. An output schema exists, so return values need not be described, but the overall context remains incomplete.

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 only 29%, so the description must compensate. It only vaguely references categories like 'general financial profile, employment status, and business structure' and highlights the two consent parameters. It does not provide meaningful semantics for the many nested parameters (e.g., loanInformation, businessInformation), leaving a significant gap.

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

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

The description clearly identifies the verb ('submits'), resource ('application prefill information for an existing enquiry'), and destination ('SecureLend's backend... selected lender API(s)'). It distinguishes this tool from siblings like display_prequalification_form and submit_documents by specifying 'prefill information' and 'existing enquiry'.

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

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

The description states a clear precondition (consentsToFcra and consentsToTcpa must be true) and implies usage context ('existing enquiry'). It explains the scope ('referral purposes only') and what happens next, but does not explicitly name alternative tools or exclusions, giving it a solid but not fully explicit guideline.

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 declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable context by noting that the status 'reflects what SecureLend has recorded' and 'is not guaranteed to represent real-time lender decisions.' This is a significant behavioral caveat that informs the agent about data freshness, which the annotations do not convey. It goes beyond the minimum annotation coverage, earning a 4.

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

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

The description is two sentences, about 30 words, and immediately states the main function. The first sentence front-loads the verb and resource, while the second adds a necessary caveat. There is no repetition of schema details or annotations, and every sentence contributes value. This is exceptionally concise and well-structured.

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 simplicity (one required param, read-only, with an output schema), the description covers the key information: what is retrieved, how it is identified, and a critical non-real-time caveat. The output schema handles return values. The only gap is the misleading 'applicant email' reference, which detracts from completeness. Otherwise, it is sufficient for an agent to invoke the tool correctly if it relies on the schema and description together.

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 has one parameter (applicationId) with a description that is clear: 'The unique ID of the application to track.' The tool description, however, claims it can retrieve status 'by applicationId or applicant email,' yet no applicantEmail parameter exists in the schema. This is misleading and could cause an agent to attempt invocation with an unsupported parameter. Since schema coverage is 100%, the description adds no useful semantics and actively introduces ambiguity, so a score of 2 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 the tool's function: 'Retrieves the current enquiry/application status stored in SecureLend's system' by applicationId or applicant email. The verb 'retrieves' and the resource 'status' make the purpose explicit. However, it does not explicitly differentiate this from sibling tools like get_offer or get_multiple_offers, though the focus on 'status' rather than offer details provides some implicit distinction.

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

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

The description implies usage for checking application status, but provides no explicit guidance on when to use this vs alternatives like get_offer or get_multiple_offers. There are no 'use this when' or 'instead use X' statements. The mention of 'by applicationId or applicant email' hints at identification methods, but does not clarify when one identifier is preferred over the other. Overall, usage context is implied but not explicitly compared to siblings.

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