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 specifies the return format (Markdown table), lists the exact fields returned, mentions error handling ('Raises: Exception'), and notes parameter defaults and API fallbacks. However, it doesn't cover rate limits, authentication needs, or pagination details.

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 sections for purpose, parameters, returns, and raises. It's front-loaded with the core functionality. Some sentences could be more concise (e.g., the parameter explanations are slightly verbose), but overall it's efficient with minimal waste.

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

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

Given 5 parameters with 0% schema coverage and no output schema, the description provides strong compensation: it fully documents parameters, specifies the return format and fields, and mentions error handling. It lacks details on authentication, rate limits, or sibling tool differentiation, but for a data-fetching tool, it's largely complete.

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

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

Schema description coverage is 0%, so the description must compensate fully. It does so excellently by explaining all 5 parameters with clear semantics: symbol (trading pair examples), fromId (ID-based start), startTime/endTime (time ranges in milliseconds), and limit (range 1-1000 with default). Each parameter's purpose, format, and default behavior are explicitly documented.

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 ('Fetch aggregated trades data'), source ('from Aster Finance API'), and output format ('return as Markdown table text'). It distinguishes this tool from siblings like get_recent_trades or get_kline by focusing on aggregated trades with specific return fields.

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 get_recent_trades or get_kline. It mentions the tool's purpose but doesn't specify scenarios where aggregated trades are preferred over other data types, 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the tool's behavior: fetching data from a specific API (Aster Finance), returning formatted output (Markdown table), and handling errors (raises Exception on API failure). It also mentions default behaviors for optional parameters when None. However, it doesn't cover rate limits, authentication requirements, or data freshness.

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 and appropriately sized. It begins with the core purpose, then provides a clear parameter section with bullet-like formatting, followed by returns and raises sections. Every sentence adds value with no redundancy or fluff, making it easy to scan and understand.

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 does an excellent job covering parameters, return format, and error handling. However, for a financial data tool with 4 parameters, it could benefit from mentioning typical use cases, data latency, or rate limiting considerations to be fully complete for agent decision-making.

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

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

The schema has 0% description coverage, so the description fully compensates by providing comprehensive parameter documentation. It explains each parameter's purpose, format (e.g., 'Trading pair symbol', 'milliseconds since Unix epoch'), constraints ('1 to 1000'), default behaviors, and examples ('BTCUSDT', 'ETHUSDT'). This adds significant 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 specific action ('Fetch Funding Rate History data') and resource ('from Aster Finance API'), distinguishing it from siblings like get_latest_price or get_order_book which serve different purposes. It specifies the exact data being retrieved (funding rate history) and the output format (Markdown table).

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 (to fetch funding rate history data), but doesn't explicitly mention when not to use it or name specific alternatives among the sibling tools. It distinguishes itself by focusing on funding rates rather than prices, trades, or order books, but lacks explicit comparison 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?

With no annotations provided, the description carries full burden and does well by disclosing the return format ('Markdown table containing open_time, open, high, low, and close'), error handling ('Raises: Exception'), and API-specific defaults. It doesn't mention rate limits, authentication needs, or data freshness, but covers core behavioral aspects adequately.

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

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

The description is efficiently structured with a clear purpose statement followed by organized sections for Parameters, Returns, and Raises. Every sentence adds value—no redundancy or fluff. It's appropriately sized for a 5-parameter tool with complex semantics.

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 moderate complexity (5 parameters, no annotations, no output schema), the description provides strong coverage of purpose, parameters, returns, and errors. It doesn't explain sibling tool relationships or advanced usage scenarios, but for a data-fetching tool, it's nearly complete. The lack of output schema is mitigated by the clear return format description.

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 0% schema description coverage. It explains each parameter's purpose, provides examples ('e.g., 'BTCUSD', '1m''), clarifies case-sensitivity, defines time formats ('milliseconds since Unix epoch'), specifies value ranges ('1 to 1500'), and documents default behaviors. This fully compensates for the schema's lack of descriptions.

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

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

The description clearly states the specific action ('Fetch Index Price Kline/Candlestick data'), resource ('from Aster Finance API'), and output format ('return as Markdown table text'). It distinguishes from siblings by specifying 'Index Price' data rather than other market data types like trades, order books, or funding rates.

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 parameter explanations (e.g., 'If None, defaults to API behavior'), but doesn't explicitly state when to use this tool versus alternatives like 'get_kline' or 'get_mark_price_kline'. It provides technical guidance but lacks comparative decision-making 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 full burden. It discloses that the tool fetches from an external API and returns formatted data, mentions default behaviors for optional parameters, and notes error conditions. However, it lacks details about rate limits, authentication requirements, data freshness, or what happens when parameters are invalid beyond the generic Exception mention.

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

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

The description is well-structured with clear sections (purpose, parameters, returns, raises) and efficiently conveys necessary information. Every sentence earns its place, though the 'Raises' section could be more specific about error types. It's appropriately sized for a 5-parameter tool with no annotations.

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

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

Given the tool's moderate complexity (5 parameters, API call, data transformation) and absence of both annotations and output schema, the description does well by explaining parameters thoroughly and specifying the return format. It could improve by detailing the table structure more or mentioning performance characteristics, but it's largely complete for basic 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?

With 0% schema description coverage, the description fully compensates by providing detailed semantics for all 5 parameters. Each parameter gets clear explanations with examples (e.g., 'BTCUSDT', '1m'), optionality indications, value ranges ('1 to 1500'), and default behaviors. 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 tool's purpose with specific verb ('Fetch') and resource ('Kline/Candlestick data from Aster Finance API'), and distinguishes it from siblings by specifying it returns data as a Markdown table. It's not a tautology and provides concrete details about what the tool does.

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

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

The description provides no guidance on when to use this tool versus the 10 sibling tools listed. While it mentions what the tool does, it doesn't indicate scenarios where this specific Kline data fetching would be preferred over alternatives like get_latest_price, get_order_book, or other Kline variants (get_index_price_kline, get_mark_price_kline).

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 API source and error conditions ('Raises: Exception'), which is helpful. However, it doesn't disclose important behavioral traits like rate limits, authentication requirements, response time expectations, or what happens when the symbol parameter is null (though this is covered in parameter semantics).

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

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

The description is efficiently structured with clear sections (purpose, parameters, returns, raises). Every sentence earns its place by providing essential information. The front-loaded purpose statement immediately communicates the tool's function without unnecessary preamble.

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

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

For a single-parameter tool with no annotations and no output schema, the description provides good coverage of purpose, parameters, and basic error handling. It could be more complete by explaining the structure of the returned Markdown table or providing more detail about error conditions, but it's substantially complete for this level of complexity.

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

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

The schema description coverage is 0%, so the description must fully compensate. It provides excellent parameter semantics: explains the symbol parameter is optional, provides examples ('BTCUSDT', 'ETHUSDT'), specifies case-insensitivity, and clearly states the behavior when None (returns data for all symbols). This adds substantial value beyond what the bare schema provides.

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

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

The description clearly states the specific action ('Fetch latest price data'), source ('from Aster Finance API'), and output format ('return as Markdown table text'). It distinguishes this tool from its siblings by focusing specifically on price data rather than trades, order books, or other market metrics.

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 about when to use this tool (for fetching price data) and implicitly distinguishes it from siblings that handle different data types like trades, order books, or statistics. However, it doesn't explicitly state when NOT to use it or name specific alternative tools for related purposes.

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: the tool fetches from an external API (Aster Finance), returns data in Markdown table format, includes error handling ('Raises: Exception'), and specifies default behaviors for optional parameters. It lacks details on rate limits, authentication needs, or data freshness.

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

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

The description is well-structured with clear sections (purpose, parameters, returns, raises) and uses bullet points for readability. It is appropriately sized but could be slightly more concise by integrating the purpose statement with parameter details.

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

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

For a tool with 5 parameters, no annotations, and no output schema, the description is quite complete: it covers purpose, all parameters with semantics, return format, and error handling. It lacks sibling differentiation and some behavioral details (e.g., rate limits), but overall provides sufficient context 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?

Schema description coverage is 0%, so the description fully compensates by providing clear semantics for all 5 parameters: explains each parameter's purpose, gives examples (e.g., 'BTCUSDT', '1m'), specifies optional/default behaviors, and defines valid ranges (e.g., 'limit' from 1 to 1500). This adds significant 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 specific action ('Fetch Mark Price Kline/Candlestick data'), resource ('from Aster Finance API'), and output format ('return as Markdown table text'). It distinguishes this tool from siblings like 'get_kline' (likely spot price) and 'get_index_price_kline' by specifying 'Mark Price' 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 implies usage through parameter explanations (e.g., 'symbol' for trading pairs, 'interval' for timeframes) but does not explicitly state when to use this tool versus alternatives like 'get_kline' or 'get_index_price_kline'. No guidance on prerequisites or exclusions is provided.

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

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

With no annotations provided, the description carries full burden and does well by disclosing: the API source (Aster Finance), output format (Markdown table), error conditions (API failures or processing errors), and default behavior (limit defaults to 100). It doesn't mention authentication requirements, rate limits, or whether this is a real-time or cached data source.

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

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

The description is efficiently structured with a clear purpose statement followed by well-organized sections for Parameters, Returns, and Raises. Every sentence adds value with no redundancy or unnecessary information.

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

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

For a 2-parameter tool with no annotations and no output schema, the description provides good coverage of what the tool does, parameters, return format, and error conditions. It could be more complete by mentioning authentication requirements, rate limits, or data freshness, but covers the essential aspects well given the 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?

With 0% schema description coverage, the description fully compensates by providing detailed parameter information: symbol meaning (trading pair with examples), limit options (specific enumerated values 5-5000), default behavior (100 if None), and case-insensitivity for symbol. This adds significant 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 specific action ('Fetch order book data'), resource ('from Aster Finance API'), and output format ('return as Markdown table text'). It distinguishes this tool from sibling tools like get_latest_price or get_recent_trades by focusing on order book depth data rather than price quotes or trade history.

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

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

The description implies usage for obtaining order book data but doesn't explicitly state when to use this tool versus alternatives like get_order_book_ticker (which might provide summary data) or get_latest_price (for single price points). No guidance is given about prerequisites, rate limits, or specific 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?

With no annotations provided, the description carries full burden and does well by disclosing: the data source (Aster Finance API), output format (Markdown table), specific fields returned, error conditions (API request failures or data processing errors), and parameter behavior (case-insensitive symbol, optional with default). It doesn't mention rate limits, authentication needs, or data freshness.

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?

Perfectly structured with clear sections: purpose statement, parameters explanation, returns specification, and error conditions. Every sentence earns its place with no redundancy. The description is appropriately sized for a single-parameter tool with rich behavioral 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 tool with 1 parameter, 0% schema coverage, no annotations, and no output schema, the description provides excellent coverage: purpose, parameters, returns, and errors. It doesn't explain the structure of the Markdown table or provide example output, but given the tool's relative simplicity, this is a minor gap.

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

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

Schema description coverage is 0%, so the description must fully compensate. It provides excellent parameter semantics: explains the symbol parameter is optional, provides examples ('BTCUSDT', 'ETHUSDT'), specifies case-insensitivity, and clarifies the behavior when None (returns data for all symbols). This adds substantial meaning 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 specific action ('Fetch order book ticker data'), source ('from Aster Finance API'), and output format ('return as Markdown table text'). It distinguishes this tool from siblings by focusing on order book ticker data rather than trades, prices, or other market data types.

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

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

The description implies usage through the parameter explanation (fetch data for a specific symbol or all symbols), but doesn't explicitly state when to use this tool versus alternatives like get_order_book (which might provide full depth data) or get_latest_price (which provides different price information). No explicit guidance on use cases or exclusions is provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions API request failures and data processing errors in the 'Raises' section, which adds useful context about potential errors. However, it doesn't cover other behavioral aspects like rate limits, authentication requirements, or whether this is a read-only operation.

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

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

The description is perfectly structured and concise: a clear purpose statement followed by well-organized sections for Parameters, Returns, and Raises. Every sentence earns its place by providing 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?

For a single-parameter tool with no output schema, the description provides excellent coverage of purpose, parameters, return format, and error conditions. The only gap is the lack of annotations, which means some behavioral aspects (like rate limits or authentication) remain unspecified, preventing a perfect score.

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

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

The schema description coverage is 0%, so the description must fully compensate. It provides excellent parameter semantics: explains the 'symbol' parameter is optional, gives examples ('BTCUSDT', 'ETHUSDT'), specifies case-insensitivity, and describes the behavior when None (returns all symbols). 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 specific action ('Fetch Premium Index data'), source ('from Aster Finance API'), and output format ('return as Markdown table text'). It distinguishes this tool from siblings like get_funding_rate_history or get_mark_price_kline by focusing on current premium index data rather than historical or price 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 clear context for when to use this tool (to fetch premium index data in markdown format) and implies when not to use it (e.g., for historical data or different formats). However, it doesn't explicitly name alternative tools or state exclusion criteria, 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 and does well by disclosing the return format (Markdown table), specific fields included, error behavior (raises Exception on API failure), and the case-insensitive nature of the symbol parameter. It doesn't mention rate limits, authentication needs, or data freshness, leaving some 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 efficiently structured with a clear purpose statement followed by organized sections for Parameters, Returns, and Raises. Each sentence adds value without redundancy, making it easy to scan 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?

For a tool with no annotations, no output schema, and low schema coverage, the description does an excellent job covering purpose, parameters, return format, and error handling. It could improve by mentioning data latency or API-specific constraints, but it's largely complete for the given complexity.

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

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

The description adds significant meaning beyond the input schema, which has 0% description coverage. It explains the symbol parameter's purpose (trading pair), provides examples ('BTCUSDT', 'ETHUSDT'), clarifies case-insensitivity, and describes the effect when None (returns all symbols). This fully compensates for the schema's lack of 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 'fetch' and the resource '24-hour ticker price change statistics from Aster Finance API', specifying the exact data source and time frame. It distinguishes from siblings by focusing on price change statistics rather than trades, klines, order books, or other market data types.

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

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

The description provides clear context for when to use this tool (to get 24-hour price change statistics) but doesn't explicitly mention when not to use it or name specific alternatives among the sibling tools. The parameter description implies usage for single symbols vs. all symbols, which offers some 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?

With no annotations provided, the description carries full burden and does well by disclosing key behaviors: it specifies the return format (Markdown table), error handling ('Raises: Exception'), and API constraints (case-insensitive symbol, limit range 1-1000, default 500). However, it doesn't mention rate limits, authentication needs, or data freshness.

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

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

The description is efficiently structured with clear sections (purpose, parameters, returns, raises), uses bullet-like formatting without markdown, and every sentence adds value. It's front-loaded with the core purpose and avoids 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 no annotations, no output schema, and 2 parameters, the description is mostly complete: it covers purpose, parameters, returns, and errors. However, it lacks details on authentication, rate limits, or pagination, which are relevant for API tools. The absence of an output schema is compensated by describing the return format.

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 significant value beyond the schema, which has 0% coverage. It explains both parameters thoroughly: symbol meaning ('Trading pair symbol'), examples ('BTCUSDT', 'ETHUSDT'), and case-insensitivity; limit meaning ('Number of trades to return'), range ('1 to 1000'), default behavior ('If None, defaults to 500'), and optionality.

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 ('Fetch recent trades data'), source ('from Aster Finance API'), and output format ('return as Markdown table text'). It distinguishes this tool from siblings like get_aggregated_trades or get_order_book by focusing on raw trade data rather than aggregated or order book 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 implies usage through parameter explanations (e.g., 'Trading pair symbol'), but lacks explicit guidance on when to use this tool versus alternatives like get_aggregated_trades. It mentions the API source but doesn't specify scenarios where recent trades are preferred over other data types.

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