TraderSpy

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the OHLCV data type and use cases but does not disclose additional behavioral traits like pagination, rate limits, or return format. This matches the baseline where annotations carry the transparency burden.

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, front-loaded sentence that states what the tool does and why it is useful. Every word earns its place, with no redundancy or fluff.

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

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

Given the rich annotations, fully described schema, and output schema presence, the description is nearly complete. It could explicitly note that this returns historical data versus a current price, which would improve differentiation from get_price, but the OHLCV mention largely covers this. Slightly more contextual guidance would make it fully complete.

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

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

Schema description coverage is 100% with all three parameters (symbol, interval, limit) fully described, including defaults, enums, and ranges. The description adds no parameter-specific meaning beyond saying 'OHLCV', so the schema already does the heavy lifting; baseline 3 applies.

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 ('Get') with a clear resource ('OHLCV candle data') and scope ('for a crypto futures symbol'). It also lists concrete use cases ('charting, price history, and technical analysis'), which distinguishes it from siblings like get_price (likely current price) and get_technical_indicators.

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 clear context for when to use this tool ('Useful for charting, price history, and technical analysis'), implying these scenarios. However, it does not explicitly mention alternatives or when not to use it, such as 'for current price, use get_price'.

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 communicate read-only and idempotent behavior. The description adds useful scoping context ('by SmartScore across exchanges') without contradicting annotations. It doesn't detail edge cases or rate limits, but for a simple read operation this is adequate.

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 single, front-loaded sentence that immediately states the trigger condition and the tool's purpose. No wasted words, perfectly scannable by an agent.

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

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

For a no-parameter, read-only tool with a clear output schema and simple trigger, the description fully covers the necessary context. There are no gaps in usage preconditions or 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?

The tool has zero parameters, so the baseline is 4 per the rubric. Schema coverage is trivially 100%, and there are no parameter details missing—the description doesn't need to explain parameters that don't exist.

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—'get the elite leaderboard'—and adds the scoping detail 'by SmartScore across exchanges,' which clearly differentiates it from sibling tools like get_top_traders. It tells the agent exactly what the tool does and when to consider 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 a clear trigger condition ('when the user specifically asks for'), giving explicit context for when to use the tool. However, it does not mention alternatives or state when not to use it, which is a minor gap relative to the top tier.

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, idempotentHint=true, and destructiveHint=false, so the description adds only context about the data source. It does not describe return format or dynamic behavior, which is acceptable given annotation coverage.

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

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

A single, front-loaded sentence with no redundant content, perfectly sized for its simplicity.

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 params, strong annotations, and an output schema present, the description adequately covers the tool's purpose and use case. Could slightly benefit from mentioning the output nature, but not necessary.

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

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

Tool has zero parameters, so the baseline is 4. The description appropriately avoids parameter details since none exist; schema coverage is 100%.

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

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

Description explicitly states the tool returns available exchanges in TraderSpy smart-money tracking, using a clear resource (exchanges) and context, distinguishing it from sibling get_* tools.

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

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

Provides clear when-to-use guidance ('when the user asks which exchanges are currently available'), but does not explicitly mention alternatives or exclusions.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that the tool computes aggregate stats and supports optional filters, but it does not describe any additional behavioral traits such as exactly which stats are computed or how period affects results.

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 one concise, front-loaded sentence that immediately states when to use the tool and what it does. 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?

Given this is a simple read-only aggregation tool with two optional parameters, a rich input schema with enums and defaults, and an output schema, the description is sufficient. It tells the agent what the tool offers and how the optional filters apply.

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 100% and both parameters have descriptions (period for closed position stats, source as exchange filter). The description's mention of scoping by source and period is consistent but does not add meaningful semantics beyond an already well-documented 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 identifies the tool as the one for aggregate market stats (positions, PNL, win rate), and the optional source/period scoping adds useful specificity. It doesn't explicitly contrast with sibling tools, but 'aggregate' and the stat types help differentiate it from get_positions, get_my_account, and get_signal_stats.

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

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

The description provides clear invocation guidance: use when the user asks for aggregate market stats, optionally scoped by source and period. It does not name alternative tools or explicitly say when not to use it, so it stops short of full 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. The description adds valuable context beyond annotations by listing the specific types of data returned (Hyperliquid balance, open positions, unrealized PnL, paper-trading account, agent trading status) and the required authentication context. It does not contradict annotations and gives the agent a clearer picture of tool scope.

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

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

The description is two concise sentences with no filler. The first sentence front-loads the purpose and usage, the second adds the key prerequisite. 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?

Given that this is a simple read-only tool with no params and an output schema exists, the description covers all necessary context: when to use, what data to expect, and special requirements. It is complete for an effective selection and 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 0 parameters, so the schema is empty. The description adds meaning by clarifying that no input is needed and the tool returns a set of account-related data points. Since 0 params triggers a baseline of 4, and the description effectively communicates the tool's behavior, this score is appropriate.

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 that the tool retrieves the user's own TraderSpy account info, specifying exact data points (balance, positions, PnL, paper-trading status, agent trading enabled). It distinguishes itself from siblings like get_positions (likely for other accounts) and get_trader_profile by emphasizing 'their own' account.

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 opening 'Use this when the user asks about THEIR OWN TraderSpy account' provides explicit usage context. It also gives a prerequisite (personal MCP connection). However, it doesn't explicitly name alternative tools to use for other account types, so it lacks a full 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, destructiveHint=false, and idempotentHint=true. The description adds the historical/current scope and filter capabilities, but does not describe return format or pagination behavior. Given the annotations cover the safety profile, the added context brings it to a moderate level.

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 trigger ('Use this when') and fills in scope and filters. No wasted words.

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

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

Given the rich schema (all params with descriptions), strong annotations, and presence of an output schema, the description covers the essential purpose and use context. It lacks an explicit contrast with get_trader_position_history, which would make it more complete in a sibling-rich environment.

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

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

Schema description coverage is 100%, with each parameter having a clear description. The description repeats the filter dimensions (status, source, symbol) without adding new meaning or format details, so it lands at the baseline for well-covered schemas.

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 specifies the tool retrieves smart-money positions, with scope (current/historical) and filter dimensions (status, source, symbol). This distinguishes it from the more specific sibling get_trader_position_history, though it does not explicitly name that alternative.

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 clear context: use when the user asks for current or historical smart-money positions, with optional filters. It lacks explicit exclusions or named alternatives, but the trigger condition and scope are well-defined.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false. The description aligns with these (fetches data, no writes). It adds behavioral detail about what data is returned (current price, high/low, volume, change), which is useful. However, it does not disclose details like rate limits, potential symbol validation, or handling of invalid symbols. With annotations covering the safety profile, the description adds some value but isn't rich on edge-case behaviors.

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, front-loads the main purpose, and wastes no words. Every sentence provides value: the first defines the action, the second lists return data. It is appropriately concise 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 the tool's simplicity (one parameter, read-only, output schema exists), the description is complete enough for selection and invocation. It lists key return data. It does not describe all output schema fields, but the output schema likely covers that. Minor gap: no mention of error handling or symbol format beyond the example, but this is minor for a price-query 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 schema covers 100% of the one parameter ('symbols') with a description and example. The tool description adds context about what the data is used for (real-time price data) but does not add meaning beyond the schema's parameter description. Given high schema coverage, baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Get real-time price data for one or more crypto futures symbols.' It specifies the resource (price data), the action (get), and the scope (one or more symbols). It also lists the returned data points (current price, 24h high/low, volume, 24h change). This distinguishes it from siblings like get_candles or get_market_stats, which likely focus on different data types.

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

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

The description implies usage for fetching current prices, but does not explicitly state when to use this tool versus alternatives. For example, it doesn't say 'use this for live spot-price queries, use get_candles for OHLC history' or reference siblings. The context of 'real-time' and '24h' data gives some implicit guidance, but explicit differentiation or when-not-to-use scenarios are absent.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is known. The description adds that it includes 'review and resolution data', which is useful but does not describe handling of missing IDs or response structure. This is comparable to the calibration example, where annotations cover safety and the description adds minimal behavior 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?

A single front-loaded sentence that immediately states purpose and includes the key constraint (by ID). Zero waste, effective for an agent.

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

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

Simple tool with one param (100% schema coverage), read-only annotations, and an output schema available. The description tells the agent exactly what it returns (full details, review and resolution data) and the condition (by ID), which is complete for this type of lookup tool.

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

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

Schema coverage is 100% with the parameter 'signalId' described as 'The ID of the signal to retrieve'. The description reinforces that it's an ID-based lookup but does not add new semantics beyond what the schema already states. Baseline 3 is appropriate.

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 explicitly states the action ('retrieve'), the resource ('one AI signal by ID'), and the scope ('full details... including review and resolution data'). It clearly distinguishes from listing signals, making the purpose unambiguous.

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

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

The description opens with 'Use this when the user needs full details for one AI signal by ID', which is a clear usage trigger. However, it does not explicitly name alternative tools for listing signals or when to use them, though the phrasing implies a single-item retrieval by ID.

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, idempotentHint=true, destructiveHint=false, and openWorldHint=false. The description adds key behavioral context beyond this: it explains the tool fetches 'recent public AI crypto trading signals' and crucially, it reveals a rendering constraint—the card view displays exactly what was fetched, which affects how parameters should be passed. This trades on the annotation safety profile while adding genuine value about the UI coupling.

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?

Two sentences, zero fluff. The first sentence explains what the tool does and its filter options; the second explains a subtle parameter-mapping requirement with a concrete example ('last 5 signals' → limit). Every phrase 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?

This is a read-only, filtered-list tool with excellent annotations (readOnlyHint, idempotentHint, destructiveHint), a 100%-documented schema, and a clear sibling landscape (get_signal_details, get_signal_stats, get_market_stats). The description fills the one remaining gap—the UI coupling to the limit parameter—making this complete for an agent to invoke correctly.

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

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

Schema description coverage is 100%, with every parameter already documented in the schema. The description adds value for the `limit` parameter by explaining that when the user names a count, it should be passed as `limit`—context not present in the schema. While it doesn't enumerate all parameters, the schema already does that job well, so the description appropriately focuses on the semantically important parameter.

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 what the tool does: 'Use this when the user asks for recent public AI crypto trading signals, optionally filtered by coin, importance, or pagination.' It includes specific filter dimensions and is distinguishable from sibling tools like get_signal_details and get_signal_stats by referring to 'public AI crypto trading signals'.

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 for recent public AI crypto trading signals...' It also provides a critical exclusion/edge case: when the user names a count, pass it as `limit` to avoid over-fetching, since 'the card view renders exactly what was fetched'. This behavior is unique to this tool and not covered by siblings, making the guidance highly 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, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe read operation. The description adds the 'aggregate' and 'over a specific period' scoping, which is useful. However, it doesn't mention any additional behavioral details such as return format aggregation level, or performance implications. Given the annotations cover the safety profile, the description adds modest value beyond the structured data, so a score of 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 a single sentence that is concise and front-loaded with the usage trigger. It earns its place by providing the primary use case. It could have been slightly more explicit about the output being aggregates, but it's efficient and appropriately sized.

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 low complexity (1 optional parameter with enum), full schema coverage, and presence of an output schema, the description is sufficient to complete the tool's documentation. The output schema likely explains the return structure, so the description doesn't need to. The only minor gap is explicit differentiation from get_signal_details, but overall the tool is adequately complete.

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

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

Schema description coverage is 100% (the only parameter 'period' is fully documented with enum and default). The description mentions 'specific period' but doesn't add format or usage details beyond the schema. The baseline for full coverage is 3, and the description doesn't meaningfully exceed it. The parameter is simple and self-explanatory from the enum values.

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

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

The description clearly states the tool's purpose: retrieving aggregate AI signal performance statistics for a specific period. It uses a specific verb-resource combination ('get ... signal performance statistics') and is distinguishable from siblings like get_signal_details (which likely returns individual signal details) and get_signals (which likely lists signals). However, it doesn't explicitly name a sibling alternative when to use another tool, so it doesn't maximize 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 begins with explicit guidance: 'Use this when the user asks for aggregate AI signal performance statistics over a specific period.' This clearly tells the agent the trigger condition. It doesn't specify when not to use it or name alternatives like get_signal_details for individual signals, but the context is clear enough for an agent to select it appropriately.

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, idempotentHint=true, and destructiveHint=false, so the read-only nature is covered. The description adds no extra behavioral context beyond listing indicators, such as performance implications of computing many indicators or data availability constraints. With annotations present, this is a minimum acceptable score.

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

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

The description is a single sentence, front-loaded with the verb and resource, and lists indicators efficiently. It is concise without redundancy, though the list of indicators is long but necessary for clarity.

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

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

Given the output schema exists (though not shown), the description needn't explain return values. Complexity is moderate with 13 indicators. The description is complete enough: it covers the essential inputs (symbol and timeframe) and the indicator list, making it suitable for agent selection and 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 covers 100% of parameters with descriptions for each (symbol, interval, indicators). The description lists all indicator names but does not add detail like default periods or how to specify multiple indicators beyond the schema. Baseline 3 is appropriate since schema does the heavy lifting.

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

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

The description clearly states the verb 'compute' and the resource 'technical indicators' for crypto futures, enumerating all supported indicators. It distinguishes from siblings like get_candles (raw data) and get_price (simple price), though it does not explicitly name alternatives.

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

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

The description implies usage for computing indicators on a symbol and timeframe, but does not provide explicit when-to-use or when-not-to-use guidance versus siblings. It lacks exclusions or alternative tool mentions, so it's adequate but not fully 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, idempotentHint=true, and destructiveHint=false, covering safety. The description adds no behavioral details beyond what annotations provide, but it doesn't contradict them. With annotations present, a baseline of 3 is appropriate; the description adds minimal extra 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 a single, front-loaded sentence that conveys the purpose and usage in a compact way. No fluff, no redundancy, 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?

The tool has an output schema, so return details are covered. The description covers the core use case with sorting/filtering mentioned. It's complete enough for a straightforward read-only query tool, though it could optionally note the ranking types or exchange scope, but these are in the schema.

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

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

Schema description coverage is 100%, with all 6 parameters fully documented including enums, defaults, and descriptions. The description itself adds no parameter details beyond what's in the schema, so baseline 3 is correct. It doesn't compensate further but also doesn't need to.

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 ranked smart-money traders with sorting and filtering, which is a specific verb+resource. It distinguishes from siblings like get_elite_leaderboard by focusing on 'smart-money traders' and 'sorting and filtering', but it doesn't explicitly name alternatives.

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

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

The description gives an explicit trigger condition ('Use this when the user wants ranked smart-money traders...'), which is clear usage context. However, it doesn't provide when-not-to-use guidance or explicitly mention alternative tools, so it falls short of a 5.

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, idempotentHint, and destructiveHint, covering the safety profile. The description adds context about 'currently tracked' and 'real-time candle data available', which hints at dynamic state but does not disclose any additional behavioral traits like rate limits or caching. Given the annotations, the description provides modest extra value beyond the structured metadata.

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 sentence of about 15 words, front-loaded with the action 'List all'. It contains no redundant phrases or filler. Every word contributes to the meaning—specifying the asset class, the filter, and the data availability. This is exemplary conciseness.

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 with an output schema present, the description fully captures what the tool does. It states the resource (symbols), the domain (crypto futures), the tracking context, and a key property of the data (real-time candles). No additional behavioral details are necessary given the annotations and the presence of 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?

There are no parameters (0 params), so the baseline is 4 per the rubric. The description does not attempt to explain parameters, which is appropriate. It adds meaning by describing the output scope, but that is not parameter-related. The schema coverage is 100% (empty schema), so no compensation is needed.

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 strong verb 'List' and clearly specifies the resource: 'crypto futures symbols currently tracked by TraderSpy'. It also adds a distinguishing condition ('with real-time candle data available') that differentiates it from sibling tools like get_candles or get_price. This is a precise and unambiguous purpose statement.

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 by stating the scope (tracked symbols with real-time data), but it does not explicitly mention when to use this tool versus alternatives. Sibling tools like get_candles or get_price are not referenced, and there is no guidance on exclusions or prerequisites. The usage context is inferred but 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, idempotentHint, and destructiveHint, covering most safety-relevant behavior. The description adds minimal behavioral context beyond the 'closed' trade history distinction, so it does not significantly enhance transparency beyond annotations.

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

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

The description is a single, front-loaded sentence with no filler or redundant phrasing. It states the exact trigger and scope efficiently, making it easy for an agent to quickly understand applicability.

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

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

Given the comprehensive input schema with 100% description coverage, output schema, and safety annotations, the single-sentence description is largely sufficient for a straightforward read-only paginated endpoint. It lacks explicit mention of pagination or ordering, but these are adequately covered by the structured schema data.

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

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

All four parameters are fully described in the input schema, including the meaning of traderId, page, limit, and source exchange. The description itself adds no parameter-level details, so the schema carries the full burden; the high schema coverage supports the baseline 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 explicitly states the tool is for retrieving closed trade history for a specific trader, providing a clear resource and scope. It distinguishes itself from sibling tools like get_positions (open positions) and get_trader_profile, though it does not name them explicitly.

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 phrase 'Use this when...' gives clear contextual guidance for when to invoke the tool (closed trade history of a specific trader). It does not provide explicit exclusions or alternatives, but the context is specific enough to discourage misuse.

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, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds useful scoping context ('metrics and latest positions') but doesn't go beyond what the annotations and output schema already convey. 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?

The description is a single front-loaded sentence with no filler. It efficiently communicates both the trigger condition and the tool's primary output scope.

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

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

Given the tool's simplicity, rich output schema, and strong annotations, the description is adequate and complete for selection. It could optionally note the relationship to get_trader_position_history, but that sibling already appears in the tool list and the description still covers key information.

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

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

The schema provides full descriptions for all four parameters, so coverage is 100%. The description does not add extra parameter semantics, merely echoing the general content (metrics and positions) without detailing how parameters map to results.

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: retrieving a single trader profile including metrics and latest positions. The phrase 'one trader profile' distinguishes it from sibling list/leaderboard tools like get_top_traders and get_elite_leaderboard.

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 begins with 'Use this when the user needs one trader profile,' providing an explicit usage context. However, it does not mention exclusions or directly name alternative tools for other scenarios, so it falls just short of full when/when-not guidance.

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