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 ('Cancel') but doesn't disclose critical traits like whether cancellation is reversible, requires specific permissions, has side effects (e.g., on account status), or returns confirmation details. 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 appropriately sized and front-loaded, with the core purpose in the first line and parameter details following. It avoids unnecessary elaboration, though the 'Args' formatting could be more integrated with the main text for better flow.

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 mutation with no annotations, 0% schema coverage, and no output schema), the description is insufficient. It lacks details on behavior, error conditions, return values, and integration with sibling tools, leaving significant gaps for an AI agent to operate 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 description includes an 'Args' section that documents the single parameter 'order_id', adding meaning beyond the schema (which has 0% description coverage). However, it only states 'Order ID to cancel' without explaining format, source (e.g., from 'get_mf_orders'), or validation rules, providing basic but incomplete semantic context.

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 ('Cancel') and resource ('a mutual fund order'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'cancel_mf_sip' or explain what distinguishes a mutual fund order from other order types, which prevents 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., whether the order must be in a cancellable state), exclusions, or relationships with sibling tools like 'place_mf_order' or 'get_mf_orders', leaving usage context 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 cancellation but doesn't disclose behavioral traits like whether this is reversible, requires specific permissions, has side effects on holdings, or follows rate limits. For a mutation tool with zero annotation coverage, 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 zero waste—two sentences that directly state the purpose and parameter. It's front-loaded and appropriately sized for a simple 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 the tool's complexity (a mutation operation), lack of annotations, no output schema, and low schema coverage, the description is incomplete. It doesn't cover return values, error conditions, or important behavioral context needed for safe invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It adds the meaning of 'sip_id' as 'SIP ID to cancel', which clarifies the parameter's purpose. However, it doesn't provide format details, examples, or constraints beyond what's implied, leaving some gaps.

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 ('Cancel') and resource ('a mutual fund SIP'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'cancel_mf_order' or 'modify_mf_sip', which would require explicit comparison to earn a 5.

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

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

No guidance is provided on when to use this tool versus alternatives like 'modify_mf_sip' or 'cancel_mf_order'. The description only states what it does, without context about prerequisites, timing, or 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?

No annotations are provided, so the description carries the full burden. It mentions that the tool 'initiate authentication if needed', implying it may perform a write operation, but doesn't disclose behavioral traits such as whether this requires user interaction, what happens during initiation, rate limits, or error handling. The description is too vague for a tool that potentially modifies state.

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 concise sentences that front-load the core functionality ('Check if Kite is authenticated and initiate authentication if needed') and follow with return information. Every sentence earns its place without redundancy or 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 tool's complexity (it checks and potentially initiates authentication), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what 'authentication status' includes, what 'relevant messages' are, or the behavior during initiation. For a state-modifying tool with no structured support, more detail 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?

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate here. Baseline is 4 for zero parameters, as the description doesn't need to compensate for any gaps.

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: 'Check if Kite is authenticated and initiate authentication if needed.' This specifies the verb ('check' and 'initiate') and resource ('authentication'), distinguishing it from siblings like 'get_request_token' or 'initiate_login'. However, it doesn't explicitly differentiate from 'initiate_login' beyond the dual-action nature.

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 context through 'if needed', suggesting this tool should be used when authentication status is uncertain. However, it doesn't provide explicit guidance on when to use this versus alternatives like 'initiate_login' or 'get_request_token', nor does it mention prerequisites or 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?

No annotations are provided, so the description carries full burden for behavioral disclosure. It states what the tool does (gets historical data) but provides minimal behavioral context: no information about authentication needs, rate limits, data format returned, pagination, error conditions, or what 'historical data' specifically entails (e.g., OHLC candles, volume). The description is functional but lacks transparency about operational 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 appropriately concise with a clear purpose statement followed by parameter documentation. Every sentence serves a purpose: the first states the tool's function, and the Args section documents parameters. However, the structure could be improved by integrating parameter explanations more naturally rather than a separate Args section, and some information is under-specified (e.g., 'etc.' for intervals).

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, 0% schema description coverage, no output schema, and 4 parameters, the description is incomplete. It covers basic functionality and parameters but lacks critical context: no information about return format (what 'historical data' looks like), error handling, authentication requirements, rate limits, or data limitations. For a data retrieval tool with multiple parameters, this leaves the agent with significant uncertainty about proper usage and expected outcomes.

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 0%, so the description must compensate. It provides basic semantics for all 4 parameters: identifies instrument_token as the instrument identifier, from_date/to_date as date range with format examples, and interval as candle interval with examples. However, it doesn't explain what an 'instrument token' is, valid date ranges, or comprehensive interval options beyond 'minute, day, 3minute, etc.' The description adds value but leaves significant gaps in parameter 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 clearly states the tool's purpose: 'Get historical data for an instrument' with a specific verb ('Get') and resource ('historical data for an instrument'). It distinguishes from most siblings (e.g., get_quote, get_holdings) by focusing on historical time-series data rather than current quotes or account information. However, it doesn't explicitly differentiate from all possible historical data tools if they existed.

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. While the name suggests it's for historical data (unlike get_quote for current data), there's no explicit mention of alternatives, prerequisites, or context for usage. The parameter documentation implies usage for date ranges and intervals but offers no strategic 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'Get' implies a read operation, the description doesn't specify whether authentication is required, what data format is returned, whether there are rate limits, or if there are any prerequisites like account setup. This leaves significant behavioral questions unanswered.

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 three words, with zero wasted language. It's front-loaded with the core purpose and contains no unnecessary information. For a simple tool like this, the brevity is appropriate and efficient.

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 financial context and lack of annotations or output schema, the description is insufficient. It doesn't specify what constitutes 'holdings/portfolio' (stocks, mutual funds, derivatives?), whether this returns current or historical data, or what authentication is required. For a financial data tool with no structured documentation, 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?

The tool has zero parameters, and schema description coverage is 100%, so there are no parameters to document. The description appropriately doesn't mention parameters, which is correct for a parameterless tool. A baseline of 4 is appropriate since there's nothing missing or misleading about parameter documentation.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('user's holdings/portfolio'), making it immediately understandable. However, it doesn't distinguish this tool from its sibling 'get_mf_holdings', which appears to serve a similar but potentially different function (mutual fund holdings vs general holdings).

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 sibling tools like 'get_mf_holdings', 'get_positions', and 'get_historical_data' available, there's no indication of how this tool differs in scope or when it should be preferred over those 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?

With no annotations provided, the description carries full burden for behavioral disclosure. 'Get' implies a read operation, but it doesn't specify whether this requires authentication, returns real-time or cached data, has rate limits, or what format the output takes. For a financial data tool with zero annotation coverage, this is insufficient.

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, which is appropriate for a simple tool. However, it could be more front-loaded with context (e.g., 'Retrieve margin trading information for the authenticated account') to better serve the agent immediately.

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 financial context and sibling tools suggesting account operations, the description is incomplete. With no annotations, no output schema, and a vague purpose, it doesn't provide enough information for reliable tool selection. A better description would clarify what 'margins' means and typical use cases.

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

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

The tool has 0 parameters with 100% schema description coverage, so the schema fully documents the absence of inputs. The description doesn't need to compensate for parameter gaps, and 'Get account margins' appropriately implies no required inputs. Baseline 4 is appropriate for parameterless tools.

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 account margins' clearly states the verb ('Get') and resource ('account margins'), making the basic purpose understandable. However, it lacks specificity about what 'margins' means in this financial context and doesn't differentiate from siblings like get_holdings or get_positions, which also retrieve account information.

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 (like authentication), timing considerations, or how it differs from other account information tools in the sibling list, leaving the agent to infer 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?

With no annotations, the description carries full burden but only states what the tool does, not how it behaves. It doesn't disclose whether this is a read-only operation, requires authentication, has rate limits, returns structured data, or handles errors—critical for a financial data tool with siblings involving authentication.

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 front-loaded with the core action and resource, 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?

For a tool with no annotations, no output schema, and siblings involving authentication and financial transactions, the description is incomplete. It doesn't address behavioral aspects like data format, error handling, or authentication needs, leaving gaps for an AI agent to use it correctly in context.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, but this is acceptable given the lack of parameters, aligning with the baseline for 0 params.

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 ('user's mutual fund holdings'), making the purpose understandable. It distinguishes from siblings like 'get_holdings' by specifying 'mutual fund' holdings, though it doesn't explicitly contrast with 'get_positions' or other financial data 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 on when to use this tool versus alternatives like 'get_holdings' or 'get_positions'. The description implies it's for mutual fund holdings specifically, but lacks explicit context about prerequisites (e.g., authentication) or when-not-to-use scenarios.

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 operation, but doesn't specify if this requires authentication, returns paginated results, has rate limits, or what format the output takes. This leaves significant gaps for an agent to understand how to invoke it effectively.

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 with no wasted words. It is front-loaded with the core action and resource, making it easy to parse. 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 and the lack of annotations and output schema, the description is insufficient. It doesn't explain what 'instruments' entails (e.g., fund details, identifiers), how results are structured, or any behavioral traits like authentication needs. For a tool in this domain, more context is needed to ensure reliable 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 tool has 0 parameters, and the input schema has 100% coverage (since there are no parameters to document). The description doesn't need to add parameter semantics, so it meets the baseline for a parameterless tool. No additional value is required beyond stating the purpose.

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 ('all available mutual fund instruments'), making the purpose immediately understandable. It doesn't differentiate from siblings like 'get_mf_holdings' or 'get_mf_orders', which would require more specificity about what constitutes 'instruments' versus 'holdings' or 'orders'.

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. For example, it doesn't explain if this is for listing all mutual funds versus filtered subsets, or how it differs from sibling tools like 'get_mf_holdings' or 'get_quote'. The description lacks context on prerequisites or typical use cases.

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 states 'Get all mutual fund orders' but doesn't disclose behavioral traits such as authentication requirements, rate limits, pagination, or whether it returns historical vs. active orders. This is a significant gap for a 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 a single, efficient sentence with no wasted words. It's front-loaded and appropriately sized for a tool with no parameters, making it highly 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 lack of annotations and output schema, the description is incomplete. It doesn't explain what 'all' entails (e.g., time range, status), return format, or error handling. For a tool with no structured data support, more context is needed to be fully helpful.

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 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, but that's acceptable given the schema completeness, warranting a baseline score above 3 for this context.

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 all mutual fund orders' clearly states the verb ('Get') and resource ('mutual fund orders'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'get_mf_sips' or 'get_mf_holdings' beyond the resource type, missing specific scope distinctions.

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 'get_mf_sips' and 'get_mf_holdings', it's unclear if this tool retrieves all orders (including pending/completed) or has specific filtering criteria, leaving usage ambiguous.

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 'Get all mutual fund SIPs', implying a read operation, but doesn't specify whether this requires authentication, returns paginated results, includes historical or active SIPs, or has any rate limits. 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 a single, efficient sentence with zero wasted words. It is front-loaded with the core action and resource, making it easy to parse. Every word earns its place by conveying essential information without redundancy.

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

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

Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks context on authentication, return format, or behavioral traits. Without annotations or output schema, the description should ideally provide more completeness, but it meets the bare minimum for a basic retrieval tool.

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

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

The input schema has 0 parameters with 100% coverage, meaning no parameters are documented in the schema. The description doesn't add parameter details, but since there are no parameters, this is acceptable. The baseline for 0 parameters is 4, as the description needn't compensate for missing 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 mutual fund SIPs'), making the purpose unambiguous. It doesn't explicitly differentiate from sibling tools like 'get_mf_orders' or 'get_mf_holdings', but the specificity of 'mutual fund SIPs' provides reasonable distinction. This is not vague or tautological.

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., authentication), context for retrieval, or how it differs from similar sibling tools like 'get_mf_holdings' or 'get_mf_orders'. Without any usage context, the agent must infer when this tool is appropriate.

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 implies a read operation ('Get') but doesn't specify authentication requirements, rate limits, response format, or whether it returns current or historical data. This is inadequate for a 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 ('Get user's positions') with no wasted words. It's front-loaded and efficiently communicates the core purpose in three words, 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 no annotations, no output schema, and a simple but vague purpose, the description is incomplete. It doesn't clarify what 'positions' means in this context, how data is returned, or any behavioral traits, leaving significant gaps for an AI agent to use it correctly.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, but that's appropriate here. A baseline of 4 is applied since the schema fully handles the parameter aspect.

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's positions' clearly states the verb ('Get') and resource ('user's positions'), making the basic purpose understandable. However, it doesn't specify what type of positions (trading positions, job positions, etc.) or distinguish this tool from siblings like 'get_holdings' or 'get_mf_holdings', leaving room for ambiguity.

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 'get_holdings' or 'get_mf_holdings'. The description doesn't mention prerequisites, context, or exclusions, leaving the agent to infer usage from the tool name 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 full burden for behavioral disclosure. It only states the basic action ('Get quote') without mentioning permissions, rate limits, data freshness, error handling, or response format. This is inadequate for a tool with no 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 brief and front-loaded with the main purpose, followed by a parameter example. It avoids unnecessary verbosity, though the structure could be slightly improved by integrating the example more seamlessly rather than as a separate 'Args:' section.

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, no output schema, and low schema description coverage, the description is incomplete. It lacks details on return values, error cases, authentication needs, and how it fits with siblings, making it insufficient for reliable agent use in this 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 0%, so the description must compensate. It adds an example for the 'symbols' parameter (e.g., ['NSE:INFY', 'BSE:RELIANCE']), which clarifies format and provides context beyond the bare schema. However, it doesn't explain symbol conventions, limits, or other constraints, leaving gaps.

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 tool's purpose as 'Get quote for symbols', which is a clear verb+resource combination. However, it doesn't differentiate from sibling tools like 'get_historical_data' or 'get_mf_instruments', leaving ambiguity about what specifically distinguishes this quote retrieval from other data-fetching operations.

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 'get_historical_data' and 'get_mf_instruments', there's no indication of whether this is for real-time quotes, specific asset types, or other contexts, leaving usage decisions 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves a token after login redirect, but lacks details on authentication requirements, rate limits, error handling, or what happens if no token is available. This is insufficient for a tool likely involved in security-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, clear sentence with no wasted words, making it easy to parse and front-loaded with essential information. It efficiently conveys the core purpose 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?

Given the complexity of authentication tools and the lack of annotations or output schema, the description is incomplete. It doesn't explain the token's format, validity, how it's used in subsequent requests, or potential errors, leaving significant gaps for an AI agent to operate effectively in this context.

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

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

The tool has 0 parameters with 100% schema description coverage, so the schema fully documents the lack of inputs. The description adds no parameter information, which is appropriate here, but doesn't compensate for any gaps since there are none. Baseline is 4 for zero parameters as per rules.

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 target resource ('the current request token after login redirect'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'initiate_login' or 'check_and_authenticate', which are related to authentication flow, preventing a score of 5.

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

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

The description implies usage after a login redirect, but provides no explicit guidance on when to use this tool versus alternatives like 'initiate_login' or 'check_and_authenticate'. There's no mention of prerequisites, error conditions, or specific scenarios, 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?

With no annotations provided, the description carries the full burden. It discloses key behavioral traits: it opens a browser (implying user interaction) and starts a local server (implying network activity). However, it lacks details on error handling, timeouts, or what happens after the redirect, leaving gaps for a tool with potential complexity.

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 concise sentences that directly explain the tool's purpose and mechanism without any fluff. It is front-loaded with the main action and efficiently communicates the necessary steps.

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, no output schema, and 0 parameters, the description is minimal but covers the core action. However, for a login flow tool that likely involves user interaction and network operations, it lacks details on expected outcomes, error cases, or integration with sibling tools like 'check_and_authenticate', making it somewhat 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?

The tool has 0 parameters, and schema description coverage is 100% (as there are no parameters to describe). The description does not need to add parameter semantics, so a baseline of 4 is appropriate, as it efficiently avoids unnecessary details.

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

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

The description clearly states the specific action ('Start the Zerodha login flow') and the mechanism ('by opening the login URL in a browser and starting a local server to handle the redirect'). It distinguishes itself from sibling tools like 'check_and_authenticate' by focusing on initiation rather than verification or other authentication steps.

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 at the beginning of a login process, but does not explicitly state when to use this tool versus alternatives like 'check_and_authenticate' or 'get_request_token'. It provides some context (starting the flow) but lacks explicit guidance on prerequisites or 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?

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It states 'modify' implies mutation but doesn't disclose permissions needed, whether changes are reversible, rate limits, error conditions, or what happens to unspecified fields. For a 6-parameter mutation tool, 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 well-structured with a clear purpose statement followed by an 'Args:' section. Each parameter explanation is concise. However, the formatting with quotes and line breaks could be cleaner, and the purpose statement could be more front-loaded with critical context.

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 6 parameters, no annotations, and no output schema, the description is incomplete. It lacks information about what the tool returns, error handling, side effects, authentication requirements, and how partial updates work (null handling). The parameter explanations help but don't compensate for these gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It provides clear semantic meaning for all 6 parameters beyond their names, explaining what each controls (e.g., 'New amount per instalment', 'New frequency (weekly, monthly, or quarterly)'). This adds significant value over the bare 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 purpose: 'Modify a mutual fund SIP' with a specific verb ('modify') and resource ('mutual fund SIP'). It distinguishes from siblings like 'cancel_mf_sip' (termination) and 'place_mf_sip' (creation), but doesn't explicitly contrast them.

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 on when to use this tool versus alternatives like 'cancel_mf_sip' or 'place_mf_sip'. The description implies usage for updating existing SIPs but doesn't specify prerequisites, constraints, or appropriate contexts beyond the basic function.

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 only states the action ('place a mutual fund order') without disclosing behavioral traits such as whether this is a destructive/mutative operation, authentication requirements, rate limits, order execution timing, confirmation mechanisms, or error handling. For a financial transaction tool with zero annotation coverage, this is a critical 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 appropriately sized and front-loaded: the first sentence states the purpose, followed by a structured 'Args:' section. Each line is brief and relevant, with no wasted words. However, the formatting could be slightly improved for readability (e.g., bullet points instead of plain 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?

Given the complexity (financial transaction tool), lack of annotations, no output schema, and 0% schema description coverage, the description is incomplete. It doesn't cover behavioral aspects, return values, error cases, or contextual dependencies like market hours or balance requirements. For a tool that places orders, this leaves the agent with insufficient information to use it 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 0%, so the description must compensate. It lists parameters (tradingsymbol, transaction_type, amount, tag) with brief examples (e.g., 'BUY or SELL'), adding some meaning beyond the bare schema. However, it doesn't explain parameter formats (e.g., amount units, tag purpose), constraints, or dependencies, leaving significant gaps given the 4 parameters.

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: 'Place a mutual fund order' with specific parameters like trading symbol, transaction type, and amount. It distinguishes from some siblings (e.g., 'place_mf_sip' for SIP orders) but doesn't explicitly differentiate from 'place_order' (which might be for stocks/ETFs). The verb 'place' is specific, and 'mutual fund order' identifies the resource.

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 when to choose 'place_mf_order' over 'place_mf_sip' (for SIPs) or 'place_order' (possibly for other securities), nor does it specify prerequisites like authentication or account setup. Usage is implied only by the tool name and parameters.

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 ('Place') but doesn't mention whether this is a read-only or destructive operation, what permissions are required, potential costs, 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 front-loaded with the purpose in the first sentence, followed by a structured list of parameters with brief explanations. It's efficient with minimal waste, though the formatting as a bullet-like list in the 'Args:' section could be slightly more polished.

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 SIP placement tool with 7 parameters, no annotations, and no output schema, the description is moderately complete. It covers parameter semantics well but lacks behavioral context, usage guidelines, and output details, leaving gaps for an AI agent to invoke it correctly in real-world scenarios.

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

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

The description adds substantial meaning beyond the schema, which has 0% description coverage. It explains each parameter's purpose (e.g., 'tradingsymbol' with an example, 'instalments' with a minimum, 'frequency' with options, and optional parameters with context). This compensates well for the schema's lack of descriptions, though it doesn't cover all nuances like format constraints for 'tradingsymbol'.

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 mutual fund SIP') and specifies it's a Systematic Investment Plan, which distinguishes it from one-time orders. However, it doesn't explicitly differentiate from 'place_mf_order' or 'modify_mf_sip' among the sibling tools, which would require a 5.

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

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

No guidance is provided on when to use this tool versus alternatives like 'place_mf_order' for one-time investments or 'modify_mf_sip' for existing SIPs. The description lacks context about prerequisites, such as authentication or account setup, which are implied by sibling tools like 'check_and_authenticate'.

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. While 'Place an order' implies a write/mutation operation, the description doesn't disclose critical behaviors: whether this executes real trades, requires authentication, has rate limits, returns order confirmation, or what happens on failure. For a financial trading tool with zero annotation coverage, 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 appropriately sized but not optimally structured. The opening sentence states the purpose, but the parameter documentation could be better integrated. While efficient, it lacks the front-loaded clarity about what this tool fundamentally does versus siblings. Every sentence earns its place, but the structure could better guide the agent.

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

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

For a complex financial trading tool with 8 parameters, no annotations, and no output schema, the description is incomplete. It documents parameters well but misses critical context: authentication requirements, return values, error conditions, rate limits, and differentiation from sibling tools. The agent lacks sufficient information to use this tool 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?

With 0% schema description coverage, the description must compensate - and it does effectively by providing clear parameter explanations with examples for 'tradingsymbol' and enumerations for 'exchange', 'transaction_type', 'product', and 'order_type'. It clarifies conditional usage of 'price' and 'trigger_price' based on order type. This adds substantial value beyond the bare 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 action ('Place an order') and the target system ('on Zerodha'), which is a specific verb+resource combination. However, it doesn't distinguish this tool from sibling tools like 'place_mf_order' or 'place_mf_sip' - all involve placing orders but for different asset classes. The purpose is clear but lacks 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?

The description provides no guidance on when to use this tool versus alternatives like 'place_mf_order' (for mutual funds) or 'place_mf_sip'. There's no mention of prerequisites (authentication, account status), typical use cases, or constraints. The agent must infer usage from parameter names alone.

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