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

With no annotations provided, the description carries full burden for behavioral disclosure. It states the action is to 'Cancel' but doesn't explain what cancellation entails (e.g., whether it's immediate, reversible, affects future payments, or requires specific permissions). For a mutation tool with zero annotation coverage, this leaves significant behavioral gaps.

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, efficient sentence with zero wasted words. It's front-loaded with the core action and resource, making it immediately scannable and appropriately sized for the tool's complexity.

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

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

For a mutation tool with no annotations and no output schema, the description is inadequate. It doesn't explain what happens after cancellation (success/failure states, return values), behavioral implications, or error conditions. Given the complexity of financial operations and lack of structured metadata, more context is needed.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters. The description adds no additional parameter information beyond what's in the schema (e.g., it doesn't clarify what constitutes an 'active SIP' for the sip_registration_number). Baseline 3 is appropriate when the schema does all the parameter documentation work.

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 action ('Cancel') and target resource ('an active SIP'), making the purpose immediately understandable. It doesn't distinguish from sibling tools like 'fabits_get_sips' or 'fabits_start_sip', but the verb 'Cancel' provides adequate specificity for the core 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., that a SIP must be active), exclusions, or relationships to sibling tools like 'fabits_get_sips' (which might list active SIPs) or 'fabits_start_sip' (which creates SIPs).

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?

No annotations are provided, so the description carries full burden. It mentions 'Check payment status' but doesn't disclose behavioral traits such as whether this is a read-only operation, if it requires authentication, potential rate limits, or what the response format looks like (e.g., success/failure states). This leaves significant gaps for agent understanding.

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, efficient sentence that directly states the tool's purpose with zero waste. It's appropriately sized and front-loaded, making it easy to parse quickly.

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

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

Given the complexity (a payment status check with polling parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects, response format, or usage context, leaving the agent with insufficient information to use the tool effectively beyond basic parameter passing.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds no additional meaning beyond what's in the schema (e.g., it doesn't explain how 'max_attempts' and 'interval_seconds' relate to polling behavior). Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the action ('Check') and resource ('payment status for an order'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'fabits_status' or 'fabits_get_transactions', which might also involve status checking, so it lacks sibling 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., after order creation), exclusions, or how it relates to siblings like 'fabits_status' (which might be more general) or transaction-related 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?

No annotations are provided, so the description carries the full burden. It mentions OTP verification as a prerequisite, which adds some behavioral context, but it doesn't disclose critical traits like whether this is a read-only or destructive operation, authentication needs, rate limits, or what happens on success/failure. For a financial transaction tool, this is a significant 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 a single, efficient sentence that gets straight to the point without unnecessary words. It's appropriately sized for the tool's complexity, though it could be slightly more structured by front-loading key details more explicitly.

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

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

Given the complexity of a financial transaction tool with no annotations and no output schema, the description is incomplete. It lacks details on behavioral traits, error handling, return values, and differentiation from siblings. While concise, it doesn't provide enough context for safe and effective use by 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 5 parameters thoroughly. The description doesn't add any additional meaning or context beyond what's in the schema, such as explaining relationships between parameters or usage nuances. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('Complete UPI lumpsum investment') and the resource ('after OTP verification'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'fabits_invest_lumpsum_upi' which might handle earlier steps, leaving some ambiguity about the exact scope.

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

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

The description provides minimal guidance by implying usage after OTP verification, but it doesn't specify when to use this tool versus alternatives like 'fabits_invest_lumpsum_upi' or prerequisites beyond OTP. No explicit when-not-to-use or alternative recommendations are given, leaving gaps in usage 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Get' implies a read-only operation, but it doesn't specify authentication needs, rate limits, or what happens if the user_id is invalid. For a tool with no annotation coverage, this lack of behavioral context is a significant gap, though it doesn't contradict any 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, efficient sentence ('Get user action plans.') that is front-loaded and wastes no words. It could be slightly more informative, but it's appropriately sized for a simple tool, earning a high score for 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?

Given the tool's complexity (a read operation with one parameter) and the absence of annotations and output schema, the description is incomplete. It doesn't explain what 'action plans' are, the return format, or any behavioral traits. For a tool in a financial context with many siblings, this leaves the AI agent with insufficient information to use it effectively.

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 100% description coverage, with the 'user_id' parameter fully documented in the schema. The description adds no additional meaning about parameters beyond what's in the schema, such as format examples or constraints. According to the rules, with high schema coverage, the baseline score is 3, as the schema does the heavy lifting.

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

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

The description 'Get user action plans' clearly states the verb ('Get') and resource ('user action plans'), making the purpose understandable. However, it's vague about what 'action plans' entail (e.g., financial plans, tasks, or workflows) and doesn't distinguish this from siblings like 'fabits_get_portfolio' or 'fabits_get_sips', which also retrieve user-specific data. This leaves ambiguity about the specific type of data returned.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'fabits_get_portfolio' and 'fabits_get_sips' that might retrieve related user data, there's no indication of context, prerequisites, or exclusions. The only implied usage is based on the name, but this is insufficient for an AI agent to make informed decisions among similar 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?

No annotations are provided, so the description carries full burden. It implies a read operation ('Get'), but doesn't disclose behavioral traits such as authentication needs (though user_id is required), rate limits, response format, or whether it's idempotent. For a financial data tool with zero annotation coverage, this leaves significant gaps in understanding how it behaves.

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 concise at three words, with zero wasted text. It's front-loaded and efficiently states the core action, though this brevity contributes to its lack of detail in other dimensions.

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

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

Given the complexity of financial tools and lack of annotations or output schema, the description is incomplete. It doesn't explain what 'basket holdings' entails, how results are structured, or error conditions. For a tool in a suite with many siblings, more context is needed to use it effectively.

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 single parameter 'user_id' fully documented in the schema. The description adds no additional meaning about parameters beyond what's in the schema, so it meets the baseline of 3 where the schema does the heavy lifting without compensation needed.

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 'Get basket holdings' restates the tool name with minimal elaboration. It specifies the action ('Get') and resource ('basket holdings'), but lacks detail on what basket holdings are or how they differ from other portfolio-related tools like 'fabits_get_portfolio'. This is a tautology that provides only basic purpose without meaningful differentiation.

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?

No guidance is provided on when to use this tool versus alternatives. With sibling tools like 'fabits_get_portfolio' and 'fabits_get_transactions' that might overlap in financial data retrieval, the description offers no context, prerequisites, or exclusions to help an agent choose 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool 'Get[s]' details, implying a read-only operation, but doesn't mention authentication needs, rate limits, error handling, or response format. For a tool that likely accesses sensitive financial data, this lack of transparency is a significant gap, though it doesn't contradict any 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, efficient sentence that front-loads the core purpose ('Get comprehensive deep-dive details about a specific mutual fund'). It avoids redundancy and wastes no words, making it easy for an AI agent to parse quickly. Every part of the sentence contributes directly to understanding the tool's function.

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

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

Given the complexity of financial data tools, no annotations, and no output schema, the description is incomplete. It doesn't explain what 'comprehensive deep-dive details' include (e.g., performance metrics, risk ratings), how results are structured, or any prerequisites like user authentication. For a tool in a suite with many siblings, more context is needed to ensure proper usage.

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 100% description coverage, with clear documentation for both parameters (user_id and fund_id). The description adds no additional parameter semantics beyond implying the tool fetches details for a 'specific mutual fund' (matching fund_id). This meets the baseline of 3, as the schema adequately covers parameter meanings without needing extra explanation in the description.

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

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

The description clearly states the verb ('Get') and resource ('comprehensive deep-dive details about a specific mutual fund'), making the purpose evident. It distinguishes from siblings like 'fabits_search_funds' (searching) and 'fabits_get_star_funds' (listing star funds) by focusing on detailed information for a single fund. However, it doesn't explicitly mention what details are included, keeping it from a perfect score.

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?

No explicit guidance is provided on when to use this tool versus alternatives. While the description implies it's for detailed fund information, it doesn't specify scenarios (e.g., after selecting a fund from search results) or contrast with siblings like 'fabits_get_portfolio' (for user holdings) or 'fabits_get_basket_holdings' (for basket details). The lack of usage context leaves gaps for an AI 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Get complete portfolio overview' implies a read-only operation, but it doesn't specify whether this requires authentication, what data format is returned, if there are rate limits, or how errors are handled. For a tool with zero annotation coverage, this leaves significant behavioral gaps.

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 concise at just four words ('Get complete portfolio overview'), with zero wasted words. It's front-loaded with the core action and resource. Every word earns its place, making it highly efficient despite potential content gaps.

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

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

Given the complexity of portfolio management tools and the absence of both annotations and an output schema, the description is insufficiently complete. It doesn't explain what data is returned, how the portfolio is structured, or what 'complete' means in this context. For a tool that presumably returns complex financial data, more context is needed for effective use.

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 100% description coverage, with the single parameter 'user_id' well-documented in the schema. The description adds no additional parameter information beyond what's already in the schema. According to scoring rules, when schema_description_coverage is high (>80%), the baseline is 3 even with no param info in the description.

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

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

The description 'Get complete portfolio overview' clearly states the verb ('Get') and resource ('portfolio overview'), making the purpose understandable. However, it lacks specificity about what constitutes a 'complete portfolio overview' and doesn't differentiate from sibling tools like 'fabits_get_basket_holdings' or 'fabits_get_transactions' that might provide related but different portfolio 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 description provides no guidance on when to use this tool versus alternatives. With multiple sibling tools like 'fabits_get_basket_holdings' and 'fabits_get_transactions' that might offer overlapping or complementary portfolio information, there's no indication of what makes this tool distinct or when it should be preferred over others.

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 no annotations provided, the description carries the full burden of behavioral disclosure. It states it 'gets' data, implying a read-only operation, but lacks details on permissions, rate limits, pagination, error handling, or the format of returned SIP data. For a tool with no annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without redundancy. It is front-loaded with the core action and resource, making it easy to parse quickly, with no wasted words or unnecessary elaboration.

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

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

Given no annotations and no output schema, the description is incomplete for a data retrieval tool. It doesn't explain what data is returned (e.g., SIP details, statuses, amounts), how results are structured, or any limitations (e.g., only returns SIPs for the specified user). For a tool in a financial context with siblings involving mutations, more context is needed to ensure safe and effective use.

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 single parameter 'user_id' documented as a required unique identifier for user session state. The description adds no additional parameter semantics beyond what the schema provides, such as explaining why user_id is needed or how it affects the SIP retrieval. Baseline 3 is appropriate given the schema handles parameter documentation.

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

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

The description clearly states the verb ('Get') and resource ('all active and inactive SIPs'), making the purpose immediately understandable. It distinguishes this tool from siblings like 'fabits_get_portfolio' or 'fabits_get_transactions' by specifying SIPs, though it doesn't explicitly contrast with 'fabits_start_sip' or 'fabits_cancel_sip' beyond the read vs. write 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?

No guidance is provided on when to use this tool versus alternatives. While the description implies it's for retrieving SIP data, it doesn't mention prerequisites (e.g., authentication state), compare it to similar tools like 'fabits_get_portfolio' for broader holdings, or indicate scenarios where it's preferred over other data-fetching 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states a read operation ('Get'), implying it's likely safe, but doesn't mention any constraints like rate limits, authentication needs, or what 'curated top recommended' entails (e.g., based on user profile, time-sensitive). This leaves significant gaps for a tool that might involve financial data.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without any fluff or redundancy. It's appropriately sized and front-loaded, making it easy to parse quickly.

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

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

Given the complexity of financial tools and the lack of annotations and output schema, the description is insufficient. It doesn't explain what 'curated top recommended' means, how results are returned, or any behavioral traits, leaving the agent with incomplete context for safe and effective use.

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 100% description coverage, with the 'user_id' parameter well-documented as a required unique identifier. The description adds no additional parameter semantics beyond what's in the schema, so it meets the baseline of 3 for high schema coverage without compensating 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 clearly states the action ('Get') and the resource ('Fabits curated top recommended mutual funds'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'fabits_search_funds' or 'fabits_get_fund_details', which might also retrieve fund information, so it lacks sibling 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 provides no guidance on when to use this tool versus alternatives. With siblings like 'fabits_search_funds' and 'fabits_get_fund_details', there's no indication of context, prerequisites, or exclusions, leaving the agent to guess based on tool names alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action ('Get') without mentioning any behavioral traits such as whether it's read-only (implied but not explicit), if there are rate limits, authentication needs beyond the user_id parameter, or what the output format might be. This leaves significant gaps for safe and effective tool invocation.

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 ('Get transaction history.') that is front-loaded and wastes no words. It efficiently communicates the core purpose without unnecessary elaboration, though it could benefit from more detail to improve clarity and completeness.

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

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

Given the complexity of a transaction history tool with 2 parameters and no output schema, the description is incomplete. It doesn't explain what data is returned (e.g., transaction types, dates, amounts), any limitations (e.g., date ranges, pagination), or how it fits into the broader context of sibling tools. With no annotations and an output schema missing, more detail is needed for effective use.

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 100% description coverage, with clear documentation for both parameters (user_id and limit). The description adds no additional meaning beyond the schema, such as explaining the scope of 'transaction history' or how parameters interact. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, but the description doesn't compensate or enhance understanding.

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 'Get transaction history' clearly states the action (get) and resource (transaction history), making the basic purpose understandable. However, it lacks specificity about what kind of transactions (e.g., investment, payment) and doesn't differentiate from sibling tools like 'fabits_get_sips' or 'fabits_get_portfolio', which also retrieve historical data. This makes it vague compared to more precise alternatives.

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

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

The description provides no guidance on when to use this tool versus alternatives. For example, it doesn't specify if this is for all transactions or a subset, or how it differs from other 'get' tools like 'fabits_get_sips' (for SIPs) or 'fabits_get_portfolio' (for holdings). Without such context, an agent might struggle to choose between similar retrieval 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?

No annotations are provided, so the description carries full burden. It mentions 'invest' which implies a financial transaction, but doesn't disclose critical behavioral traits like whether this requires authentication, confirmation steps, transaction fees, or what happens on success/failure. This is inadequate for a tool that likely involves money movement.

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, efficient sentence with no wasted words. It's appropriately sized and front-loaded with the core action, making it easy to parse quickly.

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 financial investment tool with no annotations and no output schema, the description is incomplete. It doesn't address behavioral aspects like transaction processing, error handling, or return values, which are crucial for such an operation.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description doesn't add any meaning beyond what's in the schema (e.g., it doesn't explain basket selection logic or amount constraints), meeting the baseline for high coverage.

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

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

The description 'Invest in a basket of funds' clearly states the action (invest) and resource (basket of funds), but it's vague about the specific investment type. It doesn't distinguish from siblings like 'fabits_invest_basket_onetime' or 'fabits_invest_basket_sip' which suggests different investment methods.

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?

No guidance is provided on when to use this tool versus alternatives. With siblings like 'fabits_invest_basket_onetime' and 'fabits_invest_basket_sip', the description doesn't explain whether this is for one-time investments, SIPs, or another method, leaving usage unclear.

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?

No annotations are provided, so the description carries full burden. It mentions 'Invest' implying a financial transaction, but lacks details on permissions, authentication needs, rate limits, or potential side effects (e.g., payment processing, confirmation). This is inadequate for a tool that likely involves sensitive operations.

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, efficient sentence that gets straight to the point without unnecessary words. It's appropriately sized for the tool's complexity, though it could be more informative.

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 no annotations and no output schema, the description is insufficient for a tool with 5 required parameters and likely financial implications. It lacks details on behavior, return values, error handling, and how it integrates with sibling tools, leaving significant gaps 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 fully documents all 5 parameters. The description adds no additional meaning about parameters beyond implying 'action plan' relates to 'plan_id'. Baseline 3 is appropriate as the schema handles 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 states the action ('Invest in action plan') and method ('via one-time lumpsum'), which is clear but somewhat vague. It doesn't specify what 'action plan' means in this context or how it differs from similar tools like 'fabits_invest_basket' or 'fabits_invest_lumpsum', missing sibling differentiation.

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?

No guidance is provided on when to use this tool versus alternatives. With multiple investment-related tools in the sibling list (e.g., 'fabits_invest_basket_sip', 'fabits_invest_lumpsum'), the description fails to indicate specific contexts, prerequisites, or exclusions for this one-time lumpsum method.

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 no annotations provided, the description carries the full burden of behavioral disclosure. 'Invest in action plan via SIP' implies a financial transaction that creates a recurring investment commitment, but the description doesn't disclose critical behavioral aspects like whether this requires authentication, what happens if parameters are invalid, whether the investment is immediate or scheduled, or what side effects occur. For a financial tool with significant implications, this is inadequate.

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 concise with just one sentence containing 6 words. While this is efficient, it may be too brief given the tool's complexity. The structure is front-loaded with the core action, but lacks any supporting context that would help an agent understand when and how to use this tool effectively.

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 financial investment tool with 6 required parameters, no annotations, and no output schema, the description is severely incomplete. It doesn't explain what 'action plan' means, what happens after investment, what the expected response format is, or any error conditions. Given the tool's complexity and the absence of structured behavioral information, the description fails to provide adequate context for safe and effective use.

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 6 parameters thoroughly. The description adds no additional meaning about parameters beyond what's in the schema - it doesn't explain relationships between parameters (like how plan_id relates to SIP investment) or provide usage context. With complete schema coverage, 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 states the action ('Invest in action plan via SIP') which provides a basic purpose, but it's vague about what 'action plan' means and doesn't distinguish this from sibling tools like 'fabits_invest_basket' or 'fabits_invest_basket_onetime'. The description lacks specificity about what resource is being invested in or how this differs from other investment 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?

No guidance is provided about when to use this tool versus alternatives like 'fabits_invest_basket_onetime' (one-time investment) or 'fabits_start_sip' (starting a SIP). The description doesn't mention prerequisites, timing considerations, or any context for choosing this particular investment method over others available.

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?

No annotations are provided, so the description carries the full burden. It mentions 'place a one-time lumpsum investment order,' implying a write operation, but doesn't disclose critical behavioral traits such as authentication needs, rate limits, transaction confirmation, or error handling. For a financial tool with no annotations, this is a significant gap in 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 a single, clear sentence that is front-loaded and wastes no words. It efficiently conveys the core purpose without unnecessary elaboration, making it easy to parse and understand quickly.

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

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

Given the complexity of a financial investment tool with no annotations and no output schema, the description is incomplete. It lacks details on behavioral aspects (e.g., side effects, returns), doesn't explain the outcome or confirmation process, and fails to address how it fits among sibling tools, leaving significant gaps 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 fully documents the three parameters (user_id, fund_id, amount). The description adds no additional meaning beyond what's in the schema, such as format details or constraints. With high schema coverage, a baseline score of 3 is appropriate as the description doesn't compensate but doesn't need to.

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 action ('place a one-time lumpsum investment order'), which is specific and includes the resource ('investment order'). However, it doesn't differentiate from sibling tools like 'fabits_invest_lumpsum_upi' or 'fabits_invest_basket_onetime', which might also handle one-time investments, leaving some ambiguity about when to choose this specific tool.

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

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

No guidance is provided on when to use this tool versus alternatives. With multiple investment-related siblings (e.g., 'fabits_invest_lumpsum_upi', 'fabits_invest_basket_onetime'), the description lacks context about prerequisites, timing, or distinctions, offering no help in tool selection.

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

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

With no annotations, the description carries full burden but only states 'Initiate', implying a write operation without details on permissions, side effects (e.g., payment initiation, confirmation steps), or error handling. It misses critical behavioral traits like whether it triggers immediate payment or requires follow-up actions.

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, efficient sentence that front-loads the core action without unnecessary words. It earns its place by succinctly conveying the tool's 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 financial transaction tool with 6 required parameters and no annotations or output schema, the description is inadequate. It lacks details on behavioral outcomes (e.g., what happens after initiation), error cases, or integration with sibling tools like 'fabits_complete_lumpsum_upi', leaving gaps in understanding.

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 parameters are well-documented in the schema. The description adds no extra meaning beyond implying UPI usage, which is already clear from the tool name and parameter 'upi_id'. Baseline 3 is appropriate as the schema handles most 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 clearly states the action ('Initiate') and resource ('UPI lumpsum investment'), making the purpose evident. It distinguishes from siblings like 'fabits_invest_lumpsum' by specifying the UPI method, though it doesn't explicitly contrast with all investment tools (e.g., 'fabits_invest_basket').

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?

No guidance is provided on when to use this tool versus alternatives like 'fabits_invest_lumpsum' (non-UPI) or other investment methods. The description lacks context about prerequisites, timing, or exclusions, leaving usage unclear.

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?

No annotations are provided, so the description carries the full burden. It discloses key behavioral traits: it clears authentication tokens and requires re-login, which are crucial for a destructive operation. However, it lacks details on permissions needed, rate limits, or error handling, leaving gaps in behavioral understanding.

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 core action and consequence in two concise sentences. Every sentence earns its place by explaining what the tool does and its immediate effect, with zero wasted words 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?

Given the tool's complexity (a destructive authentication operation), lack of annotations, and no output schema, the description is moderately complete. It covers the main action and consequence but omits details like response format, error cases, or security implications, which could aid the agent in handling this tool effectively.

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%, with the parameter 'user_id' fully documented in the schema. The description does not add any parameter-specific information beyond what the schema provides, such as format examples or usage context, so it meets the baseline score without compensating further.

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 specific action ('Logout and clear all stored authentication tokens') and resource (authentication tokens), distinguishing it from sibling tools like 'fabits_refresh_token' or 'fabits_verify_otp' which handle authentication differently. It explicitly mentions the consequence ('User will need to login again'), 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 provides clear context for when to use this tool: when logout is needed, and it implies usage by stating the user will need to login again. However, it does not explicitly mention when NOT to use it (e.g., vs. 'fabits_refresh_token' for token renewal) or name alternatives, which prevents a perfect 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('redeem/sell') but lacks critical details: it doesn't specify if this is a financial transaction with irreversible effects, mention authentication requirements (implied by user_id), discuss rate limits, or describe the expected outcome (e.g., confirmation, funds transfer). This is inadequate for a mutation tool with zero annotation coverage.

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 concise—a single, clear sentence that states the core purpose without any fluff. It's front-loaded with the essential action and resource, making it efficient and easy to parse. Every word 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 complexity of a financial redemption tool with no annotations and no output schema, the description is incomplete. It fails to address behavioral aspects (e.g., transaction finality, error handling), usage context, or expected results. For a 5-parameter mutation tool in a financial domain, this leaves significant gaps for an AI agent to operate safely and effectively.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds no additional meaning beyond what's in the schema (e.g., it doesn't clarify the relationship between 'units' and 'amount' as alternatives). With high schema coverage, the baseline score of 3 is appropriate as the description provides minimal value over structured data.

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 action ('redeem/sell') and resource ('mutual fund units'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this from sibling tools like 'fabits_cancel_sip' or 'fabits_get_portfolio', which also involve fund operations but serve different purposes.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing existing holdings), exclusions (e.g., not for SIPs), or compare to siblings like 'fabits_invest_lumpsum' for opposite actions. Usage is implied but not explicitly stated.

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

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

No annotations are provided, so the description carries the full burden. It discloses the tool's purpose (refreshing tokens) and trigger condition (401/403 errors), but lacks details on behavioral traits like rate limits, side effects (e.g., invalidating old tokens), error handling beyond 401/403, or response format. The description adds basic context but misses deeper operational insights.

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 zero waste: the first states the purpose, and the second provides usage guidelines. It is front-loaded with essential information and appropriately sized for a single-parameter tool with a clear, focused function.

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 no annotations and no output schema, the description is moderately complete. It covers the tool's purpose and usage trigger effectively, but for a token refresh operation—which involves authentication state changes—it lacks details on expected outcomes (e.g., new token format), error scenarios beyond 401/403, or dependencies on other tools. This leaves gaps in operational 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?

Schema description coverage is 100%, with the single parameter 'user_id' fully documented in the schema. The description does not add any parameter-specific details beyond what the schema provides, such as explaining why 'user_id' is needed for token refresh. Baseline 3 is appropriate as the schema handles parameter documentation adequately.

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 specific action ('Refresh expired access token') and resource ('using the stored refresh token'), distinguishing it from siblings that handle investments, portfolio queries, or authentication flows like OTP verification. It directly addresses token renewal, a distinct operational need.

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 this tool ('when you get 401/403 errors due to token expiration'), providing clear context for invocation. This guidance helps differentiate it from other authentication-related tools like 'fabits_verify_otp' or 'fabits_request_otp', which handle initial login rather than token refresh.

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 no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that OTP is sent to a phone number and must be called first, but lacks details on rate limits, error handling, session state implications, or what happens if called repeatedly. For a login-related tool, this is a significant gap in 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 front-loaded and concise, consisting of two sentences that efficiently convey the tool's role in the login flow without unnecessary details. Every sentence earns its place by stating the action and prerequisite step.

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 (login step with 2 parameters), no annotations, and no output schema, the description is minimally adequate. It covers the basic purpose and sequence but lacks details on behavioral aspects, error cases, or return values, which are important for a login tool in a financial 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?

Schema description coverage is 100%, so the schema already documents both parameters (user_id and phone_number) with their purposes and formats. The description does not add any additional meaning beyond what the schema provides, such as explaining the relationship between user_id and phone_number or usage nuances, resulting in a baseline score 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 tool's purpose as 'Step 1 of login: Request OTP to be sent to phone number,' specifying the action (request OTP) and resource (phone number). It distinguishes itself from sibling tools like 'fabits_verify_otp' by indicating this is the first step in a login flow, though it could be more explicit about the login context (e.g., for financial services).

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 on when to use this tool: as the first step in login before verifying OTP. It implicitly distinguishes from 'fabits_verify_otp' by sequence, but does not explicitly mention alternatives or exclusions, such as when not to use it (e.g., if already logged in).

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 no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the return format ('top matching funds with key metrics') but lacks details on authentication needs, rate limits, error handling, or session state implications. For a search tool with user_id as required, this is a significant gap in 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 a single, efficient sentence that front-loads the purpose and outcome without unnecessary details. Every word contributes to understanding the tool's function, making it appropriately sized 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 complexity of a search tool with 3 parameters, no annotations, and no output schema, the description is adequate but incomplete. It covers the basic purpose and return format but lacks details on behavioral aspects like authentication or error handling, which are crucial for a tool with a required user_id parameter.

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%, providing clear documentation for all parameters. The description adds minimal value beyond the schema, as it doesn't elaborate on parameter interactions or search behavior. Baseline 3 is appropriate since the schema does the heavy lifting, though no extra context is provided.

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 ('search') and resource ('mutual funds') with specific search criteria ('by name, category, or keywords') and outcome ('returns top matching funds with key metrics'). It distinguishes from siblings like 'fabits_get_fund_details' by focusing on search rather than retrieval of specific fund details, though it doesn't explicitly name alternatives.

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

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

No explicit guidance on when to use this tool versus alternatives like 'fabits_get_star_funds' or 'fabits_get_fund_details'. The description implies usage for searching funds but lacks context about prerequisites, timing, or exclusions, such as whether it's for initial discovery or ongoing research.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions sending an OTP but fails to describe critical traits such as delivery method (e.g., SMS, email), rate limits, security implications, or response format. For a tool involving user communication and security, this lack of detail is a significant 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 a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and wastes no space, making it easy for an agent to parse quickly.

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

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

Given the complexity of OTP sending in an investment context, no annotations, and no output schema, the description is incomplete. It omits details on behavior (e.g., delivery, errors), usage context, and return values, which are essential for an agent to invoke this tool correctly and handle responses.

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

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

Schema description coverage is 100%, with clear documentation for all three parameters (user_id, phone_number, email). The description adds no additional meaning beyond the schema, such as explaining why all three are required or their interrelationships. However, the schema adequately covers parameter semantics, 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 the action ('send transactional OTP') and the domain ('for investment'), which is specific and unambiguous. It distinguishes itself from sibling tools like 'fabits_request_otp' and 'fabits_verify_transactional_otp' by focusing on sending OTPs for transactional purposes, though it could be more explicit about the exact context (e.g., during investment processes).

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

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

The description provides no guidance on when to use this tool versus alternatives like 'fabits_request_otp' or 'fabits_verify_transactional_otp'. It lacks context on prerequisites (e.g., user authentication), specific scenarios (e.g., after initiating an investment), or exclusions, leaving the agent to infer usage from the name and sibling tools alone.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. 'Setup e-mandate' implies a configuration/write operation, but the description doesn't specify whether this is a one-time setup, what permissions are required, whether it's reversible, what happens on success/failure, or any rate limits/constraints. For a financial setup tool with 9 parameters, this is a significant gap in 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 a single, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a tool with a clear primary function, though the brevity contributes to gaps in other dimensions.

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 financial mandate setup tool with 9 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what an e-mandate is in this context, what the setup process entails, what happens after setup, or what the tool returns. The combination of complex domain, multiple parameters, and lack of structured metadata requires more explanatory content.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema - it doesn't explain relationships between parameters, provide examples, or clarify the purpose of optional fields like 'amount' override. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the action ('Setup e-mandate') and the target resource ('for action plan SIP'), providing a specific verb+resource combination. It distinguishes this as a setup/configuration tool rather than an investment or query tool, though it doesn't explicitly differentiate from all sibling tools like 'fabits_start_sip' which might have overlapping domains.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., whether an action plan must exist first), when this should be called in a workflow, or how it relates to sibling tools like 'fabits_start_sip' or 'fabits_invest_basket_sip' that also involve SIPs.

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 no annotations provided, the description carries full burden but offers minimal behavioral insight. It states the action ('Start a SIP') but doesn't disclose critical traits like authentication requirements, whether it's idempotent, what happens on failure, or typical response patterns. This is inadequate for a financial transaction 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 a single, focused sentence with zero wasted words. It's front-loaded with the core action and resource, making it immediately understandable without unnecessary elaboration.

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

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

For a financial transaction tool with no annotations and no output schema, the description is insufficient. It doesn't address behavioral aspects, error conditions, or what the agent should expect upon successful execution. Given the complexity of starting a financial plan, more context is needed.

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

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

Schema description coverage is 100%, providing complete parameter documentation. The description adds no additional parameter semantics beyond what's in the schema, so it meets the baseline score of 3 where the schema does the heavy lifting.

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

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

The description clearly states the verb ('Start') and resource ('Systematic Investment Plan'), making the purpose immediately understandable. It distinguishes from siblings like 'fabits_cancel_sip' by indicating creation rather than termination, though it doesn't explicitly contrast with other investment tools like 'fabits_invest_basket_sip'.

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?

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites, timing considerations, or differentiate it from similar tools like 'fabits_invest_basket_sip' or 'fabits_invest_lumpsum', leaving the agent without contextual usage cues.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions checking 'authentication status and account details including KYC status,' which implies a read-only operation, but doesn't specify whether this requires prior authentication, what data is returned, potential rate limits, or error conditions. This leaves significant gaps for a tool that likely interacts with user accounts.

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, efficient sentence that front-loads the core purpose. There's no wasted text, though it could potentially be more structured (e.g., separating authentication status from account details) for 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 the complexity of checking authentication and account details, the description is incomplete. With no annotations and no output schema, it fails to explain what the tool returns (e.g., KYC status values, account metadata) or behavioral aspects like error handling. This is inadequate for a tool that likely provides critical user state 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 input schema has 100% description coverage, with the single parameter 'user_id' well-documented in the schema itself. The description adds no additional parameter information beyond what's in the schema, so it meets the baseline of 3 for high schema coverage without compensating 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 clearly states the tool's purpose with specific verbs ('check') and resources ('authentication status and account details including KYC status'). It distinguishes itself from most siblings which focus on investment actions, though it doesn't explicitly differentiate from potentially similar tools like 'fabits_refresh_token' or 'fabits_logout' that might also relate to authentication.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., whether authentication is required), timing (e.g., after login or before transactions), or how it differs from other auth-related tools like 'fabits_refresh_token' or 'fabits_logout' in the sibling list.

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

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

With no annotations provided, the description carries full burden and does well by disclosing key behaviors: it 'Stores authentication token for subsequent requests' (critical side effect), identifies it as part of a two-step login process, and implies it completes authentication. However, it doesn't mention error conditions, token expiration, or security implications, leaving some behavioral aspects uncovered.

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 perfectly concise with three sentences that each earn their place: establishes context ('Step 2 of login'), states core action ('Verify OTP and complete login'), discloses critical behavior ('Stores authentication token'), and provides essential guidance ('Must call fabits_request_otp first'). No wasted words, front-loaded with 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 an authentication tool with no annotations and no output schema, the description does well by covering purpose, prerequisites, and key side effects. However, it lacks information about return values (what happens on success/failure) and doesn't mention potential error conditions or token management details, leaving some gaps for a security-critical operation.

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 all three parameters. The description adds no additional parameter semantics beyond what's in the schema descriptions (e.g., 'user_id' as session identifier, 'phone_number' matching request_otp, 'otp' as one-time password). This meets the baseline 3 when schema does the heavy lifting.

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

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

The description clearly states the specific action ('Verify OTP and complete login') and resource (authentication process), distinguishing it from sibling tools like 'fabits_request_otp' (step 1) and 'fabits_refresh_token' (token renewal). It explicitly identifies this as 'Step 2 of login' with a distinct role in the authentication 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 explicit usage guidance: 'Must call fabits_request_otp first' establishes a prerequisite, and positioning it as 'Step 2 of login' clearly defines when to use it versus alternatives like 'fabits_refresh_token' for token renewal or other non-login tools. This creates clear boundaries within the authentication workflow.

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 no annotations provided, the description carries the full burden of behavioral disclosure. It states the action is verification but doesn't explain what happens upon success/failure, authentication requirements, rate limits, or side effects. This leaves critical behavioral traits unspecified for a security-related 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 extremely concise with a single, front-loaded sentence that directly states the tool's purpose. There is no wasted verbiage or unnecessary structure, making it efficient for quick comprehension.

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

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

Given the complexity of OTP verification (a security-sensitive operation), no annotations, and no output schema, the description is insufficient. It lacks details on behavior, error handling, and integration with sibling tools, failing to provide a complete context for safe and effective use.

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

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

Schema description coverage is 100%, so the schema fully documents the three required parameters (user_id, phone_number, otp). The description adds no additional parameter semantics beyond what's in the schema, meeting the baseline for high coverage but not enhancing understanding.

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 'Verify transactional OTP' states the action (verify) and resource (transactional OTP), making the basic purpose clear. However, it doesn't specify what 'transactional OTP' means in this context or distinguish it from the sibling tool 'fabits_verify_otp', leaving some ambiguity about scope and differentiation.

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?

No guidance is provided on when to use this tool versus alternatives like 'fabits_verify_otp' or 'fabits_request_otp'. The description lacks context about prerequisites (e.g., after sending an OTP) or typical workflows, offering no usage instructions.

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