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

Annotations declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe scan. The description adds the 'multi-timeframe data' nuance and parameter hints (min_size_increase, pattern_length) that suggest analysis logic. However, it doesn't disclose specifics like data source freshness, performance considerations, or what happens when no patterns match. With annotations covering the safety profile, a 3 is fair.

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

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

The description is a compact paragraph followed by an Args block that's mostly a restatement of the schema. The prose line front-loads the purpose, and the Args block is terse. It's efficient with no waste, though formatting could be cleaner.

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 5-param scan tool with no output schema and 0% schema description coverage, the description covers the basics but misses important context: what the output looks like, how results are ranked, whether it needs an exchange symbol or scans a watchlist, and what happens when no pattern is found. Sibling tools like top_gainers likely have more context. This leaves an agent guessing about the return format and search scope.

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 for the 5 parameters. It lists each parameter with a brief meaning (e.g., 'Exchange name', 'Minimum percentage increase in candle size'), which adds meaning beyond the bare schema names. However, it doesn't specify valid values or formats (e.g., exchange name casing, pattern_length range beyond a hint in the name). This adds value but could be richer.

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 statement of what the tool does: 'Advanced candle pattern analysis using multi-timeframe data.' This distinguishes it from siblings like consecutive_candles_scan and volume_breakout_scanner, though it doesn't explicitly name any sibling. The verb 'analysis' is somewhat generic, but combined with the resource and multi-timeframe qualifier, the purpose is clear.

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 doesn't explicitly state when to use this tool vs. alternatives like consecutive_candles_scan or volume_confirmation_analysis. The phrase 'Advanced... using multi-timeframe data' implies a use case, but there's no direct guidance on when not to use it or which sibling to prefer. This is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description does not need to cover safety. It adds useful behavioral context through constraints like the SMA200 warmup requirement and the optional include_trade_log/include_equity_curve flags. However, it does not disclose output format, failure modes, data range limitations, or performance characteristics beyond what the parameter list implies.

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 opens with a clear one-sentence purpose, then uses a structured Args block that is efficient for nine parameters. It is appropriately sized and front-loaded. Minor vagueness like 'institutional-grade metrics' is the only non-essential element, preventing a perfect score.

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?

The description thoroughly covers all input parameters and usage constraints, which is essential given 9 parameters and no output schema. However, since there is no output schema, the description should also explain what the backtest returns, such as the performance metrics included in the report, but it only vaguely references 'institutional-grade metrics' and optional trade log/equity curve flags.

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 carries the full burden for parameter meaning. It does this well: it gives valid examples for symbol, enumerates strategy names, defines period options, states defaults, explains commission/slippage as per-trade percentages, and specifies interval choices. It also adds the critical warmup-period constraint for two strategies. This fully compensates for the missing schema descriptions.

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

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

The description uses a specific verb and resource: 'Backtest a trading strategy on historical data' with 'institutional-grade metrics.' It clearly identifies what the tool does, but it does not distinguish itself from sibling tools like compare_strategies or walk_forward_backtest_strategy, so it falls short of a 5.

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

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

The description provides implied usage guidance by listing allowed strategies, periods, intervals, and constraints such as 'rsi_pullback and triple_ema need period >= 1y for SMA200 warmup.' However, it does not explicitly state when to use this tool versus alternatives like compare_strategies or walk_forward_backtest_strategy, and gives no explicit 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context beyond that: it is a single-call aggregator, it returns a structured payload, and it includes a risk assessment label with specific possible values. It does not mention data freshness or rate limits, but those are not critical for this read-only 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 and front-loaded: the first sentence summarizes the tool, the usage guidance is explicit, and the return fields are bulleted for easy parsing. Every section earns its place; the length is justified by the absence of an output schema.

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 there is no output schema, the description fully compensates by enumerating the return sections: bitcoin, dominance, total_market, and assessment with possible labels. It also explains the tool's role relative to other analysis tools, making the definition complete 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?

The tool has zero parameters, so there is no parameter semantics burden on the description. The schema is empty and fully covered; the description correctly focuses on outputs and usage rather than inputs.

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 a specific purpose: providing BTC macro context (price, dominance, total market cap, risk assessment) in a single call. It differentiates itself from sibling tools by explicitly contrasting with chaining yahoo_price calls, so an agent can tell when this tool is the right one.

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

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

It explicitly says to use this tool WHENEVER analyzing any cryptocurrency to get the broader market frame, and explains why: a coin setup looks different depending on BTC behavior. It also names the alternative approach (chaining yahoo_price calls) and why this tool avoids that, giving clear selection 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?

Annotations already declare readOnlyHint and non-destructive. The description adds that it scans an entire exchange, returns a list of dicts on success, and returns a structured error envelope on any failure, which enriches the agent's expectations without contradicting annotations.

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

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

The description is well structured with a purpose statement, explicit disambiguation, a usage example, and a clear Args block. It is longer than necessary but every section adds value. Minor redundancy like re-stating the tool name could be trimmed.

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

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

Given the complexity of 4 parameters and no schema descriptions, the description provides exhaustive coverage: exchange lists, timeframe constraints, thresholds, return type, error handling, and a usage example. Since an output schema exists, not detailing the dict fields is acceptable.

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

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

Schema description coverage is 0%, so the description fully compensates by enumerating exchange options (specifying crypto vs stock exchanges), valid timeframes with typical threshold hints, the meaning of bbw_threshold, and the limit cap. This is far beyond the bare schema 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 identifies the tool as a whole-exchange Bollinger Band Width squeeze scanner, differentiating it from sibling scanners and explicitly noting it is not the single-symbol Bollinger read (which is coin_analysis). The purpose is unambiguous with a 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?

It provides explicit when-to-use (whole exchange squeeze detection) and when-not-to-use (single symbol via coin_analysis), along with an example call and typical threshold values per timeframe. These are concrete selection criteria.

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

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

Describes simulation details beyond annotations: ATR-bracket exits, intra-bar high/low checks, conservative stop-first fills, per-side fee+slippage. Annotations (readOnlyHint, destructiveHint) are consistent; no contradiction.

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

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

Well-structured: one-line summary, comparison, execution detail, then detailed Args. Slightly verbose but appropriate given complexity. 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?

Covers all parameters and behavioral details. Explains regime filtering, trade log, and execution model. No output schema but description sufficiently informs about return. Complete for a complex backtesting 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 has 0% description coverage; the description fully documents all 15 parameters with explanations, defaults, and usage suggestions (e.g., days window tips). Adds critical meaning beyond what schema provides.

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

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

Description clearly states it backtests scalp/day/swing strategies on Binance 1m-1d klines (long and short). Explicitly distinguishes from sibling backtest_strategy (Yahoo, 1h/1d, long-only).

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 alternative (backtest_strategy) for different use cases. Gives parameter suggestions (e.g., interval-day combos). Lacks explicit 'when not to use' but offers sufficient context for decision.

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

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

The description adds significant context beyond annotations: runs on same Binance data, computes once, checks neighbor profitability, and defines verdicts. No contradiction with annotations.

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

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

The description is well-structured with a summary followed by an Args list, but is somewhat lengthy; 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?

Covers algorithm, verdicts, and parameters well, but lacks details on return format or output structure.

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 fully compensates by listing all parameters with defaults, constraints, and roles, adding 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 performs a grid-search over bracket parameters (rr × atr_mult) with a stability verdict, distinguishing it from related tools like bracket_backtest or walk_forward_backtest_strategy.

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 tool is for parameter optimization and stability checking, but does not explicitly mention when not to use it or provide direct comparisons to 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?

The description adds significant behavioral context beyond annotations: force-closing positions at segment boundaries, aggregated out-of-sample result, verdict categories, and parameter stability. It does not contradict annotations (readOnlyHint: true, destructiveHint: false).

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: a bold summary, followed by process explanation, then parameter list. Every sentence is informative and front-loaded. It is appropriately sized 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 16 parameters and no output schema, the description covers the algorithm, verdicts, parameter stability, and all parameter details. It provides sufficient context for correct invocation, though output format could be more explicit.

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 provides detailed explanations for all 16 parameters, including ranges, defaults, and types (e.g., 'squeeze_breakout | ema_momentum' for strategy, '1m | 3m | ...' for interval). This fully compensates for the lack of schema descriptions.

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

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

The description clearly states 'True walk-forward optimization' and explains it's a gate before paper trading. It details the process and outcomes, distinguishing it from siblings like bracket_backtest and walk_forward_backtest_strategy.

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 indicates when to use this tool ('gate a strategy must pass before paper trading') but does not explicitly state when not to use or directly reference alternative tools. However, the context implies it is for rigorous validation.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only nature is covered. The description adds valuable behavioral context: the requirement for a bare ticker without exchange prefix, the fallback behavior that errors expose a 'listed_on' field naming exchanges that do list the symbol, and a high-level statement of the return (detailed analysis with all indicators and metrics). It does not contradict annotations.

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

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

The description is well-structured with clear sections (Purpose, Args, Returns) and front-loads the primary purpose immediately. It includes necessary examples and lists without unnecessary fluff. It is somewhat lengthy due to the exchange and symbol enumerations, but those are essential given the schema lacks details. Each sentence earns its place.

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

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

Given the complexity of symbols and exchanges across multiple markets, the description covers everything an agent needs to call the tool correctly: input formats, valid values, example calls, error-handling hints, and a definition of the return type. It also disambiguates from all sibling tools that could otherwise be confused. Nothing essential is missing, even without an 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?

The schema has zero description coverage, so the description carries the full burden for parameter meaning. It delivers extensively: symbol format with explicit crypto and stock examples, a comprehensive list of exchanges for both asset classes, and a timeframe list. It even clarifies that the symbol must not have an exchange prefix. This fully compensates for 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 opens with a precise statement of what the tool does: 'Get detailed analysis for a specific asset (coin or stock) on specified exchange and timeframe.' It explicitly declares itself the canonical single-symbol technical readout and names the sibling tools it is not (multi_timeframe_analysis, combined_analysis), making its purpose unmistakable and clearly distinct from all 40+ 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?

Provides explicit guidance on when to use this tool versus alternatives: it calls out that no 'get_technical_analysis' or 'get_technical_summary' exists, directs users to 'multi_timeframe_analysis' for trend alignment across timeframes, and to 'combined_analysis' for news sentiment + headlines. It also gives a concrete call example. This leaves no ambiguity about the right use case.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds the 'POWER TOOL' label and the combined nature of the output, but doesn't detail what the response contains (e.g., structure of TA, sentiment score, news list). With annotations covering safety, a 3 is appropriate – it adds some context but not deep behavioral detail.

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

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

The description is well-structured with a clear purpose statement, usage guidance, example, and parameter list. It's front-loaded with the key differentiator. The 'POWER TOOL' label is slightly informal but not wasteful. The parameter list is compact and useful. Minor deduction for the informal label and slight redundancy in the parameter descriptions.

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 combined analysis tool with 3 parameters and no output schema, the description covers the essential usage: what it does, when to use it, and how to call it. It doesn't describe the output structure, but that's less critical given the tool's purpose is clear. The example call is helpful. A 4 is appropriate – it's complete for an agent to invoke correctly, though it could mention what the response includes.

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 does explain the `symbol` parameter (bare ticker, no exchange prefix) and lists valid exchanges and timeframes. However, it doesn't add much beyond what the schema's defaults and types imply. The example call helps, but the description could be more explicit about parameter constraints (e.g., which exchanges are valid for which symbols). Baseline 3 is fair given the partial compensation.

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 combines TradingView technical analysis, news sentiment, and financial news for a single symbol. It uses a specific verb ('combined_analysis') and resource, and explicitly distinguishes it from siblings like `coin_analysis` and `multi_timeframe_analysis`. The example call further clarifies usage.

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 you want TA AND sentiment AND news for one symbol in a single call') and provides alternatives for other cases: `coin_analysis` for indicators only, `multi_timeframe_analysis` for cross-timeframe trend alignment. This is clear routing 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?

Annotations already signal readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context not in annotations, notably that shorter periods cause rsi_pullback and triple_ema to contribute zero trades due to incomplete SMA200 warmup. It stops short of describing output structure or runtime characteristics, but the added caveat is genuinely valuable.

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

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

The description is front-loaded with the core purpose in a single sentence, followed by a clean, well-structured Args block. Each parameter entry earns its place by adding examples, defaults, or caveats rather than repeating schema content verbatim. There is no filler or redundancy.

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

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

Given there is no output schema, the description adequately explains what the tool returns ('a ranked leaderboard'), documents all 4 parameters, and warns about the warmup limitation. The only gap is that the leaderboard's exact fields or ranking criteria are not specified, which would help an agent consume the result, but invocation is fully supported.

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 carries the full burden for parameter semantics. It compensates thoroughly: symbol is explained with examples, period lists all allowed values plus a trade-off, initial_capital states currency and default, and interval lists valid options. Every parameter is effectively documented beyond the bare schema.

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

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

The description clearly states the action: 'Run all 9 strategies' and the specific result: 'return a ranked leaderboard.' It even enumerates the nine strategies, making the resource well-defined. It does not explicitly name sibling alternatives like backtest_strategy or walk_forward_backtest_strategy, so it lacks explicit sibling differentiation.

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

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

The description provides strong usage context, including valid period and interval values, defaults, and a concrete recommendation that period >= '1y' is needed for RSI Pullback and Triple EMA to complete SMA200 warmup. It does not explicitly state when to choose this tool over siblings, but the parameter guidance is clear and actionable.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds useful context about the scan logic and the result limit, but it does not disclose output structure, ordering, or other behavioral details that an agent might need.

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 compact: a single-sentence purpose followed by a clear argument list. There is no filler or redundant restating of schema defaults, and the most important information 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?

All six parameters are documented, which is helpful. However, there is no output schema and the description does not describe expected result fields or ordering; exchange valid values are vague ('BINANCE, KUCOIN, etc.'); and bearish min_growth semantics are ambiguous. This makes the description adequate but incomplete.

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

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

The input schema has 0% description coverage, and the description compensates by explaining each parameter: exchange examples, timeframes, pattern types, candle_count range, min_growth, and limit. It does not fully clarify how min_growth should be interpreted for bearish/shrinking patterns, which is a notable ambiguity.

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 a specific action ('Scan for coins') and a specific pattern ('consecutive growing/shrinking candles pattern'), so the tool's core purpose is unambiguous. It does not explicitly differentiate from sibling scanners like advanced_candle_pattern, but the pattern focus and 'coins' scope make it reasonably distinct.

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?

There is no guidance on when to use this tool versus sibling scanners such as advanced_candle_pattern, bollinger_scan, or volume_breakout_scanner. The description explains what it does but not when it is the preferred choice or when alternatives should be used.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so no safety contradiction exists. The description adds parameter options (lookback, timeframe) but does not disclose output format, calculation methodology, or other behavioral traits beyond the structured 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 succinct, consisting of a one-sentence summary followed by a clean, structured args list. No redundant information is present, and each line 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?

Parameter documentation is thorough, and the tool is straightforward. However, the description does not mention what the analysis returns (e.g., retracement levels or a chart), and there is no output schema to fill this gap, leaving a minor completeness issue.

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 explains all three parameters in detail, providing examples for symbol, valid values for lookback and timeframe, and defaults. Since the input schema has 0% description coverage, this fully compensates for the missing schema-level documentation.

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

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

The description clearly states 'Fibonacci retracement analysis for EGX stocks,' which is a specific verb+resource combination. This distinguishes it from sibling tools like egx_market_overview and egx_sector_scan, none of which mention Fibonacci.

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 Fibonacci analysis on EGX stocks but provides no explicit guidance on when to choose this tool over alternatives. It does not mention exclusions or alternative tools, leaving the context partially implied.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description is consistent with a read-only analysis tool. It adds some context about output (constituent performance, full indicators) but does not disclose limitations like data freshness, rate limits, or whether results are real-time.

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

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

The description is appropriately concise: a single leading sentence stating the purpose, followed by a compact, front-loaded list of parameters. Every sentence adds value with no 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?

For a simple tool with three optional parameters and no output schema, the description covers the essential information for invocation: valid parameter values, defaults, and what the tool does. It could be more complete by clarifying what 'full indicators' means or by mentioning the response format, but it is largely 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?

Schema description coverage is 0%, yet the description fully compensates by explaining each parameter in the Args section: index lists all valid values, timeframe lists accepted strings and the default, and limit clarifies its meaning and maximum. This is essential because the schema only provides defaults without any descriptions or enums.

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

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

The description states a clear verb ('Analyse') and resource ('an EGX index') and mentions 'constituent performance with full indicators,' which gives a sense of the output. However, it does not explicitly distinguish this tool from siblings like egx_market_overview or egx_sector_scan, and the phrase 'full indicators' is vague.

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 when an agent needs to analyze an EGX index, but it does not provide explicit context or alternatives. There is no guidance on when to prefer this over related tools like egx_market_overview or egx_stock_screener, leaving the agent to infer suitability.

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

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

Annotations already provide readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds a note about default timeframe for stocks, which is a minor behavioral detail. But it doesn't disclose what the overview includes (market cap, indices, sectors?) or any aggregation behavior, which is significant for a 'comprehensive overview' tool. With annotations, a 3 is appropriate as the description adds some value but not rich 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 two sentences plus an Args block. It is efficient and front-loaded with the core purpose. The Args block repeats schema defaults but adds allowed values for timeframe, which is useful. No filler or waste.

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

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

For a market overview tool with a generic 'comprehensive' claim, it lacks details on what data is returned (indices, sectors, top movers?), how limit interacts with categories, and whether there are any exclusions. The sibling list shows other specialized tools, so this should clarify its scope. No output schema, so the description must do more to set expectations. It is not complete enough.

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 schema provides no semantic help for the two parameters. The description explains 'timeframe' with allowed values and 'limit' as 'stocks per category', which adds meaning. However, it doesn't define what 'per category' means (sectors? indices?) or explain the number of categories, leaving ambiguity about how limit impacts the output. This is a gap given zero schema coverage.

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

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

The description states a specific verb and resource ('Get a comprehensive overview of the Egyptian Exchange (EGX) market'), which is clear. It distinguishes from siblings like egx_sector_scan and egx_stock_screener by focusing on a market-level comprehensive overview. However, it doesn't explicitly differentiate from other EGX tools, only implies it.

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 context for use (comprehensive overview) but no explicit when-to-use or exclusions. It doesn't mention alternatives, despite many sibling EGX tools. The default timeframe hint for stocks ('1D for stocks') implies usage but is not explicit about when to choose this over egx_sector_scan or egx_index_analysis.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the tool is known to be a safe read operation. The description adds useful behavioral details: it shows available sectors when the sector parameter is left empty, it lists allowed timeframe values, and it states a maximum result limit of 50 per sector. These go beyond the annotations and give the agent insight into how the tool behaves. However, it does not describe the response format or any potential rate limits, so a 4 is appropriate.

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, well-structured, and front-loaded with the purpose. It uses a clear Args list that is easy to parse. Every sentence provides meaningful information; there is no fluff or repetition. The format is ideal for an AI agent to quickly grasp the tool's purpose and parameters.

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 that there is no output schema, the description does not explain the return structure, but it does hint at behavior (e.g., listing sectors when empty). It covers the tool's core functionality and parameters adequately. The main gap is the lack of detail about what the scan results look like (e.g., stock symbols, prices, indicators), which might be inferred from the tool's name but is not explicitly stated. For a read-only scanner with annotations covering safety, this is a minor omission, so a 4 is justified.

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 schema description coverage at 0%, the description fully compensates by providing explicit parameter semantics: it explains what 'sector' is with examples (banks, healthcare_and_pharma, etc.), lists all valid timeframe options, specifies the default and max for limit, and notes the behavior when sector is left empty. This is a comprehensive explanation that adds significant value beyond the bare schema, which only gives types and defaults. The description essentially serves as the documentation for all three parameters.

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

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

The description clearly states the tool's purpose: 'Scan EGX stocks by sector.' This is a specific verb and resource. It also mentions behavior for empty sector input, which adds clarity. However, it does not explicitly differentiate from the sibling tool 'egx_sector_scanner' that appears to have a very similar name and likely function, so it falls short of a 5.

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

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

The description provides some usage context: 'Shows available sectors if none specified' implies a workflow when you don't know the sector names. It also gives parameter guidance in the Args section. However, it does not explicitly state when to use this tool versus alternatives like egx_sector_scanner, egx_market_overview, or egx_stock_screener. There are no exclusions or conditions steering the agent away from other tools, only the general purpose of sector scanning.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds a conceptual summary ('identifies hot/cold sectors and top picks') but does not disclose internal scoring logic, output structure, or any caveats like data freshness. It adds minimal behavioral context beyond the 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 opens with a concise one-sentence purpose, then cleanly lists each parameter with its meaning and defaults. It is well-structured, front-loaded, and free of unnecessary words—every sentence earns its place.

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

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

For a read-only scanner with all-optional parameters and complete parameter documentation, the description is largely self-sufficient. The main gap is the lack of output format details (e.g., what the returned data looks like) and no clarification of the scoring criteria for 'hot/cold', but these are minor for an agent making a call.

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 zero description coverage (0%), so the description fully compensates. It lists each parameter with allowed values for timeframe (5m, 15m, etc.), numeric ranges for top_n_sectors (1-18) and top_n_stocks (1-10), min_stock_score range (0-100), and defaults. This is exactly the semantic detail an agent needs.

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's a sector rotation scanner for EGX that identifies hot/cold sectors and top picks. The verb 'identifies' and the specific resource (EGX sectors) make it unambiguous, and it distinguishes itself from generic scanners like top_gainers or stock_screener.

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

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

The description provides no guidance on when to use this tool versus alternatives. There is no mention of exclusions or specific conditions, and the sibling list includes a very similar tool (egx_sector_scan) without any differentiation. The agent would have to infer usage from the name and purpose alone.

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

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

Annotations already establish a read-only, non-destructive, open-world tool, so the safety profile is covered. The description adds only a basic 'ranking engine' behavior and does not disclose sort order, scoring logic, or result structure.

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?

A one-line summary followed by a compact parameter list with no filler. Every sentence adds value and the most important context 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?

The parameter contract is complete and callable, but the description doesn't explain output format or what 'strong' and 'actionable setups' concretely mean. For a screener with no output schema, that leaves some ambiguity about the return value.

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?

All four parameters are documented with allowed values, ranges, and coverage of the schema's gaps. The timeframe options, min_score range, index filter list, and limit max go well beyond the bare schema, which itself has 0% 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 identifies a stock ranking/screening engine scoped to EGX with a stated goal of finding strong stocks with actionable setups. This differentiates it from generic market tools, though 'actionable setups' is somewhat vague and doesn't sharply distinguish it from sibling EGX scanners.

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

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

No explicit guidance on when to use this tool instead of alternatives like stock_screener, egx_sector_scan, or bollinger_scan. The EGX focus implies a use case, but the description never states when it should be preferred or when it should be avoided.

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

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

Annotations already indicate readOnlyHint=true, openWorldHint=true, and destructiveHint=false, covering the safety and non-destructive behavior. The description adds minimal extra behavioral context beyond suggesting a generative analysis function, but it does not discuss outputs, complexity, or limitations.

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 compact, front-loaded with the purpose, and split cleanly into a purpose sentence and an Args block. Every line adds value and no filler or redundant phrases are present.

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-only generator of 2 parameters, the argument information is sufficient to invoke the tool. However, there is no output schema and the description's phrase 'full trade plan' is vague: the agent is not told what the returned plan contains, how it is generated, or what data it relies on. That omission leaves it incomplete.

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

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

Schema coverage is 0%, so the description must carry the full burden of explaining parameters. It does this well with a complete timeframe list, clear symbol semantics, example symbol values, and a default value. An agent can construct correct calls with no further lookup.

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 'Generate a full trade plan for a specific EGX stock' names a clear verb-action, a specific market, and a deliverable, so an agent can understand the tool's core purpose. It does not explicitly differentiate itself from sibling tools such as egx_stock_screener or multi_timeframe_analysis, which keeps it from a 5.

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

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

The description gives no explicit when-to-use guidance and no reference to alternatives. It only states what the tool does and does not mention that it should be used instead of other EGX tools or when a plan is needed.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds useful context by naming the data source (Marketaux), noting it is licensed, and emphasizing real-time behavior. However, it does not disclose potential rate limits, output shape, or how frequently the news updates.

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 compact and front-loaded, with a clear one-sentence overview followed by a concise, readable parameter breakdown. Every sentence adds value and there is no filler or redundant information.

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

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

All three parameters are documented and the source is identified, making invocation straightforward. However, there is no output schema and the description does not describe the response format or what fields are returned for each news item. For a news-fetching tool, that gap is moderate but not fatal.

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, and it does. Each parameter is explained: symbol with examples and the 'None = all news' behavior, category with allowed values, and limit with a clear meaning. This goes beyond the bare schema, though it could be more precise about exact accepted values or constraints.

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 indicates the tool provides real-time financial news from Marketaux. It lacks an explicit verb like 'retrieve' or 'fetch,' but the function name and content make the purpose unambiguous. There are no direct news-focused siblings, so differentiation is not a concern.

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

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

No guidance is provided about when to use this tool versus alternatives. It does not mention any exclusions, prerequisites, or conditions that would route an agent to a sibling tool. The parameter list implies usage but does not state it explicitly.

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

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

Annotations already provide readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds behavioral context by specifying the return format ('OHLCV quotes for the standard watchlist of contracts') and giving example symbols per category, which goes beyond the annotations. However, it does not disclose any limitations (e.g., what 'major front-month' means, how the watchlist is determined, or potential delays). Since this is a read-only snapshot tool, the added detail is useful but not exhaustive.

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 and front-loaded with the core purpose before diving into details. It uses a clear heading ('Args'), lists categories, and shows return behavior and examples—all in just 3 sentences. There is zero fluff; each sentence adds necessary information. This is a model of efficiency.

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 that there is no output schema, the description does explain the return (OHLCV quotes) and provides example symbols. However, it leaves some ambiguity about what 'standard watchlist' includes and does not discuss error handling or behavior for invalid categories. For a simple one-parameter tool, this is adequate but not comprehensive. The lack of a defined output schema lowers the expected burden, so a 3 is reasonable.

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

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

The schema description coverage is 0% and there are no enums, so the description carries the full burden of explaining the 'category' parameter. It explicitly enumerates the acceptable values (equity_index, energy, metals, agriculture, rates, forex, crypto_futures), which is essential for correct invocation. It also provides example symbols to illustrate typical inputs, compensating for the lack of schema-level documentation. This is strong for a single parameter, though it could mention that the default is 'energy'.

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

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

The description states a specific verb ('Quote') and resource ('all major front-month contracts in a specific futures category'). It clearly explains the scope by listing the five categories, making it distinguishable from siblings like 'futures_watchlist' (which likely targets a default set rather than a category-based subset). However, it does not explicitly contrast with sibling tools, so it falls just short of a 5.

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

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

There is no explicit guidance on when to use this tool over alternatives. It does not mention 'use when you need quotes for a category' or point to siblings like 'futures_market_overview' as a fallback. The description implies use for category-specific quotes but never states exclusions or alternatives, making this dimension weak.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the return format (Dict with total_available count and list of contracts with OHLCV + % change), which is useful. However, it doesn't disclose pagination behavior, rate limits, or what happens with invalid category values. With annotations covering safety, a 3 is appropriate.

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 for args and returns. It's front-loaded with the core purpose. The parameter list is concise and each line earns its place. Minor deduction for not being even more compact, 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?

For a read-only overview tool with no output schema, the description covers the essential information: what it returns, how to filter, and the parameter semantics. It doesn't explain edge cases (e.g., what happens with no matching contracts) or provide examples, but for a simple list tool this is adequate. The absence of an output schema means the return format description is valuable and present.

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 does: it explains each parameter's meaning (category values, exchanges options, limit default, volume_min filter). This adds significant value beyond the bare schema, which only shows types and defaults. The description effectively documents all four parameters.

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

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

The description clearly states the tool returns top futures contracts sorted by trading volume, with a specific resource (futures contracts) and verb (list/sort). It distinguishes itself from siblings like futures_top_movers and futures_category_snapshot by focusing on volume-sorted overview, though it doesn't explicitly name those alternatives.

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

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

The description provides parameter guidance (category, exchanges, limit, volume_min) and implies usage for market overview, but doesn't explicitly state when to use this tool versus alternatives like futures_top_movers or futures_category_snapshot. The context is clear but exclusions are not stated.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is established. The description adds useful behavior beyond the annotations: the return payload (list ranked by % change with OHLCV data) and the semantic of volume_min (filters illiquid contracts), which clarifies default behavior an agent would otherwise have to infer.

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 six-line summary sentence is front-loaded before the Args block, and the compact parameter listing is scannable and free of fluff. The only minor gap is 'max results' being slightly terse (max what? limit of results is implied but could be explicit).

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 read-only, parameter-simple tool, the combination of annotations, parameter documentation, and return description is nearly complete—an agent can call this tool correctly with the given information. It would only be improved by noting how it differs from the many similar siblings (e.g., futures_market_overview, futures_category_snapshot) in its domain.

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 carries the full burden of documenting parameters, and it delivers. All four parameters are given meaningful semantics: direction maps to gainers/losers with value options, exchanges maps to us/global, limit is explained as max results, and volume_min gets default plus behavioral context. This is exactly how a description should compensate for a 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 summary line "Futures contracts with the biggest percentage moves today" uses an implicit but clear verb plus resource, and the Returns section confirms it lists futures ranked by % change. However, it doesn't differentiate itself from closely-related siblings like top_gainers, top_losers, futures_market_overview, or futures_category_snapshot that could easily be confused with this tool.

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

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

The Args/Returns sections explain what the tool does with each parameter, but there is zero guidance on when to choose this tool over its many overlapping siblings. Given siblings like top_gainers, top_losers, futures_watchlist, and futures_market_overview, the description leaves an agent guessing which sibling to invoke when a user asks for top movers versus market overview data.

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

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

Annotations already mark it read-only and non-destructive, so the description's safety burden is low. It adds meaningful context by defining exactly what the list contains (front-month, categorized) and by naming the categories, which goes beyond the title. It doesn't reveal output formatting, but that is not critical for a read-only reference list.

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?

Three short sentences, each earning its place: the purpose, the exact category taxonomy, and the recommended follow-up tools. No filler or redundant wording.

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, read-only list tool, this is complete: the agent knows what it will receive, how the list is organized, and what to do next. The output schema is absent, but the description's explicit category list plus the follow-up pointers are enough for successful 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?

The tool has no parameters and the schema coverage is complete, so the description does not need to explain parameters. It correctly avoids inventing parameter requirements, making the call semantics obvious.

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?

States a specific verb ('Return') and a precise resource ('full categorized list of well-known front-month futures symbols'). The listed categories and the pointer to sibling tools distinguish it from futures_market_overview and futures_top_movers.

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 frames it as a symbol-reference source and tells the agent to feed these symbols into futures_category_snapshot or coin_analysis for deeper analysis. It does not spell out exclusions, but for a zero-parameter reference tool the intended use case 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?

Annotations already indicate read-only and non-destructive behavior. The description adds transparency by detailing the output (trade directions allowed, regime transitions, 30-bar trend histogram) and the underlying classification logic. No contradictions with annotations; all behavioral traits are disclosed adequately.

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

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

The description is well-structured, front-loading the purpose and then providing algorithmic details, output summary, and parameter explanations. Every sentence adds value, and the length is appropriate given the absence of schema descriptions. No redundant or empty content.

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?

The description is complete for a read-only tool with three simple parameters. It explains the output (trend, volatility, direction gates, transitions, histogram) without requiring an output schema. However, the exact structure of the returned data (e.g., JSON keys) could be more explicit, but it's sufficient for agent 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?

The input schema has 0% description coverage, so the description fully compensates. It explains each parameter: symbol (Binance pair, default BTCUSDT), interval (timeframe, default 4h), and days (history window 1-730, default 180, with warmup constraint). These details add meaning beyond the schema's type and default 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's purpose: determining the current market regime (trend up/down/chop) and volatility for a given symbol, using EMA50/EMA200 ratio and ATR% metrics. It distinguishes itself from sibling tools like market_sentiment or scanners by focusing on a specific classification method used in bracket backtests, providing unique value.

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 when to use the tool: to get a top-down regime snapshot for a symbol, especially as a prelude to scanning or backtesting. It does not explicitly state when NOT to use it or list alternatives, but the clear purpose and context imply appropriate usage. The inclusion of default parameters and warmup considerations provides practical 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, establishing it as a safe read-only operation. The description adds a small behavioral note about limit controlling the number of articles analyzed and mentions the licensed data source, but it does not describe the output format or any rate limits. This is moderate transparency.

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

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

The description is a single-line purpose plus a compact Args block. It contains no filler and is front-loaded with the essential behavior, every sentence earning its place.

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

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

No output schema is provided, and the description does not explain what the result looks like (score, label, articles). Since the tool's purpose is sentiment analysis, agents need to know whether to expect a numeric score, categorical rating, or article list. The licensed source mention adds some context, but the missing return format is a significant 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?

The schema provides only types and defaults (0% description coverage), so the description fully compensates by documenting symbol with examples, category with enumerated values, and limit as max articles. This is exemplary parameter documentation for a low-coverage 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 provides news sentiment for stocks and crypto, and names the data source (Marketaux). This makes its core function evident and distinguishes it from sibling tools like financial_news or top_gainers, though it lacks an explicit verb and does not name a specific sibling.

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?

There is no guidance on when to use this tool versus alternatives. It does not mention that financial_news might be more appropriate for raw articles, nor does it indicate when sentiment analysis is the right choice. The agent must infer usage solely from the tool name and brief description.

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 annotations already declare readOnlyHint=true and openWorldHint=true, so the description doesn't need to re-state that it's a read-only operation. It adds a valuable source attribution ('Powered by Yahoo Finance') and lists the asset classes, which is useful context. However, it doesn't clarify what 'top crypto' or 'key ETFs' means, nor whether output includes real-time, delayed, or end-of-day data, which could matter for an agent picking a 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 two sentences plus a source line: efficient, front-loaded with the core purpose, and no fluff. It misses a tiny opportunity to add 'use cases' without bloating, but as written it's tight.

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, read-only overview tool with annotations covering the safety profile, the description is mostly complete. But given the sheer number of sibling snapshot/overview tools, a phrase like 'broader than futures_market_overview but narrower than egx_market_overview' would have made it much more complete for an agent deciding between siblings. Also, no output schema and no mention of return format, though that might be overkill 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?

The tool has zero parameters, so there is nothing to document. The description's mention of asset classes (major indices, top crypto, FX rates, key ETFs) is the only semantic load-bearing content. With no parameters and 100% schema coverage meaning 'no params', the description does its minimal job but does not do more.

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

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

The description states a clear verb-noun phrase 'Global market overview' and lists covered asset classes (indices, crypto, FX, ETFs), which is specific enough to know roughly what the tool does. However, it does not distinguish itself from siblings like 'egx_market_overview' or 'futures_market_overview', so an agent might still pick the wrong macro tool. It's adequate but not great.

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?

There is no explicit guidance on when to use this tool versus alternatives. The description implies a broad use case, but with siblings like 'egx_market_overview' and 'futures_market_overview', the absence of any 'use this for X, not Y' direction is a gap. An agent has to infer from names alone.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful context about the internal debate structure and the final trading decision, which goes beyond annotations, but it does not disclose behavior like latency, data dependencies, or return shape details.

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

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

The description is well-structured and front-loaded with the core purpose. The Args section is compact but information-dense, and the Returns section is a single clear sentence. No filler or redundant restatement of the tool name.

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?

The description explains the inputs and the general nature of the output, but with no output schema and no statement about edge cases, failure modes, or required data prerequisites, an agent only gets a partial picture. It is adequate for a first invocation but leaves the shape and limitations of the result under-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?

Schema description coverage is 0%, so the description carries the full burden for parameters. It does this well: symbol and exchange are given extensive concrete examples across crypto and stock markets, and timeframe is listed with valid intervals. This meaningfully exceeds the bare schema definitions.

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

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

The description names a specific action ('Run a multi-agent debate') and a clear resource (a symbol), with the three agent angles (Technical, Sentiment, Risk) spelled out. It is unambiguous about what the tool does, though it does not explicitly differentiate itself from sibling analysis tools like multi_timeframe_analysis or combined_analysis.

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 no guidance about when to choose this tool over alternatives. It does not mention use cases, exclusions, or relationships to sibling tools such as multi_timeframe_analysis, market_sentiment, or coin_analysis.

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

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

Annotations (readOnlyHint=true, openWorldHint=true, destructiveHint=false) already establish this is a read-only safe operation. The description adds the specific timeframe hierarchy (Weekly → Daily → 4H → 1H → 15m), which is genuine behavioral context, but doesn't discuss rate limits, auth, or return-value behavior. Adheres to the calibration baseline of 3 for annotations covering the safety profile with some but limited additional 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 fairly long, but nearly every sentence earns its place: a one-line summary, anti-hallucination note about the canonical name, sibling routing, a worked example, and parameter docs. The 'canonical name' clarification is slightly unusual and reads as a guardrail, but the overall structure is well-organized and front-loaded with the 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 low-complexity tool (2 params, no output schema, no nested objects), this is nearly complete: purpose, alternatives, full parameter semantics, and a runnable example. The only gap is no mention of the return shape or behavior, but with no output schema and a self-evident analysis output, this is a minor omission.

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 schema description coverage at 0% and no enums, the description carries the full burden — and it excels. It documents concrete symbol formats per market ('BTCUSDT', 'COMI' (EGX), '600519' (SSE)) and enumerates all valid exchange values across crypto and stock venues. This goes far beyond the bare schema and is genuinely load-bearing for correct invocation.

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?

States a specific verb+resource ('Multi-timeframe alignment analysis') and immediately differentiates from siblings: 'for a single-timeframe deep dive use coin_analysis; for TA + sentiment + news use combined_analysis.' An agent can instantly tell this apart from the siblings without opening any schema.

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 when-to-use guidance is front and center: 'Use this for cross-timeframe trend alignment on ONE symbol' followed by named alternatives for other cases. Explicitly names two sibling tools with the conditions that select them (single-timeframe vs. combined analysis), leaving nothing to inference.

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

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

Annotations include destructiveHint: true, indicating destructive behavior. The description adds context by specifying that the tool defaults to two specific strategies and that it refuses overwrite without confirm=true. No contradiction with annotations.

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

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

The description is well-structured: a clear summary sentence, followed by a note on default strategies and the confirm condition, then a detailed bullet list of parameters. It is slightly lengthy but efficiently organized with no wasted words.

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

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

The description covers the tool's purpose, default behavior, all inputs, and a key condition. No output schema is provided, and the description does not specify return values or success/failure indicators. However, for a creation/reset tool, the behavior is well-explained.

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 8 parameters with defaults but zero descriptions. The description explicitly explains each parameter's meaning and purpose (e.g., 'confirm: Required true to wipe an existing account', 'initial_capital: Starting fake capital in USD'). 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 tool's purpose: 'Create or wipe the paper-trading account'. It specifies the resource (paper-trading account) and the actions (create or wipe). Sibling tools include paper_step and paper_status, which are distinct, so differentiation is clear.

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 a key usage condition: 'Refuses to overwrite an existing account unless confirm=true.' This tells the agent when to use the confirm parameter. However, it does not explicitly compare with sibling tools like paper_step or paper_status, so guidance on when to reset vs advance vs check status is implicit.

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

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

Annotations declare readOnlyHint and destructiveHint, and the description adds value by enumerating the report contents (capital, PnL, drawdown, etc.), which is beyond the annotations. No contradictions or missing behavioral context for this simple 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?

The description is a single, well-structured sentence that front-loads the purpose and lists key elements efficiently. No unnecessary 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 tool with no parameters and no output schema, the description provides a thorough list of returned information. It could specify format details (e.g., percentages vs absolute numbers), but the current description is sufficient for an AI agent to understand the output.

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

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

The tool has zero parameters, so schema coverage is 100% and description need not add param info. The description compensates by detailing what the report contains, which is effectively the parameter impact.

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 a paper-trading account report with specific elements like capital, PnL, drawdown, etc. It distinguishes itself from siblings by focusing on status rather than actions like reset or step.

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 checking current account status but does not explicitly state when to use it over alternatives or provide exclusions. Siblings like paper_reset and paper_step hint at when to use this tool, but no direct 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 it processes only closed candles, ignores in-progress ones, catches up after downtime, and manages positions with stop-first bracket semantics. Also explains when new entries are taken (signal, regime gate, halt, kill switch). Annotations indicate non-readonly and non-destructive, consistent with description.

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 at 5 sentences, front-loaded with the primary action. Each sentence adds meaningful detail without redundancy.

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

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

Given the tool's complexity (advancing a paper trader with multiple conditions and state), the description covers behavior, scheduling, safety, and return value sufficiently. No output schema exists but description mentions events and snapshot.

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 exist, so baseline score of 4 applies. The description fully explains behavior without needing to document parameters.

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

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

Clearly states it advances the paper trader one tick against live Binance data, processes closed candles, and manages positions. Distinguishes itself from sibling paper tools like paper_reset and paper_status by its step-specific action.

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 'Call this hourly' or run the daemon, and mentions it's safe to call any time. Lacks explicit alternatives but the context and recommendation provide clear usage 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?

Beyond the annotations (readOnlyHint, destructiveHint), the description discloses the return type ('list[dict]') and the structured error envelope on any failure ('{"error": {"code": ..., "retryable": ...}}'). It also clarifies the limit maximum. This adds valuable behavioral context beyond the annotations.

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

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

The description is well-structured with a clear one-line summary followed by a bulleted args list. It is concise and front-loads the purpose. The return/error info is appended efficiently. No extraneous content.

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 filter tool with 4 optional parameters, the description covers all parameter values, return type, error envelope, and limit constraints. It is complete enough for an agent to invoke it correctly without additional information. The presence of an output schema is noted but not needed here.

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 schema description coverage at 0%, the description fully compensates by explaining each parameter: exchange with examples, timeframe with allowed values, rating with a mapping (-3 to +3), and limit with a max. This provides essential meaning that the schema lacks.

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

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

The description states 'Filter coins by Bollinger Band rating', which is a clear verb+resource+metric. It distinguishes the tool's core function but does not explicitly differentiate it from the sibling bollinger_scan, which likely also uses Bollinger Bands. The purpose is unambiguous and specific.

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 what the tool does and the parameter semantics, but it does not state when to use this tool over alternatives like bollinger_scan or other scanners. The usage context is implied from the name and description, but no explicit when/when-not guidance is given.

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?

Beyond the readOnlyHint and non-destructive annotations, the description explicitly reveals the success return type (list[dict]) and the failure envelope with retryable flag. It also notes a max result limit of 30. This provides meaningful runtime behavior that annotations alone would not convey.

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 into a one-sentence summary, a parameter list, and a return/error statement. Every line adds necessary information and nothing is repeated. It is an appropriate length for a 5-parameter tool.

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

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

For a read-only scanner with all-optional parameters, the description covers the return contract, error shape, and all parameter semantics. No critical information about how to invoke or interpret the result is missing.

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 carries the full burden of explaining parameters. It does so for all 5 parameters, including valid rsi_range values, defaults for min_volume_ratio and min_price_change, and a max for limit. It is slightly terse for exchange but sufficient.

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

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

The description states a clear combination scanner purpose: it combines volume and technical analysis. It doesn't use a verb like 'scan' or 'screen,' but the noun phrase is specific and suggests what the tool does. It distinguishes itself from pure volume and pure technical scanners, though not by name.

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 no explicit when-to-use guidance or exclusions, and it never references siblings such as volume_breakout_scanner or bollinger_scan. The presence of filters implies its use case, but the agent is left to infer when to select it over alternatives.

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

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

Annotations already mark the tool read-only and non-destructive, and the description adds valuable behavioral details beyond that: null post_market during regular hours, weekend/holiday behavior, 'most recent valid print' per window, and the computed percentage changes relative to appropriate baselines. No contradictions with annotations exist.

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

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

The description is front-loaded with the core purpose and usage trigger, followed by concise structured Args and Returns sections. Every sentence adds value, and the format is easy for an agent to scan and apply.

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

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

For a single-parameter, read-only tool with no output schema, the description is complete: it explains inputs, outputs, null semantics, session timing, and market-condition behavior. An agent has everything needed to select and invoke the tool correctly and interpret its results.

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 provides only the parameter name and type with no description, so the description carries the full burden. It explains symbol as a US stock symbol and supplies concrete examples including tickers, index symbols, and the ^GSPC format. This fully compensates for the 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?

The description clearly states the tool's function: retrieving real-time pre-market and after-hours prices for a US stock symbol. It uses a specific verb-resource combination ('returns real-time pre-market and after-hours prices') and distinguishes itself from regular-session price tools like stock_prices and yahoo_price by explicitly limiting scope to extended-hours sessions.

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 explicit when-to-use guidance: 'Use this when the user asks about a stock outside the regular 9:30am-4pm ET session' and provides concrete example queries. It also explains edge-case behavior during regular sessions and weekends/holidays, which helps the agent decide correctly without 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral detail beyond the schema: it returns the nearest expiry when none is provided, errors with a list of valid expiries if the given one doesn't match, and fully documents the return structure including underlying prices, counts, and per-strike fields. This gives an agent a clear picture of side effects, error behavior, and output shape.

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: a one-sentence summary, explicit usage triggers, and then precisely formatted Args and Returns sections. Every sentence earns its place, and the length is justified by the need to document both parameters and the full return shape without an output schema.

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 thoroughly documents the return payload, including nested call/put objects with all key fields. It covers required behavior (nearest expiry, error on invalid expiry), parameter semantics, and the distinction between calls and puts. An agent has everything it needs to invoke this tool correctly and interpret the result.

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 carries full parameter-documentation weight. It defines `symbol` with concrete examples ('AAPL, NVDA, TSLA, SPY') and `expiry` with format constraints, validity rules, and error behavior. This exceeds what a bare schema would provide and leaves no ambiguity about how to populate each argument.

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 role: 'Full options chain (calls + puts) for a US stock symbol and one expiry.' It uses a specific verb ('returns,' 'Use this when') and identifies the exact resource, distinguishing it from generic quote tools like yahoo_price or stock_prices. The examples ('show me AAPL puts expiring next Friday') make the intent unmistakable.

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 trigger phrases: 'Use this when the user asks...' and gives concrete examples. It also explains the no-expiry fallback behavior and invalid-expiry error handling. However, it does not explicitly name sibling alternatives or state when NOT to use this tool versus stock_options_unusual_activity or other option-related tools.

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

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

Beyond the readOnlyHint annotation, it discloses the internal algorithm: scans the soonest expirations, filters out illiquid strikes below min_volume, sorts by V/VOI descendant, and helps to explain the OI > 1 interpretation. It also notes it returns aggregate call vs assets volume for directional-bias commentary.

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 longer, but every sentence adds meaningful behavior or usage guidance. It is logically organized: a one-line summary, example use cases, parameter details, and return format. There is no fluff or repeated schema text.

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

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

Given no output schema, it fully documents the return fields: underlying_price, expiries_scanned, total_call_volume, total_put_volume, put_call_volume_ratio, and each unusual contract's fields. For an additional complexity tool with four parameters, it is 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?

The input schema has descriptive coverage (0%), meaning the tool description carries full burden. It defines each parameter's purpose and default, such as 'top_n: How many strikes to return. Default 10' and 'min_volume: Filter floor... prevents noise from illiquid strikes'.

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 opens with 'Top strikes by volume / open-interest ratio — institutional positioning signal,' which names the resource and specific metric. It then gives concrete verbs: 'Scans…filters…returns,' making it clearly distinguishable from a generic stock_options_chain.

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 canonical trigger phrases: 'any unusual options activity on X?', 'where is the smart money positioned...', and 'wants an OI screener for a ticker.' It does not name an alternative sibling tool or say 'do not use this for X', but the use cases are specific enough to guide selection.

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

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

Annotations only declare readOnlyHint/openWorldHint/destructiveHint. The description adds substantial behavioral disclosure: the max of 2000 tickers, the fact that even at that size it is 'one upstream request', the exchange-scoped lookup behavior, and the not_found list in the response for unrecognized tickers. These are exactly the kind of behaviors an agent needs to know that the annotations do not cover.

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 about 60 words of prose split into an intro sentence, an Args section, and a Returns section. Every sentence adds critical information—no redundancy, no fluff. The most important constraint (format) appears first, with the example and edge cases (not_found) following naturally. It is dense but 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 tool has only one parameter and no output schema, the description covers all necessary usage context: the exact string format, length limits, the behavior when a ticker is not recognized, and the full set of returned fields (ticker, symbol, description, exchange, price, open, high, low, currency, change_percent). There is no external output schema to fall back on, yet nothing essential is missing for correct 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?

The input schema only provides 'tickers' with type string and no description or enum, i.e., 0% schema description coverage. The description fully compensates by specifying the exact format ('EXCHANGE:SYMBOL'), giving an example ('NASDAQ:NVDA, NASDAQ:TSLA, KRX:005930'), the comma separator, the 2000 max, the requirement for an exchange prefix, and the return envelope structure. This transforms a previously meaningless parameter into a completely specified one.

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: 'Current price + daily % change for specific stock symbols.' It specifies the resource (stock symbols), the action (retrieve current price and change), and the scope (specific symbols, not indices or sectors). This distinguishes it from the many scanner and analysis tools in the sibling list.

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

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

The description implies usage through detailed formatting instructions ('comma-separated EXCHANGE:SYMBOL list') and notes the exchange prefix is required. However, it never explicitly states when to use this tool versus a sibling like 'yahoo_price' or 'stock_screener', nor does it exclude alternatives. The context is clear, but there are no explicit when/when-not conditions.

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

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

Annotations already flag readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds genuinely useful behavior beyond annotations: 'single upstream request', 'server-side descending sort over the WHOLE market', the 'price is current/last close' semantic, local-currency behavior (with KRW example), and the return-envelope structure. An agent calling this knows exactly what side effects and data semantics to expect.

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 docstring-style Args/Returns layout is scannable and front-loaded with intent. Every clause earns its place, from the parenthetical 'single upstream request' caveat on limit to the 'KRW for korea' clarification. The sort_by example is the longest sentence but conveys critical semantics that could not be abbreviated. No redundancy with the schema since the schema has no descriptions.

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?

With no output schema present, the description correctly carries the return-format burden — and does so thoroughly: the envelope keys (total_matches, returned, rows), row-level fields, and the meaning of open/high/low relative to price are all stated. The only minor omissions are error behavior for invalid country values and an explicit statement about rate limiting, but for a read-only screener this is fully adequate.

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 carries the full documentation burden — and it delivers. Every parameter gets meaning beyond its name: country gets a TradingView market-name note and examples; limit gets max-2000 plus ranking semantics; sort_by gets the full semantics of each value; exclude_otc and compact each explain the trade-off and intended use. Parameter names in the schema would be insufficient; the 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?

The opening line names a specific verb (screen), resource (stocks), and the qualifying scope ('by share type'). It also anchors itself as the API twin of TradingView's 'Common stock' / 'Preferred stock' filter, which immediately signals its purpose relative to the many scanner siblings. Together with the title, an agent can distinguish this from the scanner tools without inspecting the schema.

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 rich intra-tool usage context: sort_by is explained with a concrete example showing server-side whole-market behavior, compact is positioned 'for bulk price feeds', and exclude_otc explains the 'US venue' vs 'US company' distinction. However, it never explicitly says when NOT to use this tool or names a sibling alternative (e.g., egx_stock_screener or the scanners), so selection guidance across tools is left implicit.

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

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

The description adds valuable behavioral context: it specifies the return format (list[dict] on success) and the structured error envelope with retryable flag, which is not covered by annotations. Since readOnlyHint is true and destructiveHint is false, the safety profile is already clear, but the error handling detail goes beyond annotations. No contradiction exists.

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

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

The description is well-structured with a docstring format: purpose first, then Args, then Returns. It is concise yet covers all essential details without unnecessary fluff. The structure is easy to scan, and the purpose 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?

For a read-only screener, the description covers all necessary aspects: parameters, valid values, return type, and error behavior. The existence of an output schema is indicated, but the description still explains the return shape, which is helpful. No critical information is missing for an agent to call 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?

Schema description coverage is 0%, so the description must fully compensate. It excels by listing valid exchange names (KUCOIN, BINANCE, etc.), valid timeframes (5m, 15m, 1h, etc.), and the limit parameter with a max of 50. This provides all necessary semantics that the schema lacks (which only has 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?

The description clearly states it returns top gainers for an exchange and timeframe using Bollinger Band analysis. This distinguishes it from siblings like top_losers (opposite direction) and bollinger_scan (likely a broader scan), even though it doesn't name them explicitly. The verb and resource are specific and unambiguous.

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

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

The description does not explicitly state when to use this tool versus alternatives like bollinger_scan or top_losers. Usage is implied by the name and purpose, but no explicit conditions or comparisons are given. An agent could infer that it's for quick gainers screening, but the lack of explicit guidance leaves some 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?

Annotations already declare readOnlyHint, openWorldHint, and destructiveHint, so the safety profile is covered. The description adds a clear success return type and a structured error envelope on any failure, which is useful and goes beyond the annotations. It does not contradict any annotation.

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?

Three short sentences are front-loaded with the core purpose, followed by supported markets and the return/error contract. There is no filler or redundancy.

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

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

Given all parameters are optional with defaults and an output schema exists, the description covers the main selection logic and failure behavior. The remaining gap is the lack of enumerated timeframe values, which could cause an agent to pass an unsupported string, but overall the tool is callable from the description.

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

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

With 0% schema description coverage, the description must carry parameter meaning. It adds concrete exchange choices and distinguishes crypto vs stock markets, but it still omits valid timeframe values and the meaning/range of limit. This is meaningful but incomplete compensation.

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 opens with a specific verb-resource pair, 'Return top losers for an exchange and timeframe,' which immediately distinguishes the tool from screening, price, and news tools. It also enumerates supported markets, so the agent knows its exact scope. This exceeds baseline clarity.

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 supported exchange list gives implicit guidance about where the tool applies, but there is no explicit 'use this instead of X' statement or exclusions. An agent must infer when to choose top_losers over top_gainers, futures_top_movers, or stock_screener. That is adequate but not strongly guided.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false, so the description adds some behavioral detail by explaining the return contract: returns list[dict] on success, an error envelope on total upstream failure, and that an empty list means no matches today. However, it does not discuss rate limits, performance characteristics, or any side effects beyond the obvious read-only nature.

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 purpose statement followed by a parameter list and return information. It is reasonably concise, though it somewhat duplicates the schema by listing parameters that are already present. The structure is logical and easy to scan, but could be tightened by referencing the schema instead of repeating content.

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 that the tool has 5 parameters, no required fields, and an output schema, the description covers all parameters, return types, and error behavior. It also clarifies the meaning of an empty list. However, it omits any mention of preconditions, such as the need for an active market or data availability, and does not discuss edge cases (e.g., invalid timeframe values). The presence of an output schema compensates for missing low-level return details.

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 provides semantic explanations for each parameter (e.g., 'volume_multiplier: How many times the volume should be above normal level' and 'timeframe: One of 5m, 15m, 1h, 4h, 1D, 1W, 1M'), which the input schema lacks. This gives the agent a clear understanding of what each parameter controls, though it could be augmented with examples or more explicit units (e.g., percentage as a number) to reach a perfect score.

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 begins with a clear verb 'Detect' and specifies the resource 'coins' with the criteria 'volume breakout + price breakout'. This is distinct from the sibling tools (e.g., smart_volume_scanner, top_gainers) and immediately clarifies the tool's primary function.

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

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

The description does not provide any guidance on when to choose this tool over the many alternative scanners, such as when a user specifically wants a combined volume and price breakout vs. volume-only or pattern-based scans. There is no mention of appropriate use cases or comparison with 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?

The annotations already indicate readOnlyHint=true and destructiveHint=false, and the description adds no additional behavioral context such as rate limits, data source, or what 'analysis' entails. While the description is consistent with the annotations, it provides no extra transparency about side effects or system behavior beyond what annotations already capture.

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 front-loads the main purpose, followed by a parameter list. It could be better structured with consistent formatting or a more explicit separation between the summary and details, but it is not bloated and every word earns its place.

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

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

For a read-only analysis tool with only three parameters and no output schema, the description is adequate. It explains the parameters and the tool's purpose. However, it does not mention what happens after analysis (e.g., output format, examples), which could be important for an agent to know. But given the simplicity and the presence of annotations, this is a minor gap.

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

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

The input schema has no descriptions for any parameter (0% schema coverage), but the description's Args section provides brief definitions: 'Coin symbol', 'Exchange name', 'Time frame for analysis'. This adds meaning and compensates for the schema gap, though the definitions are minimal and could be more detailed (e.g., accepted formats, examples).

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 performs 'volume confirmation analysis' for a specific coin, which is a specific verb+resource. It includes the parameters symbol, exchange, and timeframe, making its purpose clear. However, it does not explicitly differentiate itself from sibling tools like volume_breakout_scanner, so it loses a point for not distinguishing from alternatives.

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

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

No guidance is provided on when to use this tool versus other volume-related tools in the sibling list. The description only lists parameter names without any context about typical use cases, prerequisites, or alternatives. This is essentially no usage guidance beyond the tool's name.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, destructiveHint=false, so the safety profile is clear. The description adds meaningful behavioral context by explaining why some strategies are unsupported ('SMA200 warmup exceeds typical fold size'), the fold-based evaluation approach from training to unseen test data, and the per-fold capital structure—useful context beyond the 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 opening sentence is a crisp thesis, and the Args block is well-organized for parsing. However, the Args section restates defaults already present in the schema (e.g., 0.05, 10000) and is fairly long. It's efficient enough to be skimmable but slightly redundant with schema values that the agent could fetch on its own.

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 9-parameter tool, the description thoroughly covers what, why, and when, including a critical sibling alternative. The main gap is that it doesn't describe expected return values or output shape, and there's no output schema to fill the void. It also doesn't mention error cases, but for a backtest with no side effects, the provided context is nearly 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?

With 0% schema description coverage, the description carries the full burden—and it delivers. Every parameter is documented with units, defaults, accepted values, and slot semantics (e.g., 'per fold', 'fraction of each fold used for training'). The description even clarifies constraints like n_splits max=10 that the schema leaves implicit. This is a model example of compensating for absent schema descriptions.

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

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

The description leads with a specific verb and resource combination—'Walk-forward backtest to detect overfitting'—and explains the mechanism ('validates strategy on unseen data'). It clearly differentiates this walk-forward variant from standard backtests by naming the core purpose and the range of strategies it supports.

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 routes unsupported strategies (rsi_pullback, triple_ema) to run_backtest with a specific period, giving the agent an unambiguous alternative. It also advises a preferred period ('recommend 2y') and constrains n_splits to a max of 10, providing decisions rather than just definitions.

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

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

Annotations already establish readOnlyHint=true, openWorldHint=true, and destructiveHint=false, and the description does not contradict those. It adds the Yahoo Finance data source and real-time character, but provides no further behavioral context such as rate limits, latency concerns, or what the quote response contains.

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 compact: one purpose sentence plus a short Args section with examples. Every line adds necessary signal, and the main purpose appears first.

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

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

For a one-parameter, read-only quote tool, the description is mostly complete and gives an agent enough to invoke it correctly. The remaining gaps are the absence of any output-shape note and the lack of guidance that would disambiguate from similar-sounding sibling tools.

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

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

The schema description coverage is 0%, so the description carries the full burden for the symbol parameter. It compensates well with concrete examples covering equities, crypto, ETFs, indices, forex, and foreign markets, making the expected symbol format genuinely actionable.

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?

States a specific verb+resource and scope: 'Real-time price quote from Yahoo Finance for any stock, crypto, ETF or index.' It is exactly clear what data this tool returns. It does not name how it differs from closely related sibling tools such as stock_prices, so it is not fully differentiated.

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 no explicit when-to-use or when-not-to-use guidance and names no alternatives. Given the sibling list contains overlapping-sounding tools like stock_prices, the agent receives no help separating them by context or intent.

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