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

Despite no annotations, the description fully discloses behavior: it notes cache may serve stale data up to TTL, counters are cumulative since process start, and provides detailed return structure. No contradictions.

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?

Well-structured with a brief line, bulleted usage cases, and a clear dict description. Every sentence adds value, no fluff.

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

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

For a zero-parameter tool with output schema, the description fully covers purpose, usage, behavior, and return format. It is self-contained and 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?

No parameters in input schema (baseline 4). Description does not need to explain parameters but adds value by detailing the output structure, which is not covered by 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 it returns HTTP-cache statistics with specific verb 'Return' and resource 'current HTTP-cache statistics'. It distinguishes from siblings like clear_cache.

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?

Explicit 'Reach for this when' bullet points list three scenarios, guiding when to use this tool over alternatives, e.g., when debugging rate-limit errors or checking cache utilization.

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

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

Discloses full effect (drops all entries, preserves counters, returns count). Without annotations, description carries burden; it adequately covers main behaviors. Minor omission: no mention of permissions or performance implications, but given simplicity, still strong.

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?

Efficiently structured: purpose, usage guidelines, caution, return format. Every sentence earns its place; no fluff. Front-loaded with core action.

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?

Fully covers tool behavior, when to use, and return format. Given 0 parameters and presence of output schema, no missing information. Context regarding sibling tools (cache_stats) is implied.

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?

No parameters in schema, so description adds value by explaining output format and tool purpose. Baseline for 0 params is 4; description also provides output schema in prose.

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?

Explicitly states 'Drop every entry from the HTTP cache' with specific verb and resource. Emphasizes it resets ALL endpoints, distinguishing it from siblings like cache_stats and other data-fetching 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?

Provides explicit 'Reach for this when' criteria with two clear scenarios (explicit user request, suspected stale data). Advises preferring natural TTL expiry, giving clear boundaries on when not to use.

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

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

No annotations provided, so description carries full burden. Discloses that failed branches return error inline, explains spread_bps computation, and warns about BitMEX linear symbol errors. Missing explicit mention of rate limits or authentication, but otherwise thorough.

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?

Well-structured with bold summary, use cases, symbol details, arguments, and return format. Every sentence adds value; slightly lengthy but appropriate for the complexity.

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

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

Given no output schema and 2 simple parameters, description covers all aspects: arguments, failure behavior, return fields. Complete for the tool's complexity.

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

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

Input schema has 0% description coverage. Description adds essential meaning: symbol convention (CCXT unified perp), default values, exchange_ids format (comma-separated), and notes about BitMEX. Also describes return structure, fully compensating for schema gaps.

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

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

Clearly states verb 'compare' and resource 'funding rates'. Explicitly distinguishes from siblings: 'For a single exchange snapshot use get_funding_rate; for historical trend on one venue use get_funding_rate_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?

Provides explicit when-to-use (arbitrage opportunities, lopsided positioning) and when-not-to (single exchange, historical). Includes examples of expected behavior for specific exchanges like BitMEX.

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, description fully discloses behavior: parallel fan-out to CoinGecko, CCXT per exchange, DexScreener; per-coin mapping; error handling; return structure including max/min/spread. No contradictions.

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?

Well-structured with clear sections, but slightly verbose (lists exchanges and coin mapping in prose). Front-loaded with purpose, but could trim some redundant detail.

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?

Comprehensive coverage: input/output description, source details, edge cases (unknown coin_ids), and output schema exists for return values. No gaps for effective agent understanding.

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

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

Schema coverage is 0%, but description explains all three parameters: coin_id (CoinGecko ID), vs_currency (quote currency with special handling), exchange_ids (comma-separated CCXT IDs). Adds defaults and usage details beyond schema.

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

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

Description clearly states the tool fetches prices from many sources concurrently and compares them. It explicitly differentiates from siblings like `get_price` (single source) and `compare_funding_rates` (perp funding).

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?

Explicit usage guidance: cross-source sanity checks, finding divergences, arbitrage spotting. Contrasts with sibling tools and explains conditions (e.g., DexScreener only for 'usd'), enabling appropriate 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?

Despite no annotations, the description fully discloses behavioral traits: no data fetching, returns observations only, input bounds (5000 rows), volume handling, series truncation, and default indicator set. No contradictions.

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 and front-loaded purpose, but is quite verbose. Could be slightly more concise while retaining completeness.

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

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

Given the tool's complexity (15 parameters, no output schema), the description is remarkably complete: covers input restrictions, output shape for every indicator, limitations, and edge cases like missing volume or series truncation.

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 coverage, the description explains every parameter in detail: ohlcv format and ordering, indicator list with defaults, all period parameters with defaults, and include_series behavior including truncation.

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 computes technical indicators on provided OHLCV data, and distinguishes it from data-fetching sibling tools like get_exchange_ohlcv and get_aggregated_ohlc.

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?

Explicitly provides 'USE THIS WHEN' clause and directs to sibling tools for data fetching, with clear when-to-use and when-not-to-use guidance.

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

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

With no annotations, the description carries full burden and does well by disclosing that it returns most-liquid pairs first, up to 30 per call from DexScreener, and specifies error handling ('On API failure returns {"error": "..."}'). Missing mentions of rate limits or auth, but overall transparent.

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 first sentence, usage condition, and then Args/Returns sections. It is appropriately detailed but could be slightly more concise; still, every sentence adds value.

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

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

Given no output schema, the description lists all return fields. It covers purpose, usage, parameters, and return format thoroughly. For a search tool with two parameters, it is fully contextual and leaves no major gaps.

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

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

Schema description coverage is 0%, but the description adds rich meaning: query parameter is free-text with examples, and limit parameter explains it's after sorting by liquidity with range 1-30. This exceeds what the schema alone 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 tool searches DEX pairs across all chains by token name, symbol, or address, using a specific verb and resource. It distinguishes from siblings like get_price and get_token_dex_price by noting it returns DEX-side/on-chain prices and most-liquid pairs first.

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: when the token is too new or small for CoinGecko (get_price returns empty) or when the user wants DEX-side/on-chain prices. This provides clear guidance and differentiation from 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?

No annotations provided, but description explains candle width auto-selection based on days parameter and return format. Lacks details on error handling or rate limits, but covers main behavioral traits sufficiently.

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?

Well-structured with clear sections, front-loaded purpose, and concise sentences. Every sentence adds value without repetition.

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?

Comprehensive given no output schema and three parameters: explains purpose, usage, parameter details, return format, and validation. Sufficient for an AI agent to invoke 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 0%, so description compensates by explaining all three parameters: coin_id validation pattern, vs_currency example, and days with mapping to candle widths. Could add more detail on vs_currency.

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?

Clearly states it gets aggregated OHLC candlestick data across all exchanges, with specific verb and resource. Distinguishes from sibling get_exchange_ohlcv for per-exchange 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?

Explicitly advises use for technical-analysis-style views of the market rather than a single venue, and directs to get_exchange_ohlcv for per-exchange high-granularity candles.

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

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

Discloses return format (array of {date, tvl}) and parameter behavior (empty chain for total). Without annotations, description covers key aspects but lacks info on caching or rate limits.

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?

Concise with clear Args/Returns sections, no redundant information. Every sentence adds value.

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

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

Complete for a simple tool: explains return format, all parameters with defaults and constraints, and references a sibling tool. No output schema, but description fills the 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?

Adds substantial meaning beyond schema: chain empty for combined TVL, days range 1-3650, default 90, and regex validation. Schema coverage is 0%, but description fully compensates.

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?

Clearly states the tool retrieves historical TVL for one chain or all DeFi combined, with specific verb 'Get' and resource 'historical total DeFi TVL'. Distinguishes from sibling 'get_global_defi' by noting it complements that 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?

Provides explicit usage examples ('Ethereum TVL over the last year') and contrasts with 'get_global_defi' (only current number). Also specifies parameter constraints like chain validation and days range.

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

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

No annotations are provided, so the description carries full burden. It comprehensively details the return object fields and notes coin_id validation via regex. Though it does not explicitly state read-only nature, the return-focused description implies no side effects. The level of detail is high, but a slight omission of safety traits like 'does not modify data' prevents a 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 well-structured with clear sections: purpose, usage guidelines, parameter details, return description, validation note. It is slightly long but each part adds value. Could be tightened by merging the initial purpose with the usage context, but current structure aids 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 has 6 parameters, no output schema, and many sibling tools, the description is quite complete. It explains all parameters, defines when to use alternatives, and outlines return fields. Lacks mention of rate limits or pagination, but those may be less critical for a single-entity retrieval tool. The validation note adds extra completeness.

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

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

Schema description coverage is 0%, meaning no descriptions in the schema itself. The description compensates fully by explaining each parameter: format example for coin_id, purpose of localization ('Usually false to keep responses small'), tickers warning ('large'), and scope of market_data, community_data, developer_data. This adds substantial meaning beyond the schema's bare names and defaults.

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 'Get rich metadata for a single coin: description, links, scores, market data, dev/community stats,' which clearly identifies the verb ('Get') and resource ('rich metadata for a single coin'), and lists specific data categories. It also distinguishes from sibling tools like get_price and get_coin_tickers, making purpose unambiguous.

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

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

Explicitly states when to use: 'when the user wants to learn about a coin... or when you need scores like CoinGecko rank, sentiment up/down vote percentages, or developer activity.' Provides clear exclusion: 'For just the price, use get_price (much cheaper)' and for tickers: 'Use get_coin_tickers instead.' This offers concrete 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?

Describes return data (price, volume, spread, etc.), pagination, and ordering, but no annotations are provided so some behavioral aspects like rate limits are missing.

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?

Succinct top line, followed by usage examples, structured args/returns/note. No 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?

Covers all parameters, return structure, and validation note. No output schema, but description provides sufficient context for an agent.

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

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

Despite 0% schema coverage, the description explains every parameter, including default values, validation, and relationship to other tools.

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

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

Clearly states it lists exchange tickers for a single coin across many venues, with specific use cases and data included.

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

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

Provides clear when-to-use guidance with example questions, but does not explicitly mention when not to use or 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?

Without annotations, the description fully outlines return structure (total_holdings, total_value_usd, market_cap_dominance, companies array with fields), and notes limitation to Bitcoin and Ethereum. No behavioral contradictions.

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?

Description is brief, front-loaded with purpose, and every sentence (including Args/Returns) provides essential information without redundancy or filler.

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

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

Given the single parameter with enum and no output schema, the description fully covers usage, parameter, and return structure, leaving no gaps for the agent.

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

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

Despite 0% schema coverage, the Args section explains coin_id's allowed values (bitcoin/ethereum) and the reasoning (only assets tracked), adding meaning beyond the enum and default 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?

Description clearly states the tool retrieves public companies' BTC/ETH treasury holdings with specific examples ('which companies own BTC?', 'MicroStrategy stack'), and differentiates from siblings which cover prices, markets, exchanges, 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?

Provides concrete use cases (tracking institutional adoption) and implies applicability to Bitcoin/Ethereum treasury queries. No explicit when-not or alternatives given, but the examples make usage clear.

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

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

No annotations provided, so the description bears full responsibility. It discloses that the tool fetches in parallel, caps exchange_ids at 10, clamps depth to [1,50], does not aggregate by price level, and details the return structure including error handling for failed exchanges. This is comprehensive.

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 fairly long but well-structured with a purpose statement, usage hint, args block, and returns block. Every sentence adds value. Minor redundancy (explicitly listing args in a separate block) but overall efficient for the tool's complexity.

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

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

Covers all aspects: purpose, when to use, parameter details, return format, error handling. Given the tool's parallelism and merging logic, the description provides enough context for correct selection and invocation. Output schema exists, so return details are appropriate.

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

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

Schema description coverage is 0%, so the description must compensate. It explains each parameter: symbol (CCXT unified format, example), exchange_ids (comma-separated, capped at 10, default), depth (levels per side, clamped, default). This adds meaning beyond the schema's defaults and types.

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?

Describes the tool as fetching L2 order books from multiple exchanges in parallel and merging them into one virtual book. It explicitly differentiates from the sibling tool `get_orderbook` by stating it is 'more useful than per-venue get_orderbook for execution analysis', and explains that the merged book retains source exchange information for liquidity attribution.

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?

Clearly states the use case: answering 'where is the best bid/ask across the whole market'. It contrasts with `get_orderbook` and provides guidance on when to use this tool instead. Also mentions that some exchanges may reject the symbol, handling errors in `exchanges_error`.

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

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

No annotations provided, so the description carries full burden. It details the return value structure, including sub-objects and error cases, and notes input validation. It does not discuss rate limits or authentication, but for a read operation these are acceptable omissions.

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 intro, Args, and Returns sections. It is concise yet complete, with every sentence adding value. Front-loaded with purpose.

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

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

For a simple two-parameter tool with no annotations or output schema, the description covers all necessary aspects: purpose, usage context, parameter details, return format (including error cases), and validation. It is self-contained and comprehensive.

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

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

Schema coverage is 0%, but the description compensates thoroughly: it explains chain_id with typical values and pair_address with case-insensitivity, and mentions validation regex patterns. This adds significant meaning beyond the schema.

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

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

The description clearly states the tool gets full details for a single DEX pair on a specific chain, with explicit mention of what information is included (tx counts, price changes, liquidity). It distinguishes itself from siblings like dex_search and get_dex_token_pairs by indicating it is for a single pair.

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 says 'Use after dex_search / get_dex_token_pairs when the user wants the full picture for one specific market', providing clear guidance on when to invoke this tool. It does not mention when not to use it, but the context is sufficient.

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

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

No annotations provided, but description discloses key behaviors: returns sorted by USD liquidity, validates token address, returns error on API failure. Could mention rate limits or data freshness, but sufficient for a read 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?

Well-structured: purpose upfront, then usage, then param details, return format, validation note. Every sentence adds value; front-loaded with core function.

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

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

Covers purpose, usage, parameters, return format, error handling, and validation. No output schema or annotations, but description is fully self-contained for a tool with 3 parameters.

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%, but description explains all three parameters with examples and allowed values (limit range, chain common values). Adds significant meaning beyond schema.

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

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

Clearly states the tool gets all DEX pairs for a given token contract across chains. Uses specific verb 'Get' and resource 'DEX pairs'. Distinguishes from siblings like dex_search and get_price in usage guidelines.

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?

Explicitly recommends using this over dex_search when contract address is known, and get_price for large CEX-listed tokens. Provides clear when-to-use and when-not-to-use context.

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

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

No annotations are provided, so the description carries the full burden. It discloses that exchange_id is validated against a regex pattern and describes the returned object fields (name, year_established, country, description, url, image, trust score, volume metrics, tickers array). This is comprehensive, though it does not mention rate limits or authentication.

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

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

The description is very concise, with a clear one-sentence summary followed by structured Args and Returns sections. Every sentence adds value, and there is no redundancy or fluff.

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

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

Given the tool's simplicity (1 param, no output schema), the description fully covers purpose, parameter semantics, and return values. It is complete enough for an agent to use the tool correctly without additional information.

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

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

The schema has 0% description coverage, but the description fully explains the exchange_id parameter: its meaning (CoinGecko exchange ID), examples (binance, gdax, kraken), how to discover valid IDs (list_exchanges_directory), and a note about differing IDs. It also provides a validation regex. This adds immense value beyond the schema.

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

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

The description clearly states 'Get detailed info on a single exchange (CoinGecko directory): description, links, volume, top tickers.' It specifies the action (get detailed info), the resource (single exchange), and the source (CoinGecko directory). This distinguishes it from sibling tools like get_exchange_markets and list_exchanges_directory.

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 tells the agent how to find the exchange_id: 'See list_exchanges_directory to discover IDs.' It also warns about CoinGecko IDs differing from CCXT IDs. This provides clear context for when to use the tool, though it does not explicitly mention when not to use it or alternative 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?

With no annotations, the description carries the full burden. It explains the effect of active_only parameter and details the return structure including fields like symbol, base, quote, settle, type, etc. This is transparent for a listing tool, though it omits potential authentication or rate limit implications.

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 concise and well-structured: purpose sentence, usage example, Args section with both parameters explained, and Returns section with object shape. No redundant information, and front-loaded with the core purpose.

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

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

Given the tool's low complexity, no output schema (but return described fully), and absence of annotations, the description is complete. It covers purpose, parameters, return type, and usage context, leaving no critical gaps for an agent to invoke it correctly.

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

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

Input schema defines two parameters (exchange_id, active_only). The description adds significant value: for exchange_id, it specifies 'CCXT exchange ID (lowercase)' and refers to list_supported_exchanges; for active_only, it explains 'If true, exclude delisted/inactive markets.' This goes well beyond the schema.

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

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

The description clearly states the verb 'List' and resource 'trading pairs (markets) supported by a specific exchange.' It distinguishes from siblings like get_exchange_info (exchange metadata) and get_exchange_ticker (ticker prices) by focusing on market list discovery.

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

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

The description provides explicit usage context: 'Use to discover what symbols an exchange trades... or to enumerate available perpetual contracts.' It also references list_supported_exchanges for valid exchange IDs. However, it does not explicitly state when not to use this tool or compare to alternatives like get_exchange_ticker.

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

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

No annotations are provided, so the description carries full burden. It discloses that not every exchange supports every timeframe, and typical limit caps (500-1500 candles). It also describes the return format. However, it omits rate limits or potential cost of the call.

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

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

The description is front-loaded with the main purpose, followed by usage guidance, then parameter descriptions, and finally return format. Every sentence is informative, and the structure is logical and efficient.

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

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

Given the absence of annotations and output schema, the description thoroughly covers purpose, usage guidelines, parameter semantics, and return format. It provides sufficient information for an agent to select and invoke the tool correctly.

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

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

Despite 0% schema description coverage, the description explains each parameter in detail: exchange_id as CCXT exchange ID, symbol as unified format, timeframe with common safe choices, limit with typical caps, and since_ms behavior when null. This adds significant 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 tool retrieves OHLCV candlestick data from a specific exchange, noting high granularity including 1-minute candles. It distinguishes itself from the sibling tool `get_aggregated_ohlc` by specifying its use for a single venue and sub-hour timeframes.

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 lists conditions for preferring this tool over `get_aggregated_ohlc`: when the user asks about a specific venue, needs sub-hour candles, or requires exact volume on one exchange. This provides clear when-to-use and when-not-to-use guidance.

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

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

No annotations are provided, so the description carries the full burden. While it mentions 'real-time' and the return fields, it lacks disclosure of behavioral traits such as rate limits, data source reliability, authentication requirements, or what happens if the exchange is unavailable. This is insufficient for an unannotated tool.

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

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

The description is extremely concise: a single-sentence purpose, followed by a usage guideline, then parameter details, and a returns list. Every sentence provides essential information with no redundancy or filler. Well-structured and front-loaded.

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 simplicity (2 parameters, no output schema), the description is complete: purpose, usage, parameter semantics, and return fields are all covered. The return fields list compensates for the lack of output schema, and the context signals indicate no nested objects or enums, so no additional explanation is needed.

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

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

With 0% schema description coverage, the description adds crucial semantic information for both parameters: 'exchange_id' is explained as a CCXT ID with an example, and 'symbol' is described as a CCXT unified symbol with multiple examples including linear perpetual formats. This far exceeds the minimal schema titles.

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', the resource 'real-time ticker', and specifies the scope 'one symbol on one exchange'. It distinguishes from siblings by mentioning 'specific venue' and giving examples like 'BTC on Coinbase', which helps the agent select this tool over aggregated or multi-exchange 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 explicitly provides usage context: 'Use when the user asks about price on a specific venue' and includes examples. However, it does not explicitly mention when not to use the tool or list alternative siblings, though the guidance is clear and sufficient for most 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?

The description explains the index as a contrarian indicator, details the components (volatility, momentum, etc.), and specifies that higher values mean greedier. With no annotations, it provides sufficient behavioral context.

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

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

The description is structured with a clear purpose statement, context, and Args/Returns sections. It is efficient but slightly longer than necessary; still, every sentence adds value.

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

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

Given the simplicity (one parameter, no output schema), the description fully covers usage, parameter semantics, and return format, including field details and interpretation. No gaps.

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

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

Despite 0% schema description coverage, the description's Args section thoroughly explains the 'limit' parameter, including defaults and special value (0 = all history), adding meaning beyond the schema's type and default.

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

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

The description clearly states the tool retrieves the Crypto Fear & Greed Index, defines the 0-100 scale, and distinguishes it from sibling tools by focusing on a specific sentiment indicator.

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 suggests use for 'are people fearful or greedy right now?' questions, indicating appropriate context. It does not explicitly exclude cases or mention alternatives, but the guidance is clear.

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 explains the funding rate concept and notes that return fields vary by exchange, adding some transparency. However, without annotations, it fails to disclose rate limits, authentication requirements, or potential side effects (though the tool is clearly read-only). The behavioral disclosure is adequate but not comprehensive.

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 brief summary, explanatory context, and explicit Args/Returns sections. It is front-loaded and contains no filler, though the funding rate explanation could be slightly condensed. Overall efficient and 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?

Despite lacking an output schema, the description lists return fields and notes variability. The two required parameters are fully described with examples. The tool is relatively simple, and the description provides sufficient context for correct invocation, though missing potential error handling or usage constraints.

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 compensates for the schema's 0% coverage by providing concrete examples for exchange_id ('binance', 'okx', 'bybit', 'bitmex') and symbol ('BTC/USDT:USDT', 'BTC/USD:BTC'), adding meaning beyond the bare string type. This guides the agent effectively on parameter values.

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 clear verb+resource phrase 'Get the current funding rate for a perpetual-futures contract on a specific exchange,' which immediately distinguishes it from sibling tools like get_funding_rate_history (historical) and compare_funding_rates (comparison). The context about funding rate further clarifies the tool's domain.

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 current rate but does not explicitly state when to use alternatives like get_funding_rate_history for historical data or compare_funding_rates for cross-exchange comparison. No exclusions or prerequisites are mentioned, leaving the agent to infer usage boundaries.

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

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

No annotations are provided, so the description fully bears the burden. It discloses varying funding intervals, timestamp behavior, default window, limit clamping, return format (oldest-first), and error handling on unsupported exchanges. No contradictions with annotations.

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

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

The description is well-structured and front-loaded with purpose, but it is slightly verbose with extensive examples in the exchange_id parameter list. Every sentence adds value, but a bit more conciseness could improve it.

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 4 parameters, no output schema, and moderate complexity, the description is comprehensive: covers usage context, parameter details, return fields, cadence caveats, and error responses. No significant gaps remain.

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

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

The input schema has 0% description coverage, but the description compensates fully: it lists specific exchange IDs, explains symbol format with settle suffix examples, describes `since_ms` as optional unix-millis lower bound with default behavior, and notes `limit` clamping to [1,1000] with default 100.

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

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

The description clearly states it retrieves historical funding-rate time-series for a perpetual contract on one exchange. It distinguishes itself from siblings `get_funding_rate` (single snapshot) and `compare_funding_rates` (cross-exchange current rate), providing specific verb and resource.

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

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

The description explicitly specifies when to use (trend analysis, spotting cycles, quant signal) and when not (use `get_funding_rate` for single snapshot, use `compare_funding_rates` for cross-exchange current rate). It also warns about varying funding intervals by venue, offering clear guidance on when to avoid this tool.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool returns an object with specific fields, implying a read-only operation. However, it does not mention data freshness, authentication requirements, or any potential rate limits, leaving gaps in behavioral context.

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

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

The description is mostly concise, with two paragraphs: purpose and return fields, then usage guidelines. It includes a separate 'Returns:' section that repeats some information, which is slightly redundant but enhances clarity. Overall, it is well-structured and informative.

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

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

Given no parameters, no output schema, and no annotations, the description covers the tool's purpose, return data, and usage context sufficiently. It distinguishes from siblings and lists all return fields, making it nearly complete for its simple nature.

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 zero parameters (100% coverage), so no parameter description is needed. The description adds value by listing return fields, which compensates for the lack of an output schema. Baseline for 0 params is 4.

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

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

The description clearly states the tool retrieves global DeFi market stats, listing specific data points like total market cap, DeFi-to-Eth ratio, and top coin by share. The verb 'Get' and resource 'global DeFi market stats' are explicit, and it distinguishes from sibling tools by referencing alternatives for granular 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 explicit when-to-use guidance and names alternative tools (get_protocol_tvl and list_chains_tvl) for more granular protocol or chain-level breakdowns, helping an agent decide when not to use this tool.

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

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

No annotations provided, so description carries full burden. It describes the return structure in detail and implies a read-only operation. No contradictions or missing behavioral traits.

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?

Well-structured with bullet points and example questions. Slightly verbose but each sentence adds value. 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 no output schema, description fully explains return fields. No annotations but description compensates completely. Tool is simple (no params) and description is 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?

No parameters defined, so schema coverage is 100%. Description adds meaning beyond schema by detailing the structure of the returned data object.

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

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

Description clearly states the tool gets global cryptocurrency market stats, listing specific fields like total market cap and BTC/ETH dominance. It distinguishes from sibling tools by focusing on macro-level 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?

Provides example use cases ('macro questions') but does not explicitly state when not to use or mention alternatives. However, the context is clear enough for an agent to decide.

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?

Despite no annotations, the description discloses granularity auto-selection logic based on `days`, parameter validation regex, and return format. This compensates for missing annotations and provides essential behavioral context.

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

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

The description is well-organized with sections, bulleted granularity table, and clear parameter explanations. It is slightly verbose with the regex note but remains efficient and front-loads the purpose. Good structure overall.

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?

Without an output schema, the description explains the return structure (object with three arrays of [unix_ms, value] pairs). It covers granularity, parameters, and typical use cases. Minor omissions (e.g., error handling) do not detract from overall completeness for this simple 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 0% schema description coverage, the description fully compensates by explaining each parameter: `coin_id` (with example and regex), `vs_currency` (with examples), `days` (with valid values including 'max'), and `interval` (with enum options). 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 'Get historical price, market cap and total volume time series for a coin,' which is a specific verb+resource combination. It also explicitly distinguishes itself from sibling `get_aggregated_ohlc` by directing users to that tool for candlestick 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 advises using the tool for 'line charts or compute returns/volatility' and provides an alternative for OHLC data. While it lacks explicit 'when not to use' statements beyond the alternative, the context is clear enough for correct 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?

No annotations provided, so description must cover behavioral aspects. It details return fields and validation of nft_id, but does not mention error behavior or side effects. Adequate but not thorough.

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?

Well-structured with a one-line summary, explicit Args/Returns sections, and a Note. Every sentence adds value, no fluff.

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

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

For a simple read tool with one parameter and no output schema, the description covers the purpose, parameter details, and return contents completely. No missing 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 coverage is 0%, but description fully explains the nft_id parameter: what it represents, examples, how to find valid IDs, and regex validation. Adds substantial meaning beyond the schema.

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

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

Clearly states it gets detailed data for a single NFT collection, listing specific metrics like floor price and market cap. Distinguishes from sibling tools like list_nfts (multiple) and get_coin_details (coins).

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?

Recommends using search or list_nfts to find the nft_id. Does not explicitly state when not to use it, but the guidance for ID discovery is helpful.

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

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

With no annotations, the description discloses fallback behavior to fetch_open_interest_history, explains the return object format, and mentions error handling for unsupported exchanges. This adds significant behavioral context beyond just the tool name.

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: definition, interpretive guideline, fallback note, parameter docs, return description. It is slightly long but each sentence adds value, and the structure is logical.

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 output schema, the description covers return fields, fallback, and error handling. It is complete enough for an agent to invoke correctly without additional context.

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

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

Schema coverage is 0%, but the description explains each parameter: exchange_id as 'CCXT exchange ID supporting perps' and symbol with example suffix. It also details the return object structure, compensating for the lack of schema details.

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

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

The description starts with a clear verb+resource: 'Get the current open interest (OI) for a perpetual contract on one exchange.' It distinguishes itself from sibling tools like get_funding_rate and get_funding_rate_history by explicitly mentioning them as alternatives for funding-rate 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 interpretive guidance on reading OI with price action and explicitly names alternative tools for funding-rate context. It lacks explicit when-not-to-use guidance but the context is clear.

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

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

No annotations are provided, so the description must disclose behavioral traits. It mentions it's a snapshot (not a stream), but does not explicitly state it's a read-only operation, any authentication requirements, rate limits, or side effects. This is a significant gap.

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

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

The description is concise and well-structured: a brief summary, usage note, parameter documentation, and return format. Every sentence adds value with no 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 output schema and no annotations, the description covers the return structure, parameter details, and purpose. It lacks error handling or edge-case behavior, but is otherwise comprehensive for a snapshot 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 0% schema description coverage, the description adds essential context for all three parameters: explains exchange_id as CCXT ID, symbol with example, and limit with default and behavior across exchanges. 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 verb 'Get' and the resource 'Level-2 order-book snapshot', specifies it's from a specific exchange, and lists use cases. It distinguishes from sibling 'get_consolidated_orderbook' by clarifying it's per exchange.

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 gives usage context ('assess liquidity, spread, short-term supply/demand') and notes it's a snapshot, not a stream. However, it does not provide explicit when-not-to-use guidance or compare to alternatives like get_consolidated_orderbook.

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

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

With no annotations, the description carries full burden. It describes the return structure and notes that coin IDs are not ticker symbols. It does not mention rate limits, pagination, or error behavior, but provides sufficient behavioral clarity for a simple lookup tool.

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

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

Well-structured with a clear purpose, usage note, parameter list, and return description. Slightly verbose but each sentence adds value; front-loaded with key 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?

Covers all parameters and return structure, including optional flags. Lacks mention of response size or rate limits, but is complete enough for typical usage given no output schema.

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

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

Schema description coverage is 0%, so description must compensate. It explains each parameter in detail (coin_ids, vs_currencies, optional flags) with examples and a critical note about coin IDs not being ticker symbols.

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?

Clearly states it gets current spot price of one or more cryptocurrencies. Distinguishes from sibling tools by specifying it's for the cheapest, fastest current price lookup, contrasting with historical (get_market_chart) and venue-specific (get_exchange_ticker) 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?

Explicitly recommends use for 'what is X worth right now?' and provides alternatives: for historical prices use get_market_chart or get_aggregated_ohlc, for real-time venue-specific prices use get_exchange_ticker.

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

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

No annotations provided, but description fully discloses behavioral traits: it trims each history series to history_days, drops per-token breakdown arrays, and validates slug against regex. Also notes the raw DefiLlama response is enormous, adding important 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?

Description is fairly long but well-structured with clear sections: purpose, usage, args, returns, note. Every sentence adds value; minimal fluff. Could be slightly more concise but effective.

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

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

No output schema, but description covers return object structure in detail. Parameter details are comprehensive, usage context is clear, and validation note included. Fully adequate for a two-parameter tool.

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

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

Schema coverage is 0%, but description adds thorough meaning: explains slug format with examples and validation hint, and history_days includes default, purpose, and typical range. Goes far beyond schema names/types.

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 gets a single protocol's metadata, current TVL, and recent TVL history, with specific examples (Aave, Lido). It distinguishes from sibling tools like list_protocols by focusing on drilling into one protocol.

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?

Explicitly says to use after list_protocols, gives example queries, clarifies slug is not a CoinGecko ID, and warns about raw response size and trimming behavior. Provides clear context for when to use.

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

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

With no annotations, the description partially discloses behavior: it mentions the return format and that limit has a maximum of ~1000 depending on venue. However, it omits other behavioral traits like rate limits, data freshness, authentication requirements, or idempotency.

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 organized into a brief intro, usage line, Args section, and Returns. It is concise without being terse, though the structure could be slightly more streamlined.

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 output schema, the description includes a Returns section detailing the array of trade fields. It also covers all parameters adequately. Missing context like authentication or rate limits, but overall complete for a public 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?

Schema description coverage is 0%, so the description compensates well by providing an Args section that explains each parameter (exchange_id, symbol, limit) with examples and constraints (e.g., default 50, max ~1000). Adds 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?

Description clearly states 'Get recent public trades (the tape) for a symbol on a specific exchange.' It uses a specific verb-resource pair and outlines use cases (inspect order flow, identify large prints, compute metrics), distinguishing it from other get_* siblings.

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?

Description explicitly says 'Use to inspect order flow, identify large prints, or compute very short-term trade-driven metrics.' This gives clear guidance on when to use, but lacks explicit when-not-to-use or differentiation from other similar tools in the sibling list.

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

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

No annotations provided, so description carries full burden. It discloses return format (coins map with decimals, price, symbol, timestamp, confidence) and validation rules. Could mention that it fetches from external API or potential rate limits, but overall good.

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?

Well-structured with Args, Returns, and Note sections. Every sentence adds value without redundancy. Front-loaded with clear purpose.

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

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

Given one parameter, no output schema, and no annotations, the description is fully complete. It covers input format, output structure, validation, and context for alternatives.

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 has zero description coverage for the single string parameter. Description fully compensates by explaining the comma-separated chain:address format, providing examples, chain naming conventions, and validation regex.

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

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

Description clearly states it gets DefiLlama oracle spot prices for tokens identified by chain:address. It distinguishes from siblings by explicitly mentioning alternatives like dex_search and CoinGecko search for human-friendly discovery.

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?

Explicitly says when to use ('when you have a token's contract address and want a price without going through CoinGecko/DexScreener') and provides alternatives. Also gives detailed format for coins parameter.

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?

Given no annotations, the description discloses the API key dependency, potential error without key, and return structure (object with arrays). It is transparent about behavior but could mention read-only nature explicitly.

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 reasonably concise, with a clear first sentence, separate sections for args and returns. It could be slightly more streamlined but remains efficient.

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

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

In the absence of annotations and output schema, the description covers purpose, authentication, fallback, return structure, and parameter semantics. It does not explicitly state default values or optionality, but overall provides adequate context.

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

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

The 'Args' section explains each parameter's purpose and includes enum values for 'top_coins' but not for 'duration'. Schema coverage is 0%, so description adds meaning, but not all enum options are listed, leaving some gaps.

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

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

The description clearly states the tool gets the biggest price movers (gainers and losers) over a time window, with a specific verb and resource. It distinguishes itself from sibling tool 'list_top_coins' by mentioning a fallback, showing differentiation.

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

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

The description explicitly notes the API key requirement and fallback to 'list_top_coins' if no key is provided, giving clear when-to-use and when-not-to-use guidance.

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

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

Discloses that data is search-driven and returns a specific structure with price snapshots. No annotations exist, so description carries full burden. It does not mention potential limits like the number of items returned or any rate-limiting behavior, which would be helpful.

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?

Concise and well-structured: first sentence states purpose, second provides usage context, then a clear 'Returns' section with specific fields. No unnecessary words; every sentence adds value.

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

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

Given no parameters and no output schema, the description fully explains what the tool returns and the context for use. It includes enough detail for an agent to understand the output and decide when to invoke it.

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 parameters, the schema provides no information. The description adds meaning by detailing the return structure (coins, nfts, categories) and fields like item.id, item.name, etc. This exceeds the baseline of 3 for high schema coverage and effectively compensates for the lack of params.

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

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

The description clearly states the tool gets trending coins, NFT collections, and categories based on last 24h searches. It distinguishes itself from siblings like get_top_gainers_losers by emphasizing search-driven vs volume-driven, and specifies the exact data returned.

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

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

Explicitly gives example questions ('what is the market paying attention to right now?') and explains the search-driven nature, helping the agent decide when to use it. However, it does not explicitly mention when not to use it or point to alternative tools for volume-driven queries.

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

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

With no annotations, the description fully discloses behavior: makes fresh network calls, pings in parallel, lists each upstream source, and describes the return format including fields and error detail. No contradictions.

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?

Well-structured: summary line, usage guidelines, list of sources, return format. Every sentence is valuable and earns its place. Concise and front-loaded.

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 zero parameters and presence of output schema, the description covers everything: behavior, sources, and return details. No gaps remain.

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?

No parameters in the input schema, so the description provides all necessary context about what the tool does. It adds complete meaning beyond the empty 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: 'Parallel-ping every upstream data source and report status + latency.' It uses specific verbs and resources, and among many sibling tools, this is the only health-check tool, so it's well-distinguished.

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?

Explicit guidance: 'DEBUGGING tool. Call only when the user reports something is broken... Do NOT call on every request.' This clearly tells when to use and when not to use, with no ambiguity.

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

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

No annotations provided, so the description carries the full burden. It discloses that the tool is a read-only list operation and details the return fields (e.g., id, name, market_cap). However, it does not mention any side effects, rate limits, or authentication requirements, which is acceptable for a simple list tool.

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

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

The description is well-structured with sections for args and returns, and it is front-loaded with the main purpose. It is concise, though the code block for args and returns adds slight verbosity.

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 has one optional parameter and no output schema, the description adequately covers the input, output, and use case. It explicitly lists return fields, which is sufficient for an agent to understand the tool's behavior.

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 only parameter is 'order' with an enum of sort orders. The description notes 'order: Sort order,' which adds minimal meaning beyond the schema's 'title' and enum values. The schema coverage is 0% for property descriptions, so the description should compensate more here.

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 'List all coin categories with aggregated market data (market cap, 24h volume, 24h change).' It specifies the verb (list), resource (coin categories), and differentiates from siblings by explicitly mentioning the use case of finding category IDs for list_top_coins.

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

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

The description provides explicit usage: 'Use to discover narratives... and to find category IDs you can pass to list_top_coins(category=...).' This gives clear context for when to use the tool, though it does not mention when not to use it or provide direct 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?

No annotations provided, but the description implies a read-only operation by stating it lists current TVL. It doesn't explicitly state non-destructiveness, but the context is clear. Returns a sorted array, and mentions parameters and return fields, which adds transparency.

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

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

Concise and well-structured with two paragraphs plus Args/Returns. Every sentence contributes meaning, and the most important info is front-loaded.

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

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

Given the tool's simplicity (one param, no output schema, no annotations), the description is complete: covers purpose, usage, parameter, and return structure. No gaps.

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

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

Only one parameter (limit) with schema coverage 0%. Description adds value by explaining 'Number of chains to return after sorting by TVL desc (1..200)', providing range and default behavior beyond the schema.

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

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

The description clearly states the tool's purpose: 'List blockchain networks ranked by current total DeFi TVL.' It uses a specific verb and resource, and distinguishes from sibling tools like get_chain_tvl_history and list_protocols by mentioning them.

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

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

Provides explicit usage examples and when to use alternatives: 'Use for 'which chains have the most DeFi activity?', 'how does Solana's TVL compare to Ethereum's?', or to discover chain names you can pass to get_chain_tvl_history or list_protocols(chain=...).'

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. It only states 'List' (implying read-only) but omits details on caching, rate limits, data freshness, or any side effects, leaving gaps for an AI agent.

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 concise with a short introductory sentence and clear bullet-like parameter and return listings. No extraneous information, though structure could be slightly improved with formatting.

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 simple list tool with pagination, the description covers parameters and explicitly lists return fields (compensating for lack of output schema). It lacks error handling details but is complete enough for typical 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?

Schema description coverage is 0%, so the description must add meaning. It provides brief explanations for each parameter (e.g., 'Sort order' for order, '1..250 per page' for per_page), adding some value beyond the schema defaults and enums, but not deeply elaborating.

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

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

The description clearly states it lists derivatives exchanges (futures/perp/options) ranked by open interest or volume, using a specific verb and resource. It distinguishes itself from sibling tools like list_exchanges_directory by focusing on derivatives.

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 says 'Use to compare derivatives venues... by size,' providing a clear use case. However, it does not mention when not to use it or alternative tools, which would improve 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, description details return structure and change percentages, but could mention rate limits or update frequency.

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?

Well-structured with usage, args, returns; slightly verbose in returns but overall efficient.

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

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

Comprehensive for a simple list tool: purpose, usage, param, and detailed output; no missing essential info.

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?

Adds range and clarification beyond schema (1..200, number of DEXes), compensating for 0% schema description 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?

Clearly states 'List DEXes ranked by 24-hour trading volume' with example queries, distinguishing from sibling 'dex_search'.

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

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

Provides explicit use cases and suggests pairing with 'get_exchange_ticker' for centralized exchanges, but lacks explicit when-not-to-use.

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

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

No annotations provided, so description carries full burden. Clearly describes it as a read-only listing with specified return fields and sorting. Lacks explicit idempotency or safety statement, but the nature is obvious.

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?

Well-structured with purpose sentence, clarification, and Args/Returns sections. Each sentence adds value, though slightly longer than minimal.

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

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

Given no output schema, description lists all return fields. Specifies sorting, distinguishes from sibling, and covers parameters. Complete for a list tool.

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

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

Schema coverage 0% but description adds range for per_page (1..250) and clarifies page is a page number. Adds meaning beyond schema defaults and types.

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?

Explicitly states it lists centralized exchanges from CoinGecko's directory ranked by trust score/volume. Clearly distinguishes from sibling list_supported_exchanges, which is for live queryable exchanges.

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?

Explicitly tells when not to use (for live queryable exchanges) and provides alternative list_supported_exchanges. Also describes that it returns metadata for curated directory.

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

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

No annotations provided, but the description discloses the return format, the subtle field naming behavior when data_type changes, and the distinction between fees and revenue. Does not address destructive actions or auth needs, largely unnecessary for a read-like 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 verbose and includes extensive return field details. While well-structured with Args/Returns sections, it could be more concise without losing clarity.

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

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

No output schema, but the description provides complete return format details (summary and protocols fields). Covers parameter semantics and behavioral nuances thoroughly, making the tool fully understandable for invocation.

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

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

Input schema has 0% description coverage, but the description compensates fully: explains each parameter's role, enum values meaning, and the note about per-window field names referring to the chosen metric. Adds significant value beyond the schema.

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

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

The description clearly states it lists protocols ranked by fees or revenue, with specific use cases and differentiation between fees and revenue. It distinguishes from sibling tools like list_protocols and list_dex_volumes by focusing on fee/revenue 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?

Provides explicit examples of when to use (e.g., 'which protocols make the most money?') and explains the data_type parameter with practical guidance. Does not explicitly mention when not to use or alternatives, but the context is sufficient.

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?

Describes return type, error handling, and API cap. No destructive behavior implied, though annotations absent.

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?

Well-organized with purpose, caveats, and structured Args/Returns sections. Efficient and informative.

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

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

Covers all necessary context: purpose, usage, limitations, parameter, and return format. Adequate for invocation.

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

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

Only parameter 'limit' gets clear explanation of meaning and API cap, compensating for 0% schema description 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?

Clear verb 'list' and specific resource 'latest tokens with profile on DexScreener'. Differentiates from sibling tools like 'dex_search' by focusing on token profiles.

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?

Explicitly states use case as early-signal feed and warns about legitimacy, suggesting cross-check with 'get_dex_token_pairs'.

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?

Since no annotations are provided, the description carries the full burden. It states that it is a listing operation returning an array of NFT collections with specific fields. However, it does not disclose rate limits, authentication needs, or error handling, which would be helpful.

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 very concise with a clear purpose sentence, followed by structured Args and Returns sections. 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?

For a listing tool with 3 parameters and no output schema, the description provides acceptable information: sort options, pagination, and return fields. It directs to 'get_nft_collection' for details. Could be improved by noting default sort direction.

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 descriptions of parameters are minimal ('Sort order', '1..250', 'Page number'), but the purpose text adds meaning by listing sortable metrics. Schema coverage is 0%, so the description partially compensates but does not explain all enum values.

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 lists NFT collections with sort options (floor price, market cap, 24h volume). It distinguishes from sibling 'get_nft_collection' which is for a single collection.

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 explains the sort, pagination, and return fields. It directs to 'get_nft_collection' for details, providing an alternative. However, it does not explicitly state when not to use this tool or compare to other listing 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?

With no annotations, the description carries full burden. It explains sorting behavior, filtering by chain, and specifies return fields. While it doesn't explicitly state side effects (e.g., mutability), the action is inherently read-only and the description is thorough.

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 Args and Returns sections and is front-loaded. However, it includes some redundancy (e.g., repeated field list) and could be slightly more concise while remaining 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 3 parameters, no output schema, and no annotations, the description is comprehensive. It covers full parameter behavior, return fields, and includes a validation note. The agent has all necessary information to invoke 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 0%, but the description fully compensates by explaining each parameter: limit range (1..500), sort_by options (tvl, change_1d, etc.), and chain filter with validation regex. This adds significant 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 'List DeFi protocols ranked by TVL (or 1d/7d change, or market cap).' It specifies the verb 'list' and the resource 'DeFi protocols', and distinguishes itself from sibling tools like get_global_defi and get_protocol_tvl, which is explicit differentiation.

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

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

The description provides explicit when-to-use examples: 'Use this for "what are the biggest DeFi protocols?"...' and contrasts with get_global_defi, stating 'Far more granular than CoinGecko's get_global_defi, which only returns aggregate DeFi market cap.' This gives clear guidance on 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?

No annotations provided, but the description details return fields, conditional behavior (include_chain_breakdown), and links the id field to get_stablecoin_detail. Discloses essential behavioral traits.

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?

Well-structured with summary, examples, Args, and Returns. Front-loaded with purpose. Every sentence adds value, though 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?

No output schema, but description thoroughly covers return fields, optional chainCirculating, and explains the id field usage. Complete for a stablecoin listing tool.

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

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

Schema coverage is 0%, so the description must compensate. It explains both parameters: limit (range 1-200) and include_chain_breakdown (boolean affecting response size). Adds meaning beyond schema defaults.

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

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

The description clearly states it lists stablecoins ranked by market cap, with examples like 'what are the biggest stablecoins?' Distinguishes from siblings like list_top_coins by focusing on stablecoins.

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

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

Provides explicit use cases (e.g., comparing stablecoins, tracking peg health). Lacks explicit when not to use or alternatives, but the examples make the intent clear.

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?

Without annotations, the description transparently explains the tool returns an object with `count` and `exchanges` array, with example values. No side effects are expected, and the return structure is fully disclosed. No contradictions.

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?

Description is concise, with two clear paragraphs: purpose and return format. No unnecessary words. Front-loaded with the main action.

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 zero parameters and no output schema, the description fully covers the tool's behavior: what it does, why use it, and what it returns. Complete for its simplicity.

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?

No parameters are defined in the input schema. The description adds no parameter info beyond schema (which is empty). Baseline for 0-param tools is 4.

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 lists supported exchange IDs via CCXT, with a specific verb ('List') and resource ('exchange IDs'). It explicitly differentiates from siblings by noting it provides valid IDs for other CCXT-backed tools like `get_exchange_markets`.

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?

Directly states when to use: 'Use this when you need to know which exchange_id values are valid for the other CCXT-backed tools.' It lists those tools, providing clear context. No explicit when-not, but the purpose is narrow enough.

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

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

With no annotations, the description fully covers behavioral aspects: it explains that boosts are paid promotions, that high spend does not imply quality/traction/safety, and that it signals active pushing. It also documents return structure including error responses. A slight deduction for not mentioning rate limits or other potential constraints.

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 brief statement, a caution section, usage alternatives, and parameter/return doc. It is front-loaded with the core purpose. Some redundancy in the caution section could be trimmed, but overall efficient for the content delivered.

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

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

Given the lack of output schema, the description compensates by listing return fields (chainId, tokenAddress, etc.) and error handling. It also provides contextual advice about using complementary tools for deeper analysis. However, it could mention the ranking criterion or refresh frequency, leaving some minor gaps.

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

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

The input schema has 0% description coverage, so the description must compensate for the single parameter 'limit'. It states 'Max tokens to return', which is functional but minimal. No range, default behavior beyond schema, or caveats are provided, giving only basic 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 lists currently top-boosted tokens on DexScreener, a paid promotion. It explicitly distinguishes itself from siblings like list_latest_dex_tokens and get_dex_token_pairs, providing a specific verb and resource with 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 explicit when-to-use guidance: it is useful as a signal of what is being actively pushed. It also gives clear when-not-to-use alternatives: prefer list_latest_dex_tokens for unbiased early tokens and get_dex_token_pairs for price/liquidity confirmation. The caveat to read results with skepticism adds further guidance.

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

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

No annotations are provided, so the description carries full responsibility. It explains the tool's behavior (list, sort, paginate) but omits details like rate limits, authentication needs, data freshness, or any side effects, which is a moderate gap.

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

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

The description is well-structured with a concise summary, a helpful one-sentence context, a bulleted Args list, and a Returns list. Every sentence adds value without redundancy, 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 6 parameters, all optional, no output schema, and many sibling tools, the description provides sufficient context: usage patterns, parameter details, and return fields. Minor omissions like error handling or limits beyond pagination prevent 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?

With 0% schema description coverage, the description thoroughly explains all 6 parameters in the Args block, including defaults, possible values for order, category reference to list_categories, and format for price_change_percentages, adding significant meaning beyond the schema.

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

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

The description clearly states 'List top coins with market data (price, market cap, volume, change %)' and identifies specific use cases like 'show me the top N coins' and 'top by volume', distinguishing it from sibling tools such as get_price or get_top_gainers_losers.

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 explains when to use the tool ('workhorse for show me the top N coins style questions') and mentions pagination for more results, but does not explicitly state when not to use it or provide alternatives beyond the implicit 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?

The description explains client-side aggressive filtering, pool count (~20k), validation of parameters, and default behaviors. It does not explicitly state read-only nature but implies it. Without annotations, this provides substantial transparency.

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

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

Well-structured with clear sections: purpose, usage, args, returns, note. Every sentence adds value, and core purpose is front-loaded. No 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 output schema, it lists all return fields comprehensively. All 6 parameters are explained, validation details provided, and edge cases addressed (default 1M, disable by 0). The tool's behavior is fully specified.

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?

Despite 0% schema coverage, the description explains every parameter in detail: defaults, filtering behavior, case-insensitivity, value ranges (limit 1-500), and enum meanings. Regex patterns add extra clarity.

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 defines the tool as listing DeFi yield-bearing pools with filtering and ranking by APY/TVL. It uses specific verbs and resource, and distinguishes from sibling 'list_protocols' by noting different use cases.

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?

Explicit usage scenarios are given (e.g., 'best stablecoin yields', 'highest APY on Aave'), and an alternative tool is mentioned for protocol-level TVL, guiding when to use this vs. siblings.

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

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

No annotations provided, so description carries full burden. It details return structure (arrays for coins, exchanges, categories, nfts) and purpose. However, it omits information about rate limits, authentication, or any side effects. Since it's a search tool, likely read-only, but additional behavioral notes would be beneficial.

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?

Description is concise and well-structured: a brief purpose statement, explicit usage guidance, then structured Args and Returns sections. Every sentence adds value with no redundancy.