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

Annotations already provide readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true, covering safety and idempotency. The description adds value by explaining the data's purpose ('gauging sentiment among margin traders'), which is useful context beyond annotations. It doesn't contradict annotations (e.g., it doesn't imply destructive actions), and it adds behavioral insight without redundancy. However, it doesn't detail rate limits or specific auth needs, so it's not a full 5.

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 core purpose, followed by a clarifying sentence and examples. Every sentence earns its place by adding useful information without waste. It's structured for quick comprehension and avoids unnecessary details.

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

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

Given the tool's low complexity (1 parameter, no nested objects), rich annotations (covering read-only, idempotent, etc.), and the presence of an output schema (which handles return values), the description is largely complete. It explains what the tool does and why, with examples. However, it could be more explicit about sibling differentiation or edge cases, but for this context, it's sufficient.

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

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

The input schema has 100% description coverage, with the 'symbol' parameter clearly documented. The description adds minimal semantics beyond the schema: it provides examples ('BTC', 'ETH') that reinforce the schema's description, but doesn't explain format constraints or additional meaning. With high schema coverage, the baseline is 3, and the examples offer slight enhancement without significant added value.

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

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

The description clearly states the tool's purpose: 'Get Bitfinex margin long/short data' and 'Shows margin positions on Bitfinex exchange.' It specifies the verb ('Get') and resource ('Bitfinex margin long/short data'), distinguishing it from siblings like 'coinglass_funding_current' or 'coinglass_spot' by focusing on margin positions. However, it doesn't explicitly differentiate from 'coinglass_long_short' (which might be similar), so it's not a perfect 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 provides implied usage context: 'Useful for gauging sentiment among margin traders' and examples for BTC and ETH. This gives a general idea of when to use it, but it doesn't explicitly state when not to use it or name alternatives among siblings (e.g., vs. 'coinglass_long_short'). No exclusions or clear comparisons are provided, so it's adequate but not comprehensive.

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

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

Annotations already indicate read-only, non-destructive, and idempotent behavior. The description adds value by explaining the tool's utility ('understanding available options and current limits') and providing examples of specific actions, which helps the agent understand the scope and practical applications beyond the basic safety hints. No contradiction with annotations.

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

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

The description is well-structured and front-loaded: purpose statement, usage context, and examples. Every sentence earns its place without redundancy. It's appropriately sized for a simple tool with one parameter.

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

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

Given the tool's low complexity (1 parameter), rich annotations (read-only, idempotent), 100% schema coverage, and presence of an output schema, the description is complete enough. It covers purpose, usage, and examples, aligning well with the structured data without needing to explain return values or behavioral details already provided elsewhere.

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

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

Schema description coverage is 100%, with the 'action' parameter fully documented via enum and descriptions. The description adds minimal semantics by listing examples (e.g., 'List exchanges: action="exchanges"'), but this mostly repeats schema info. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose as 'Get CoinGlass configuration and metadata' with a specific verb ('Get') and resource ('CoinGlass configuration and metadata'). It distinguishes from siblings by focusing on configuration/metadata rather than market data, funding, or other specific metrics, though it doesn't explicitly contrast with each sibling tool.

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

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

The description provides clear context for usage: 'Useful for understanding available options and current limits.' It implies when to use this tool (for configuration/metadata queries) versus alternatives (siblings focused on market data, funding, etc.), but doesn't explicitly name alternatives or state when not to use it.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true. The description adds useful context about institutional flow interpretation (positive/bullish, negative/bearish) which isn't captured in annotations, but doesn't disclose rate limits, authentication needs, or detailed behavioral traits beyond the basic 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: purpose statement first, key context second, then practical examples. Every sentence earns its place with zero waste. The bullet points and examples are organized for quick scanning while maintaining complete information.

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

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

Given the comprehensive annotations (read-only, non-destructive, idempotent), 100% schema coverage, and existence of an output schema, the description provides exactly what's needed: clear purpose, usage context, and practical examples. No additional explanation of return values or safety concerns is necessary.

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

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

With 100% schema description coverage, the schema already documents all 6 parameters thoroughly. The description provides examples showing how parameters combine (e.g., action='list' with asset='bitcoin'), which adds some practical context, but doesn't significantly enhance the semantic understanding beyond what's in the schema.

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

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

The description clearly states 'Get crypto ETF data (Bitcoin & Ethereum)' with specific verb+resource, then elaborates on tracking institutional flows. It distinguishes from siblings by focusing exclusively on ETF data, unlike other tools for funding, market data, or on-chain 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 for when to use this tool ('Track institutional flows through ETFs') and includes examples for different actions. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the sibling tools for similar data.

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

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

The description adds valuable behavioral context beyond what annotations provide. While annotations indicate read-only, open-world, idempotent, and non-destructive operations, the description clarifies the three specific data types returned (rates, accumulated, arbitrage) and provides concrete examples of usage patterns. This enhances understanding of what the tool actually returns and how to use it.

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 bullet points explaining the three data types and concrete examples. Every sentence serves a purpose, though the bullet points could be slightly more concise. The information is front-loaded with the core purpose first.

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

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

Given the tool's moderate complexity, comprehensive annotations, complete schema coverage, and presence of an output schema, the description provides adequate context. It explains what data types are available and gives usage examples, which complements the structured data well. The main gap is lack of explicit differentiation from sibling tools.

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

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

With 100% schema description coverage, the input schema already fully documents both parameters. The description adds minimal value by repeating the three action options in bullet points and providing usage examples, but doesn't add significant semantic information beyond what's already in the schema descriptions.

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

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

The description clearly states the tool's purpose: 'Get current funding rate data across exchanges.' It specifies the verb ('Get') and resource ('current funding rate data'), but doesn't explicitly differentiate it from sibling tools like 'coinglass_funding_history' beyond the 'current' vs 'history' distinction in their names.

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 implied usage guidance through examples that show how to use different actions, but it doesn't explicitly state when to use this tool versus alternatives like 'coinglass_funding_history' for historical data or other sibling tools. The examples help illustrate parameter usage but don't provide comparative context.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true, covering the safety and idempotency profile. The description adds useful context about what funding rates represent and their sentiment implications, which helps the agent understand the domain semantics. However, it doesn't mention rate limits, authentication requirements, or pagination behavior beyond the 'limit' parameter documented in the schema.

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

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

The description is efficiently structured with clear sections: purpose statement, domain explanation, parameter guidance, and examples. Every sentence adds value - the funding rate explanation provides necessary domain context, and the examples directly help with parameter selection. No wasted words or redundant information.

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

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

Given the tool's complexity (6 parameters, multiple actions), the description provides good context about what funding rates are and how to use different actions. With annotations covering safety/idempotency and an output schema existing, the description doesn't need to explain return values. The main gap is lack of explicit guidance on when to choose this tool over alternatives like 'coinglass_funding_current'.

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

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

With 100% schema description coverage, the input schema already documents all 6 parameters thoroughly. The description adds value by explaining the relationship between actions and parameters through the 'Required params by action' section and concrete examples, but doesn't provide additional syntax or format details beyond what's in the schema descriptions. This meets the baseline for high schema coverage.

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

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

The description starts with a specific verb ('Get') and resource ('funding rate OHLC history'), clearly stating what the tool does. It distinguishes from sibling tools like 'coinglass_funding_current' by focusing on historical data rather than current rates. The explanation of funding rates adds domain context that helps differentiate this tool's purpose.

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

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

The description provides clear context for when to use this tool through the 'Required params by action' section and examples, showing how different actions correspond to different parameter combinations. However, it doesn't explicitly state when NOT to use this tool or mention alternatives like 'coinglass_funding_current' for current rates versus historical data.

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

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

Annotations already indicate read-only, non-destructive, idempotent, and open-world behavior, so the description does not need to repeat these. It adds value by explaining the meaning of Grayscale premium/discount (bullish/bearish sentiment), which is useful context beyond annotations. However, it lacks details on rate limits, error handling, 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 concise, with no wasted words. It starts with the core purpose, adds explanatory context, and provides actionable examples. Each sentence adds value, 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?

Given the tool's moderate complexity, rich annotations (covering safety and behavior), and the presence of an output schema, the description is complete enough. It explains the tool's purpose, provides usage context with examples, and adds semantic meaning to the data, compensating well for any gaps without needing to detail return values or technical behaviors.

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

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

Schema description coverage is 100%, so the schema fully documents parameters. The description adds semantic context by explaining what Grayscale data represents and providing examples that illustrate parameter combinations (e.g., action='premium', fund='GBTC', range='90d'). This enhances understanding beyond the schema's technical definitions.

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 Grayscale fund data.' It specifies the verb ('Get') and resource ('Grayscale fund data'), and distinguishes it from siblings by focusing on Grayscale-specific data, unlike other tools for funding rates, market data, or options. The examples further clarify the scope.

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

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

The description provides clear context for when to use the tool by explaining the significance of Grayscale premium/discount as an institutional sentiment indicator. It includes examples that illustrate usage scenarios (e.g., action='holdings' or 'premium'). However, it does not explicitly state when not to use it or name specific alternatives among siblings, such as for non-Grayscale ETF data.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true, covering safety and idempotency. The description adds valuable context about indicator-specific behaviors (e.g., BTC-only limitations, symbol/exchange requirements for borrow_rate, and examples of action usage), which enhances understanding beyond annotations.

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

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

The description is well-structured with a clear purpose statement, bullet points for key indicators, and practical examples. It's appropriately sized without unnecessary fluff, though the examples could be slightly more integrated into the 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 with 6 parameters, rich annotations (read-only, idempotent, open-world), and the presence of an output schema, the description is complete. It covers purpose, usage nuances, and behavioral context without needing to explain return values or repeat structured information.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters. The description adds some semantic context by explaining that 'Most indicators are BTC-only' and 'borrow_rate requires symbol + exchange,' but doesn't provide additional details beyond what's in the schema descriptions. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose as 'Get market indicators and on-chain metrics' with specific examples of indicators like fear_greed, rainbow, and pi_cycle. It distinguishes itself from sibling tools by focusing on indicators rather than funding, liquidation, or market data, though it doesn't explicitly name alternatives.

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

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

The description provides clear context for when to use specific actions, such as 'Most indicators are BTC-only. rsi returns all coins. borrow_rate requires symbol + exchange.' and includes examples for different scenarios. However, it doesn't explicitly state when NOT to use this tool versus sibling 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?

Annotations already provide readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true. The description adds useful context about plan requirements ('Requires Professional+ plan') which isn't covered by annotations, but doesn't provide additional behavioral details like rate limits, authentication needs, or what specific data formats are returned. No contradiction with annotations exists.

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

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

The description is well-structured and appropriately sized with three sentences plus an example. The first sentence states the purpose, the second explains the utility, the third notes plan requirements, and the example demonstrates usage. Every sentence earns its place, though the example could be slightly more concise.

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

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

Given the tool's moderate complexity (6 parameters, 1 required), rich annotations, 100% schema coverage, and existence of an output schema, the description is reasonably complete. It covers purpose, utility, and plan requirements. With the output schema handling return values, the description doesn't need to explain response format, making it adequately complete for 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?

With 100% schema description coverage, the input schema already documents all 6 parameters thoroughly with descriptions, enums, and defaults. The description provides an example showing parameter usage but doesn't add significant semantic meaning beyond what's already in the schema. The baseline of 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose with specific verbs ('Get liquidation heatmap/map visualization data') and resource ('heatmap/map'). It distinguishes from siblings by focusing specifically on liquidation heatmaps and leverage distribution maps, unlike other tools for funding rates, market data, or on-chain analytics.

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 ('Useful for identifying potential support/resistance and cascade zones') and includes a note about plan requirements ('Requires Professional+ plan'). However, it doesn't explicitly state when NOT to use it or name specific alternative tools from the sibling list for different types of data.

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

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

Annotations already declare this as read-only, non-destructive, idempotent, and open-world, so the description doesn't need to repeat those safety aspects. However, it adds valuable context about what liquidation data represents ('Liquidations occur when a trader's position is forcibly closed...') and its analytical significance ('Large liquidation clusters can indicate support/resistance'), which helps the agent understand the data's meaning beyond just retrieval.

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, explanatory context, and practical examples. Every sentence adds value, though the explanatory paragraph about liquidations could be slightly more concise. The examples are particularly effective for showing usage patterns.

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 comprehensive annotations (read-only, non-destructive, etc.), 100% schema coverage, and presence of an output schema, the description provides adequate context. It explains what the data represents and gives usage examples, which complements the structured metadata well for this data 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?

With 100% schema description coverage, the schema already documents all 6 parameters thoroughly. The description adds minimal parameter semantics beyond the schema - it provides example configurations that illustrate how parameters combine, but doesn't explain parameter meanings or relationships that aren't already in the schema descriptions.

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

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

The description clearly states the tool's purpose as 'Get liquidation history data' with a brief explanation of what liquidations are. It specifies the resource (liquidation history) and verb (get), but doesn't explicitly differentiate from sibling tools like 'coinglass_liq_heatmap' or 'coinglass_liq_orders' that also handle liquidation 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 usage context through examples that show when to use different action values (e.g., 'BTC liquidations: action="aggregated", symbol="BTC"'). It effectively demonstrates how to parameterize the tool for different scenarios, though it doesn't explicitly mention when to choose this tool over sibling liquidation tools.

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

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

Annotations cover key traits (read-only, non-destructive, idempotent, open-world), but the description adds valuable context: it specifies the tool returns 'recent liquidation orders as they happen' (implying a streaming or near-real-time behavior), notes a plan requirement, and provides usage examples. This enhances understanding beyond the annotations without contradiction.

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

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

The description is front-loaded with the core purpose, followed by usage context, a note on requirements, and concise examples. Every sentence adds value without redundancy, making it efficient and well-structured for quick comprehension.

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

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

Given the tool's moderate complexity, rich annotations (read-only, idempotent, etc.), 100% schema coverage, and the presence of an output schema, the description is complete. It covers purpose, usage, prerequisites, and examples, leaving detailed parameter and output information to the structured fields.

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

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

Schema description coverage is 100%, so the schema fully documents parameters (symbol, side, limit). The description adds minimal semantics through examples (e.g., 'BTC longs only'), but does not provide additional meaning or constraints beyond what the schema already specifies, aligning with the baseline for high coverage.

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

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

The description clearly states the tool's purpose with specific verbs ('Get real-time liquidation orders stream') and resource ('liquidation orders'). It distinguishes from siblings like 'coinglass_liq_heatmap' and 'coinglass_liq_history' by emphasizing real-time streaming rather than historical or aggregated 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 ('monitoring market stress and potential cascade liquidations') and mentions a prerequisite ('Requires Standard+ plan'). However, it does not explicitly state when not to use it or name specific alternatives among siblings, such as when historical data is needed instead.

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

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

The description adds valuable behavioral context beyond annotations. While annotations already indicate read-only, non-destructive, idempotent operations, the description explains what the data represents (market sentiment interpretation) and provides concrete examples of parameter usage. It doesn't mention rate limits or authentication requirements, but with comprehensive annotations covering safety profile, this is acceptable.

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 front-loaded with the core purpose, followed by interpretation guidance, action options, and a concrete example. Every sentence earns its place by adding distinct value - no redundancy or wasted words. The bullet-point format for actions and sentiment interpretation enhances readability.

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, comprehensive annotations (readOnlyHint, idempotentHint, etc.), 100% schema coverage, and existence of an output schema, the description provides complete contextual information. It explains what the data means, how to interpret it, available actions, and includes a working example - everything needed for effective tool selection and 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?

With 100% schema description coverage, the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema - it lists the four action options and provides one example, but doesn't explain parameter interactions or provide additional semantic context. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose: 'Get long/short ratio data' with a specific verb ('Get') and resource ('long/short ratio data'). It distinguishes from siblings by focusing on this specific metric rather than other crypto data types like funding rates, options, or on-chain data. The explanation of market sentiment (ratio >1 bullish, <1 bearish) further clarifies what the data represents.

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 different actions (global, top_accounts, top_positions, taker_ratio) and includes a concrete example showing exchange, pair, and action parameters. However, it doesn't explicitly state when NOT to use this tool versus alternatives like coinglass_taker or coinglass_oi_history, which might provide overlapping data.

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

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

The description adds valuable behavioral context beyond annotations: 'Data is updated frequently (30 second cache)' provides crucial timing information. Annotations already cover safety (readOnlyHint=true, destructiveHint=false) and idempotency, but the description enhances this with real-time characteristics. No contradiction with annotations exists.

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

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

The description is efficiently structured: purpose statement, key metrics, behavioral note, parameter requirement, and concrete examples. Every sentence adds value with zero waste. The information is front-loaded with the core purpose first.

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

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

Given the tool's moderate complexity, comprehensive annotations (readOnlyHint, idempotentHint, etc.), 100% schema coverage, and presence of an output schema, the description provides complete contextual information. It covers purpose, usage guidance, behavioral characteristics, and examples without needing to explain return values.

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

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

With 100% schema description coverage, the schema already fully documents both parameters. The description adds minimal value: it mentions 'coins_summary requires symbol parameter' which is already in the schema, and provides examples that illustrate parameter usage. This meets the baseline of 3 when schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'Get real-time market data summaries from CoinGlass' with specific metrics listed (price, open interest, volume, funding rates). It distinguishes from siblings by focusing on aggregated market metrics rather than specialized data like funding history or liquidation heatmaps. However, it doesn't explicitly contrast with all 23 sibling tools, keeping it at a 4 rather than 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?

The description provides explicit guidance on when to use specific actions: 'coins_summary requires symbol parameter' with examples showing different use cases (BTC metrics, all pairs, price changes). It clearly indicates parameter requirements and distinguishes between the three action types, giving the agent concrete decision criteria.

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

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

The description adds valuable behavioral context beyond annotations: it specifies that data is 'relatively static and cached for 5 minutes' and provides concrete examples of different query patterns. While annotations already indicate read-only, open-world, idempotent, and non-destructive behavior, the description enhances understanding of data freshness and usage patterns without contradicting annotations.

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

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

The description is efficiently structured: a clear purpose statement, important behavioral context about data caching, and specific examples showing different use cases. Every sentence adds value without redundancy, and the information is front-loaded with the most important details first.

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

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

Given the tool's moderate complexity, comprehensive annotations (read-only, open-world, idempotent), 100% schema coverage, and the presence of an output schema, the description provides complete context. It covers purpose, behavioral characteristics, and usage examples, making it fully adequate for an AI agent to understand and use this tool correctly.

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

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

With 100% schema description coverage, the input schema already fully documents both parameters. The description provides examples showing how parameters combine (e.g., action='pairs' with exchange='Binance'), which adds some practical context, but doesn't significantly expand on the schema's parameter documentation.

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

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

The description clearly states the tool's purpose: 'Get static market metadata from CoinGlass' with specific resources (coins, trading pairs, exchanges). It distinguishes from siblings by focusing on static metadata rather than dynamic data like funding rates, price history, or on-chain metrics found in other tools.

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

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

The description provides clear context for when to use this tool: for static market metadata that's cached for 5 minutes. It includes examples showing different use cases. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the sibling tools for dynamic data needs.

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

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

Annotations already indicate read-only, non-destructive, idempotent, and open-world behavior, so the bar is lower. The description adds valuable context by explaining that 'The bid/ask ratio can indicate buying or selling pressure,' which provides insight into the tool's analytical utility beyond just data retrieval. It doesn't contradict annotations, and while it could mention rate limits or auth needs, it adds meaningful behavioral insight.

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 front-loaded with the core purpose, followed by explanatory context and practical examples. Every sentence adds value: the first states the action, the second explains significance, and the examples illustrate usage. There's no wasted text, making it efficient and easy to parse.

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

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

Given the tool's complexity (7 parameters, multiple actions) and rich annotations (read-only, etc.), the description is reasonably complete. It covers the purpose, usage hints, and examples. Since an output schema exists, it doesn't need to explain return values. However, it could be more complete by addressing when to use this over sibling tools or detailing parameter interactions more explicitly.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly (e.g., action types, symbol usage, interval options). The description adds minimal parameter semantics beyond the schema—it mentions 'pair_depth' and 'coin_depth' in examples but doesn't explain their differences or other parameters like 'interval' or 'range' in more detail. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose: 'Get order book depth history' and 'Shows historical bid/ask depth at various price levels.' It specifies the resource (order book depth history) and the action (get/show). However, it doesn't explicitly differentiate from sibling tools like 'coinglass_ob_large_orders' or 'coinglass_liq_heatmap' that might also relate to order book data, 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 implied usage through examples (e.g., 'BTC depth on Binance' vs. 'Aggregated BTC depth'), which helps understand when to use different actions. However, it lacks explicit guidance on when to choose this tool over siblings (e.g., vs. 'coinglass_ob_large_orders' for large orders or 'coinglass_liq_heatmap' for liquidity heatmaps), and doesn't mention prerequisites or exclusions, so it's not fully comprehensive.

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

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

The description adds valuable behavioral context beyond what annotations provide. While annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true, the description adds specific threshold information ('BTC >= $1M, ETH >= $500K, others >= $50K') that defines what constitutes 'large' orders. This quantitative threshold disclosure is important behavioral information not captured in annotations. No contradiction with annotations exists.

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

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

The description is exceptionally concise and well-structured. It uses only 4 sentences: the first states the core purpose, the second adds threshold context, and the last two provide clear usage examples. Every sentence earns its place with zero wasted words. The information is front-loaded with the most important details first.

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

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

Given the tool's moderate complexity, comprehensive annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint), 100% schema coverage, and the presence of an output schema, the description is complete enough. It covers the tool's purpose, quantitative thresholds, and usage examples. With annotations handling safety/behavioral guarantees and the output schema presumably documenting return values, the description focuses appropriately on what's not captured elsewhere.

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

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

With 100% schema description coverage, the input schema already documents all 4 parameters thoroughly. The description adds minimal parameter semantics beyond the schema - it only provides examples for the 'action' parameter values. While helpful, this doesn't significantly enhance understanding of parameters like 'exchange', 'pair', or 'limit' beyond what the schema already provides. The baseline of 3 is appropriate given the comprehensive schema coverage.

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

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

The description clearly states the tool's purpose: 'Get large limit orders (whale walls)' with specific verb ('Get') and resource ('large limit orders'). It distinguishes from siblings by specifying this tool focuses on order book large orders rather than other crypto data like funding rates, liquidations, or market data. The description adds context about detecting support/resistance levels, which further clarifies its unique analytical purpose.

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

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

The description provides clear context about when to use this tool through the action parameter examples ('Current whale walls: action="current"' and 'Historical large orders: action="history"'). However, it doesn't explicitly state when NOT to use this tool or mention specific alternatives among the sibling tools (like coinglass_ob_history for general order book history or coinglass_whale_positions for different whale data). The guidance is helpful but lacks explicit exclusion criteria.

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

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

Annotations already provide strong behavioral hints (readOnlyHint=true, destructiveHint=false, idempotentHint=true, openWorldHint=true), covering safety and idempotency. The description adds value by explaining the tool's utility ('understanding market concentration and finding arbitrage opportunities'), but does not disclose additional behavioral traits like rate limits, authentication needs, or data freshness beyond what annotations imply.

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

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

The description is front-loaded with the core purpose, followed by utility context and specific examples. Every sentence earns its place: the first states the action, the second explains use cases, and the examples illustrate parameter usage without redundancy. It is appropriately sized for a tool with clear parameters and 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, rich annotations (covering safety and idempotency), 100% schema coverage, and the presence of an output schema (which handles return values), the description is complete enough. It provides purpose, usage context, and examples, leaving no critical gaps for an AI agent to understand and invoke the tool correctly.

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

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

Schema description coverage is 100%, with clear descriptions for all parameters (action, symbol, range). The description adds minimal semantic context through examples (e.g., 'BTC OI by exchange'), but does not provide additional meaning beyond what the schema already documents, such as explaining the significance of 'by_exchange' vs 'exchange_chart' in market analysis.

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

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

The description clearly states the tool's purpose with specific verbs ('Get Open Interest distribution') and resources ('across exchanges'), distinguishing it from siblings like 'coinglass_oi_history' (historical OI trends) or 'coinglass_market_data' (general market data). It specifies the exact data type (OI distribution) and scope (exchange-level), making its function unambiguous.

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

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

The description provides clear context for when to use the tool ('useful for understanding market concentration and finding arbitrage opportunities'), but does not explicitly state when not to use it or name specific alternatives among siblings. While it implies usage for OI analysis, it lacks direct comparison to tools like 'coinglass_oi_history' for temporal trends or 'coinglass_long_short' for position ratios.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true. The description adds useful context about what Open Interest represents and its market interpretation (bullish/bearish signals), but doesn't mention rate limits, authentication needs, or data freshness. With comprehensive annotations, this adds moderate value.

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 purpose statement, conceptual explanation, parameter guidance, and examples. Every sentence serves a purpose, though the conceptual explanation of Open Interest interpretation could be considered slightly verbose for a pure tool description.

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

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

Given comprehensive annotations (readOnly, idempotent, non-destructive), 100% schema coverage, and the existence of an output schema, the description provides complete contextual information. It explains the tool's purpose, usage patterns, and includes practical examples without needing to cover return values.

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

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

Schema description coverage is 100%, so the schema already fully documents all 6 parameters. The description adds minimal value by mentioning required params by action and providing examples, but doesn't explain parameter semantics beyond what's in the schema. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the verb 'Get' and resource 'Open Interest OHLC history', specifying it's for historical data. It distinguishes from siblings like coinglass_oi_distribution (distribution data) and coinglass_funding_history (funding rate history) by focusing on OHLC format open interest 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 provides explicit guidance on when to use different actions with concrete examples: 'pair' for single exchange pairs, 'aggregated' for all exchanges combined, and other actions for specific margin types. It clearly distinguishes usage scenarios with parameter requirements.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true, so the agent knows this is a safe, read-only operation. The description adds useful context about interpreting exchange balance trends (bullish/bearish implications), which goes beyond the annotations. 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: a clear purpose statement, bullet points explaining what to track, and specific examples. Every sentence earns its place by providing either conceptual context or practical usage guidance 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 rich annotations (covering safety and idempotency), 100% schema coverage, and the presence of an output schema (not shown but indicated in context signals), the description provides complete contextual information. It explains the tool's purpose, usage context, and provides examples without needing to duplicate structured data.

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

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

Schema description coverage is 100%, so the schema already documents all 6 parameters thoroughly. The description provides examples that illustrate how parameters combine (e.g., action='balance_chart' with asset='BTC' and exchange='Binance'), adding some practical context beyond the schema's individual parameter descriptions.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('on-chain exchange data'), then elaborates on what can be tracked. It distinguishes this tool from siblings by focusing on exchange holdings and flows, unlike other tools that handle funding, liquidation, options, etc.

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

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

The description provides clear context for when to use the tool (tracking exchange holdings and flows) and includes examples that illustrate different use cases. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the sibling tools.

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

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

Annotations already provide key behavioral hints (readOnlyHint: true, destructiveHint: false, etc.), so the bar is lower. The description adds value by specifying data sources (Deribit, OKX, Binance, Bybit) and explaining concepts like 'max pain' and 'put/call ratio,' which aren't covered in annotations. However, it doesn't mention rate limits, auth needs, or other operational details, keeping it from a perfect score.

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, starting with the core purpose, adding explanatory context, and ending with examples. Every sentence adds value, but it could be slightly more front-loaded by placing examples after the purpose for quicker scanning. No wasted content, but minor structural improvements are possible.

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 (3 parameters, 100% schema coverage, annotations, and output schema exists), the description is mostly complete. It covers purpose, sources, and examples, but lacks details on output format or error handling, which the output schema might address. For a data-fetching tool with good annotations, this is sufficient but not exhaustive.

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

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

Schema description coverage is 100%, with clear descriptions for each parameter (e.g., action enum values explained, symbol limited to BTC/ETH, range as time range). The description adds minimal semantics beyond this, such as examples linking actions to symbols, but doesn't provide additional syntax or format details. Baseline 3 is appropriate given the schema's comprehensive coverage.

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

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

The description clearly states the tool's purpose: 'Get options market data from Deribit, OKX, Binance, Bybit.' It specifies the verb ('Get'), resource ('options market data'), and sources, which is specific and actionable. However, it doesn't explicitly differentiate from sibling tools like 'coinglass_oi_history' or 'coinglass_oi_distribution' that might also handle options-related data, missing full sibling distinction.

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

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

The description provides implied usage through examples (e.g., 'BTC max pain: action="max_pain", symbol="BTC"') and context about what options data helps understand, but it lacks explicit guidance on when to use this tool versus alternatives. No when-not-to-use or direct sibling comparisons are included, leaving usage somewhat inferred rather than clearly defined.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true. The description adds valuable behavioral context beyond annotations: the plan requirement for smaller intervals (m1, m5, m15) and the specific data structure returned (candlestick data with timestamp, open, high, low, close, volume).

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 starts with the core purpose, adds return format and usage context, includes an important note about plan requirements, and provides concrete examples. Every sentence earns its place with no wasted words.

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

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

Given the comprehensive annotations (readOnly, idempotent, non-destructive), 100% schema coverage, and the presence of an output schema, the description provides complete context. It covers purpose, usage, behavioral constraints (plan requirements), and includes helpful examples without needing to explain return values or safety aspects already covered by annotations.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal parameter semantics beyond the schema - it provides examples showing how parameters combine but doesn't explain parameter meanings or constraints beyond what's in the schema descriptions.

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

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

The description clearly states the tool's purpose with specific verb ('Get') and resource ('historical OHLC price data for a specific trading pair'). It distinguishes from sibling tools by focusing on price history rather than funding, liquidation, 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 ('Useful for technical analysis and charting') and includes a note about plan requirements for smaller intervals. However, it doesn't explicitly mention when NOT to use it or name specific alternatives among the sibling tools.

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

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

The description adds valuable context beyond annotations: it explains that the tool returns 'matching tools with their available actions,' clarifying the output structure. Annotations already indicate it's read-only, non-destructive, idempotent, and closed-world, so the description doesn't need to repeat these. No contradictions exist; it complements annotations by detailing the search functionality and result format.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by usage guidance and examples. Every sentence adds value: the first defines the tool, the second specifies when to use it, the third describes the return, and the examples illustrate practical queries. It's efficiently structured 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 low complexity (1 parameter), rich annotations (readOnlyHint, etc.), and the presence of an output schema (implied by context signals), the description is complete. It covers purpose, usage, and output behavior adequately, without needing to detail parameters or safety aspects already handled by structured data.

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

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

Schema description coverage is 100%, with the parameter 'query' well-documented in the schema as 'Search query (e.g., 'liquidation BTC', 'funding arbitrage').' The description adds minimal extra semantics through examples (e.g., 'query="liquidation"'), but doesn't provide significant additional meaning beyond the schema. This meets the baseline of 3 for high schema coverage.

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

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

The description clearly states the tool's purpose: 'Search available CoinGlass operations' to 'discover which tool and action to use for your task.' It specifies the verb ('search') and resource ('CoinGlass operations'), and distinguishes itself from sibling tools by focusing on discovery rather than executing specific operations like 'funding_current' or 'liq_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 explicitly states when to use this tool: 'Use this to discover which tool and action to use for your task.' It provides clear examples (e.g., 'Find liquidation tools: query="liquidation"'), guiding users to employ it for exploration before selecting a specific sibling tool, effectively differentiating its role from direct data-fetching tools.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true. The description adds value by specifying the scope ('spot market data') and providing concrete examples of different actions and their required parameters (like exchange and pair for price_history). It doesn't contradict annotations and provides useful operational context.

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

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

The description is well-structured and front-loaded with the core purpose. It uses bullet points for examples that efficiently demonstrate different use cases without unnecessary elaboration. Every sentence serves a clear purpose in explaining the tool's functionality.

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

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

Given the rich annotations (readOnlyHint, idempotentHint, etc.), 100% schema coverage, and presence of an output schema, the description provides adequate context. It covers the main use cases with examples and specifies the data domain. A 5 would require explicit sibling differentiation or more detailed behavioral context beyond what annotations already provide.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema - it mentions 'action' values in examples but doesn't provide additional semantic context. The baseline of 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'Get spot market data' with specific examples of what it provides (supported coins, trading pairs, market summaries, historical prices). It distinguishes from siblings by focusing on spot market data specifically, though it doesn't explicitly contrast with other tools like 'coinglass_market_data' or 'coinglass_price_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 provides implied usage through examples that show different actions and their parameters. However, it doesn't explicitly state when to use this tool versus alternatives like 'coinglass_market_data' or 'coinglass_price_history' from the sibling list. The examples help but lack explicit guidance on tool selection.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true, covering safety and idempotency. The description adds context about what taker volume measures and how to interpret buy ratios (bullish/bearish signals), which is useful behavioral information not captured in annotations. 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 well-structured and appropriately sized. It starts with the core purpose, explains what taker volume represents, and provides concrete examples. Every sentence adds value, though the bullish/bearish explanation could be slightly more concise. The formatting with bullet points and examples is clear.

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 (7 parameters, multiple actions), the description provides good context about what the tool returns (taker volume data with buy ratio interpretation). With annotations covering safety aspects and an output schema presumably defining the return structure, the description focuses appropriately on the tool's purpose and usage patterns rather than repeating structured information.

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

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

With 100% schema description coverage, the schema already documents all 7 parameters thoroughly. The description adds minimal parameter semantics beyond the schema - it only provides examples linking 'action' and 'symbol' parameters to specific use cases. This meets the baseline expectation when schema coverage is complete.

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 taker buy/sell volume data.' It specifies the exact resource (taker volume data) and verb (get), and distinguishes it from siblings by focusing on taker volume rather than other metrics like funding, open interest, or liquidation data. The explanation of what taker volume represents adds valuable context.

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 usage context through examples that map action parameters to specific use cases (BTC taker volume, by exchange). It implicitly suggests when to use different actions but doesn't explicitly state when to choose this tool over sibling alternatives like coinglass_market_data or coinglass_spot, which might also provide volume-related data.

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

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

The description adds valuable behavioral context beyond what annotations provide: it discloses the requirement for a 'Startup+ plan' (an access constraint not covered by annotations) and provides practical examples of different action types. Annotations already cover read-only, non-destructive, idempotent, and open-world characteristics, so the description appropriately supplements rather than contradicts them.

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

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

The description is well-structured and efficient: it starts with the core purpose, adds usage context, includes an important note about plan requirements, and provides concrete examples. Every 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?

Given the tool's moderate complexity (4 parameters, one required), rich annotations, 100% schema coverage, and the presence of an output schema, the description provides good contextual coverage. It explains the tool's purpose, usage context, access requirements, and provides examples. The main gap is lack of explicit differentiation from sibling tools, but overall it's quite complete for its 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 100% schema description coverage, the input schema already thoroughly documents all parameters. The description provides examples that illustrate parameter usage (e.g., 'action="positions", symbol="BTC"'), but doesn't add significant semantic meaning beyond what's in the schema descriptions. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose: 'Track whale activity on Hyperliquid. Monitor large traders' positions and activity.' It specifies the resource (whale activity/positions) and the platform (Hyperliquid). However, it doesn't explicitly differentiate from sibling tools like 'coinglass_long_short' or 'coinglass_oi_distribution' that might also track market activity, so it doesn't reach the highest 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 clear context for when to use this tool: 'Useful for following smart money and identifying potential market moves.' It also includes examples that illustrate different use cases (alerts, positions, all_positions). However, it doesn't explicitly state when NOT to use it or name specific alternatives among the many sibling tools, preventing a perfect score.

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