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

The annotations already indicate readOnlyHint=true and openWorldHint=true. The description adds substantial behavior beyond that: the exact index formula (share of top 50 Binance perpetual altcoins beating BTC over trailing 90 days), the altseason/bitcoin-season thresholds (>=75 / <=25), the inclusion of strongest/weakest alts, and the caveat that daily history is 'never reconstructed.' This is rich, honest behavioral disclosure.

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 user-intent triggers before the return details. Every clause carries useful information: formula, thresholds, return contents, and the reconstruction caveat. 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?

With no parameters and no output schema, the description carries the full burden and fulfills it: it covers when to call, what the indicator measures, how the index is classified, what outputs to expect, and a data-quality warning. Nothing essential is missing for an agent to decide whether and how to invoke this 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 and the schema is 100% covered with an empty properties object. There are no parameter semantics for the description to clarify, so the baseline of 4 applies; the description already explains what data will be returned.

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 explicit call conditions ('Call this when the user asks whether it is altseason, how altcoins are doing against Bitcoin, or about market rotation') and precisely names the resource: the live Altcoin Season Index plus recorded history. It also defines the index calculation and thresholds, making the tool's purpose unmistakable and clearly distinct from generic market index tools.

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

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

The description gives strong, explicit when-to-use guidance: altseason questions, altcoin-vs-Bitcoin performance, and market rotation. It does not name alternative sibling tools or state when not to use it, so it stops short of full exclusionary guidance, but the provided context is sufficient for correct routing in most cases.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the description adds value by detailing the output fields (daily premium, 7-day average, streak, last 30 days, carry yields) and the interpretation of positive premium as US buying pressure. No contradiction; it supplements the annotations with useful 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 concise (four sentences), front-loaded with the usage trigger, then return values, then historical depth and interpretation. Every sentence contributes valuable information without redundancy.

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

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

Given no output schema and no parameters, the description fully covers what the tool returns (latest premium, averages, streaks, 30-day history, carry yields) and how to interpret it. It also mentions historical coverage since 2017, making it complete for this straightforward 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 the baseline is 4. The description does not need to explain inputs and instead focuses on output semantics, which is appropriate and sufficient for a parameterless tool.

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

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

The description clearly defines the tool as a gauge for US buying/selling pressure via Coinbase Premium, explicitly naming the metric and the related carry yield. It distinguishes from siblings by referencing specific topics such as Coinbase Premium and cash-and-carry basis trade, which are unique among 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?

Provides explicit trigger conditions ('Call this when...') for user queries about US investor activity, Coinbase Premium, or carry trade yield. However, it does not mention alternatives or when not to use this tool, so it lacks exclusionary guidance that would elevate it to 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 provide readOnlyHint and openWorldHint, covering the safety profile. The description adds substantive behavioral detail: Pearson correlation, 30-day rolling window, daily returns, and top perpetuals as the universe. This meaningfully explains what computation the tool performs 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?

Two sentences, each earning its place: the first gives trigger scenarios and the second describes the output. No fluff, and the use cases are 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?

With no parameters and no output schema, the description explains the return value well, including method, window, and data universe. It could be slightly more specific about what 'top perpetuals' means or how an agent extracts a pair-specific answer from the matrix, but for a zero-param tool this is largely complete.

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

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

The tool has zero parameters, so schema description coverage is trivially 100% and there is no param info to add. The description appropriately omits param details, and the baseline for zero-param tools 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 names a specific verb and resource: 'Returns the 30-day rolling Pearson correlation matrix of daily returns across the top perpetuals.' It also lists concrete user intents (two-coin correlation, decorrelated pairs, alts tracking BTC), making it clearly distinguishable from the sibling analytics tools.

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

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

The description explicitly says 'Call this when the user asks' and gives three representative queries, which tells the agent when the tool is appropriate. It does not explicitly name alternatives or state when not to use it, but the context is clear enough for selection among the large sibling list.

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

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

Beyond the readOnlyHint annotation, the description adds valuable behavioral context: data source (official CFTC), update frequency (every Friday), and an important interpretation caveat about hedge fund shorts being basis trades. This helps the agent understand the data's nuance and reliability.

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—three sentences that front-load the call instruction, then detail the return contents, and end with a note. Every sentence serves a purpose with no redundancy.

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

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

Even without an output schema, the description names the specific data returned (net positions, week-over-week changes, open interest, extremes/streaks) and the source/update cycle. This is sufficiently complete for an agent to invoke the tool and interpret results 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 the schema is empty. The description compensates by stating the scope (BTC and ETH CME futures) and the output dimensions, adding meaning beyond the bare schema. Baseline 4 for zero params 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 identifies the tool's function: retrieving CFTC Commitments of Traders positioning data for Bitcoin and Ethereum futures. It distinguishes itself from sibling tools (e.g., get_etf_flows, get_open_interest) by focusing specifically on trader categories and the weekly COT report.

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 states when to call: 'when the user asks how hedge funds or institutions are positioned in Bitcoin or Ethereum, or about the CFTC Commitments of Traders report.' This provides a direct trigger and implicitly differentiates it from alternatives like total open interest or ETF flow tools.

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

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

Annotations declare readOnlyHint and openWorldHint. The description adds that results are one row per finalized US trading day, denominated in USD, and covers about 14 months of history, providing a clear picture of data granularity and temporal range.

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, front-loaded with usage instruction, followed by a compact description of output fields and data history. No redundant phrases.

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 fully explains the output structure (row per day/asset, fields), which compensates for the lack of an output schema. It also covers history length and data currency, making it sufficient for the tool's simple interface.

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 already provides 100% parameter descriptions (days and asset). The description does not add additional parameter-level detail, so it meets the baseline but does not exceed it.

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 direct instruction ('Call this when the user asks about Bitcoin or Ethereum ETF flows') and enumerates specific metrics (daily net inflows/outflows, cumulative flow, total net assets) and example ETFs (IBIT, FBTC, ETHA). This clearly distinguishes it from sibling tools focused on different market data.

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

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

The description explicitly states when to invoke ('when the user asks about Bitcoin or Ethereum ETF flows') and outlines the range of queries it satisfies. It does not mention alternatives, but no sibling tool covers ETF flows, making the use case unambiguous within the toolset.

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 openWorldHint annotations, the description discloses the n >= 30 gate, the median 7-day BTC move vs base rate, and that results are distributions rather than forecasts. This gives the agent meaningful expectations about the output 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?

Two dense sentences lead with use cases and then describe the output format and qualifications. Every clause carries useful information, and the 'distributions, not forecasts' phrase is a compact yet critical disambiguation.

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 parameters and no output schema, the description fully carries the burden of explaining what the agent will receive: every recorded metric, its historical band, median 7-day BTC move, base rate comparison, and sample-size gate. This is sufficient for a no-argument read-only 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 input schema has zero parameters and 100% coverage, so there is no parameter semantics for the description to add. A baseline of 4 is appropriate because the tool takes no arguments and the description cannot meaningfully elaborate on 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 states a specific resource ('factor board') and the exact function: returning recorded metrics in their historical band with the median following BTC move. It distinguishes itself from siblings by emphasizing a cross-metric conditional overview and explicitly noting 'distributions, not forecasts.'

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 trigger scenarios: unusual-band indicators, historical precedent for BTC moves, or cross-metric conditional overview. It does not name specific sibling alternatives or say when not to use this tool instead of another, but the 'not forecasts' clause offers a mild exclusion.

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 openWorldHint, but the description adds meaningful behavioral context: the VPIN scale (0=balanced, 1=fully one-sided), the 90-day percentile, the danger threshold, and the 24h average. It also notes that elevated readings historically precede volatility and warns that VPIN says nothing about direction, which goes beyond the annotation cues.

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-loaded with the 'Call this when' instruction, followed by a concise explanation of return values and interpretation. Every sentence earns its place with no fluff.

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

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

With no output schema, the description fully carries the burden of explaining return values and their meaning. It specifies the current VPIN, percentile, threshold, and 24h average, and provides interpretative guidance. The tool is simple (no params) and the description covers all necessary context.

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

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

The tool has zero parameters, so the baseline is 4. The description adds no parameter-specific details (there are none); it is adequate given the empty schema.

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

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

The description clearly states the tool's purpose: detecting informed or toxic order flow via VPIN for BTC, ETH, and SOL perps. It uses specific verbs ('Call this when...') and distinguishes itself from sibling tools by focusing on VPIN and order-flow toxicity.

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 tells when to use the tool ('when the user asks whether informed or toxic order flow is building, about VPIN, or whether market makers are under pressure'). It doesn't name alternatives or state when NOT to use it, but the trigger context is very clear, and the 'VPIN says nothing about direction' caveat subtly hints at scope limits.

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 carry readOnlyHint=true and openWorldHint=true, and the description adds meaningful context beyond them: the closing caveat "Description, not prediction" tells the agent these are retrospective statistics rather than forecasts, preventing a whole class of misuse. It also discloses the data provenance ('measured from a minute-resolution record') and the statistical framing ('near a coin flip'). 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?

Three sentences, each earning its place: the first front-loads usage triggers, the second enumerates return fields, the third delivers the critical epistemic caveat. No filler, no repetition of the title or schema, and the most important routing information comes 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 0-parameter read-only tool with no output schema, the description is fully sufficient: it covers when to call, what data comes back, and how to frame the results. The one thing it omits (exact numeric formatting) is minor against the low complexity and the fact that annotations already cover safety.

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 with 100% schema coverage, so there is nothing to document; the baseline of 4 applies. The description instead productively covers return semantics — per-statement 5/30/60-minute BTC reactions, average move versus a normal half hour, up/down split, and next meeting date — which is the information the agent actually 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 opens with specific trigger scenarios — "what Bitcoin does on Fed days, how FOMC statements move crypto, or when the next FOMC meeting is" — and scopes the resource precisely as measured FOMC impact on Bitcoin. This clearly distinguishes it from the 33 siblings; no other tool in the list is FOMC-specific, so an agent can route correctly without opening schemas.

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 first sentence gives explicit, concrete when-to-use triggers phrased as call conditions. It doesn't name alternatives or say when not to use it, but for a 0-parameter informational tool the three trigger phrases are specific enough to make misrouting unlikely. This matches 'clear context, no 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 declare readOnlyHint=true, so safety is known. The description adds valuable behavioral detail: it compares funding across 6 specified exchanges for 12 major perps and returns both gross and net APR (net of taker fees and weekly rebalance cost). This exceeds the annotation baseline without contradiction.

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

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

The description is two sentences: the first gives the usage trigger, the second explains the computation and output. It is front-loaded, specific, and contains no redundant information relative to the schema/annotations.

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

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

For a no-parameter tool without an output schema, the description provides a solid summary of the output: best long/short venue per symbol with gross and net annualized APR. It could specify whether this is current data or a snapshot, but the core expectations are clearly set.

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, and the input schema is empty, so the baseline for 0 params is 4. The description does not need to elaborate on parameters and instead focuses on what the tool computes and returns, which 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 function: it compares funding rates across multiple exchanges and returns best long/short venues with APR. It explicitly mentions funding arbitrage, funding rate differences, and delta-neutral carry trades, distinguishing it from sibling tools like get_funding_heatmap.

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 'Call this when the user asks about funding arbitrage, funding rate differences between exchanges, or delta-neutral carry trades,' providing clear when-to-use guidance. However, it does not mention when not to use the tool or suggest alternatives, 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 include readOnlyHint=true, which the description agrees with by describing a read-only query. Beyond that, it adds valuable behavioral context: contracts without a live funding print are skipped, returns include funding rate per settlement interval, 24h open interest change, and 24h price change, and positive funding means longs pay shorts. 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?

Three sentences, each with a distinct job: trigger/scope, alternative routing, and return field details. It is front-loaded with the main use case and contains minimal redundancy, though the scope ('~30 most traded Binance perps') is restated in both the title and the return-spec sentence.

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 and minimal annotations, the description carries the burden of explaining return values and behavior. It covers the data returned per symbol, the skip condition, the row count, and the meaning of positive funding. There is no missing information needed to invoke the tool correctly, aside from minor unit details for the 24h changes.

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% for the single optional symbol parameter, with examples (BTCUSDT or BTC) and the default behavior (omit to get all 30 rows). The description's mention of 'funding rate of one specific coin' aligns with the schema but does not add new semantic content, so 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 opens with the specific trigger ('when the user asks for the full current funding table...') and names the exact resource and scope (~30 most traded Binance perps, 28-30 rows). It also states the alternative for top-10 rankings (get_top_movers), distinguishing this tool from the closest sibling. The return fields are listed, making the tool's purpose unambiguous.

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

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

Explicitly states when to call: for the full current funding table or the funding rate of one specific coin. It also gives an explicit exclusion: use get_top_movers for a pre-ranked top-10 of the most extreme funding rates. This is clear routing with no inference 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 a data-source detail ('from the daily Deribit chain') and what the returned surface contains, but does not disclose potential limitations such as data lag, snapshot timing, or how open-world data affects results. This is adequate but not rich.

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 front-loads the usage trigger and then compactly enumerates the return components. Every phrase adds value, and no filler or redundant restatement of the title appears.

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

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

Despite lacking an output schema, the description spells out the major return fields: IV surface by expiry/moneyness, per-expiry ATM and 25-delta put/call IV, skew, butterfly, and constant-30d history. With only one optional parameter and annotations covering read-only/open-world behavior, an agent has enough to call and interpret the tool correctly.

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

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

Schema description coverage is 100% for the single optional currency parameter, so the schema already documents it fully. The description does not need to repeat parameter details and adds no extra meaning beyond the schema; the baseline of 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 states a specific verb ('get') and resource ('options implied-volatility surface and 25-delta skew') and enumerates the exact types of user questions it addresses. It clearly distinguishes itself from the many sibling tools by focusing on IV, skew, and term structure.

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 opens with 'Call this when the user asks about...' and lists concrete use cases like skew, put versus call IV, and downside protection cost. It does not name alternatives or state when not to use the tool, but the usage context is clear enough for an agent to route correctly.

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 readOnlyHint and openWorldHint annotations cover the safety profile, and the description adds valuable behavioral context by specifying the exact output: per-pair daily cross-correlations at lags -3..+3, lead asymmetry, and share of days each venue led. This goes beyond the annotations without contradicting them.

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

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

Two sentences carry exactly the needed information: when to invoke the tool and what it returns. The trigger is front-loaded and every phrase contributes meaning.

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 tool with no output schema, the description is complete. It explains both the query conditions and the returned metrics, so an agent can correctly select and invoke it without further elaboration.

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 semantic burden on the description. The baseline for a zero-parameter tool is 4, and the description appropriately needs to add no parameter-level detail.

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 resource and function: venue lead-lag across Coinbase, Kraken, and Binance. It begins with an explicit call trigger and clearly distinguishes this tool's domain (who moves first) from the many sibling market 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?

It provides an explicit 'call this when' statement covering both exchange lead-lag and spot-vs-perp lead questions. However, it does not explicitly name alternative tools or state when not to use this tool, so it stops 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?

The annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds meaningful behavioral context beyond the annotations: the public tier is restricted to the 24h view, other intervals are member-only, and the data comes from six venues.

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 sentences, each earning its place: the first gives the usage trigger, the second describes the return contents, and the third notes the public-tier limitation. It is front-loaded and free of 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 single-optional-parameter read-only tool with rich schema coverage and no output schema, the description is complete: it states what the tool returns, the scope limitation, and the data source. There is no missing information an agent would need 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?

There is only one parameter, and the schema already fully describes it, including allowed pattern, example 'BTCUSDT', acceptance of bare BTC, and default value. The description adds no additional parameter semantics, so the baseline score of 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 names a specific trigger ('where liquidation clusters or liquidity pools sit'), specifies the resource (LiqMap snapshot for one symbol), and details what it contains: modeled liquidation levels, zone aggregates, and real prints from six venues. The title adds 'estimated liquidation clusters with real prints overlaid,' which helps distinguish it from related liquidation tools.

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

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

The opening sentence gives explicit conditions for when to call the tool, including user phrasings like 'liquidation heatmap reading.' It does not explicitly name alternative siblings or state when not to use it, but the trigger context is clear enough for routing.

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 and openWorldHint, and the description adds meaningful behavioral context beyond them: results are auto-detected, totals are an honestly-labeled lower bound, and the data comes from a real liquidation tape. This manages expectations about data completeness and provenance 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 compact and front-loaded: the trigger condition appears first, followed by the output contents, then the important caveat about lower-bound totals. Every sentence earns its place and there is 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 no-argument, read-only tool with no output schema, the description covers when to call it, what data it returns, and a key limitation. It could go slightly further on output formats or explicitly distinguish itself from get_liquidations for raw per-liquidation data, but it is sufficient for selecting and invoking the tool correctly.

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

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

The tool has zero parameters and an empty input schema, so there is no parameter semantics to document. Per the baseline for zero-parameter tools, a 4 is appropriate; the description's focus on output fields is correct and does not need to compensate for missing parameter docs.

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 names the resource (auto-detected liquidation cascades), specifies the action (returns cascade incidents), and enumerates the returned fields (when, total notional flushed, long/short split, leading coins, BTC's move). This differentiates it from siblings like get_liquidations by emphasizing cascade incidents and the forensic case-file framing.

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 explicit trigger conditions: 'Call this when the user asks what caused a recent crash or flush, about liquidation cascades, or who got liquidated.' This gives clear context for when to use the tool, but it does not name alternatives or explicitly state when not to use it, 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?

The annotations only indicate read-only and open-world behavior, so the description carries the burden of explaining data provenance and interpretation. It adds strong context: events are recorded from specific exchange stream collectors, are a floor rather than estimates, are finalized per UTC day, and history begins on a known date and grows daily. This goes well beyond what annotations or schemas disclose.

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 call trigger, then provides a dense but efficient second sentence covering output, units, granularity, source, caveat, and history. Every clause adds useful information and there is no repetition of the title or 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?

There is no output schema, so the description must explain what the agent can expect in the result, and it does: daily long/short totals in USD, per symbol and exchange, one row per finalized UTC day, plus the data availability start date. The call pattern is also complete: an optional symbol filter and a default days window are both covered. Nothing essential is missing for a tool of this complexity.

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

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

The input schema already provides 100% coverage for both parameters: days has a default and range, symbol has a pattern and meaning. The description reinforces the output granularity (per day, symbol, exchange) but does not add any new parameter-level semantics beyond what the schema documents, so the baseline score of 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 states exactly what the tool does: returns daily long and short liquidation totals in USD per symbol and exchange for crypto futures. It also names concrete user queries ('how much was liquidated', 'whether longs or shorts got flushed', 'liquidation history'), making the purpose unmistakable even among many sibling tools.

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

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

The description explicitly says when to call the tool ('Call this when the user asks how much was liquidated...', 'or for liquidation history'). It does not name alternatives or state when not to use it, such as pointing to get_liquidation_cascades for cascade-specific analysis, so it falls just short of full 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 include readOnlyHint=true and openWorldHint=true, and the description does not contradict them. It adds useful return behavior by stating it 'Returns the recorded daily series and latest values,' which partially compensates for the missing output schema, though it leaves out details like units or time 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?

Two tight sentences: the first gives usage guidance, the second states the return behavior. There is no filler, and the title adds complementary detail without bloating the description.

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

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

Given a single optional parameter, read-only annotations, and no output schema, the description provides enough for an agent to decide when to call the tool and roughly what to expect in return. It could briefly mention sample data fields or coverage, but the tool is simple enough that this is not a critical 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 documents the only parameter, days, completely with type, min, max, and default. The description adds no additional meaning beyond the schema, so the baseline score of 3 applies because the schema carries the semantic weight.

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 trigger phrase ('Call this when the user asks about macro liquidity, the Fed balance sheet, reverse repo, rates or stablecoin supply') and clearly identifies the resource: recorded daily macro liquidity series with latest values. The title further enumerates the exact components (Fed funds, 10y, balance sheet, RRP, stablecoin supply), distinguishing it from sibling tools that cover price, flows, or sentiment.

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 conditions for when to call the tool, listing concrete user topics such as macro liquidity, Fed balance sheet, reverse repo, rates, and stablecoin supply in relation to crypto. It does not mention specific alternatives or when-not-to-use scenarios, but the trigger list is clear enough to route an agent correctly.

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 openWorldHint. The description adds useful context: the refresh interval (~30 minutes) and the specific components included (today/yesterday's Fear & Greed, Bitcoin dominance, total market cap, Retail Euphoria). This goes beyond the annotations without contradicting them.

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

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

The description is two sentences, front-loaded with the usage trigger, and packs detailed data points without redundancy. Every sentence earns its place with no fluff.

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

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

Given the tool's simplicity (no parameters, no output schema, simple data retrieval), the description is fully complete: it states what to call it for, what data it returns, and the refresh cadence. No critical information 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?

The tool has zero parameters, so the schema provides no semantics. The baseline for 0 params is 4. The description compensates by explaining exactly what data will be returned, making the parameterless invocation clear.

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: answering questions about overall crypto market sentiment or macro state. It lists specific data points (Fear & Greed, BTC dominance, total market cap, Retail Euphoria) and distinguishes itself from sibling tools that focus on narrower metrics like funding, liquidations, or options flows.

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 tells when to use the tool ('when the user asks about overall crypto market sentiment or macro state'). It does not explicitly mention alternatives or when not to use it, but the sibling list provides context and the instruction 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?

The description goes well beyond the annotations by disclosing key behavioral traits: buckets under 30 days are suppressed, most metrics do not separate from the base rate, and the interpretation says so plainly. It also specifies the concrete outputs (median forward BTC return and up-share at +1/+3/+7 days with the all-days base rate), which is valuable given there is no output schema.

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

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

The description is front-loaded with the primary use case, then delivers mechanics, honesty rules, and the supported metric list in a compact sequence. Every sentence adds decision-relevant information, and the length is justified by the need to convey conditional-distribution behavior and interpretation caveats.

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 what the tool returns, how the bucketing works, the interpretation caveat, and the supported metric candidates. Nothing essential is left for the agent to infer.

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 already fully documents the single `metric` parameter with examples and a pattern, so the baseline is 3. The description adds extra semantic value by enumerating the full supported metric set and clarifying that the metric must be a 'recorded metric' with daily history, which helps the agent pick valid 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 states a precise trigger condition and resource: it explains the tool buckets a metric's current value against its own daily history to determine whether readings are high or low and what happened after similar readings. It clearly differentiates itself from a forecast and lists the exact metrics it supports, making its purpose unambiguous even among many sibling tools.

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

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

The description gives an explicit 'Call this when...' condition: when the user asks whether a metric reading is high or low, or what happened after similar readings. It also states 'History, not a forecast,' which is a useful exclusion. It does not name alternative tools, but no sibling tool appears to overlap directly, so the lack of explicit alternatives is not a significant gap.

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 openWorldHint, covering the safety profile. The description adds that data is measured on the node and returns both a daily series and latest values, but does not disclose freshness, rate limits, or failure behavior. This is acceptable but not rich.

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 with no filler. It front-loads the triggering condition and then states what is returned, making it easy for an agent to process quickly.

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

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

For a simple read-only tool with one optional parameter, the description is nearly complete. It explains when to call and what kind of data is returned. Without an output schema, a bit more detail about the exact response fields could help, but the current level is sufficient given the low complexity.

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

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

The single 'days' parameter is fully documented in the schema with range and default. The description does not need to add parameter details; the schema carries the burden, so 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 clearly specifies the resource (Bitcoin network health from ByKaranteli's own node) and the exact topics covered: hashrate, difficulty, fees, and mempool congestion. This distinguishes it from the sibling market-analysis tools even without naming them.

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

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

The description provides an explicit trigger: 'Call this when the user asks about Bitcoin hashrate, difficulty, fees or mempool congestion.' It gives clear usage context but does not mention exclusions or alternative tools.

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

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

Annotations already mark the tool as read-only and open-world, so the description does not need to restate safety. It adds useful behavioral context: the data comes from six exchanges, is refreshed by an hourly scan, and includes both listings and delistings.

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 with zero filler. The trigger conditions are front-loaded in the first sentence, and the second sentence states the return scope. 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 tool with one optional parameter and no output schema, the description adequately covers when to call it and what it returns. It could describe the response format, but the tool is simple enough that this omission 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 only parameter, days, is fully documented in the schema with range, default, and a note about paid data. The description adds no parameter-level detail, but the schema covers 100% of the parameter semantics, so the baseline of 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 names specific user intents: new perpetuals listed, which exchange listed a coin first, and delistings. It clearly distinguishes this tool from the broader market-data siblings by focusing on listing/delisting events across six exchanges.

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

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

Explicitly says 'Call this when the user asks...' and lists three concrete question types, giving clear routing guidance. It does not name alternative tools or exclusion criteria, but the usage context is clear enough for an agent to handle most listing/delisting questions.

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 cover read-only safety, and the description adds useful non-obvious behavior: 5-minute resolution, 24-hour deltas, and the exact regime categories per symbol. It does not contradict annotations, but it also does not mention data freshness, coverage limits, or any edge cases.

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 carrying full value: the first front-loads the exact user intent, the second compactly enumerates the return fields and regime labels. No filler or redundant phrasing.

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-param, read-only tool, this covers the trigger, scope, resolution, delta fields, and four possible regime labels. Nothing an agent needs to decide whether to call it or interpret its output 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?

There are zero parameters, so the baseline is 4. The description adds that the result is per symbol across major perpetuals, which is sufficient context for a parameter-less call.

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

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

The description starts with a specific trigger ('Call this when the user asks...'), identifies the resource (open interest for major perpetuals), and specifies the output contract (5-minute OI, 24h deltas, four-regime regime labels). This clearly separates it from siblings like funding heatmap or liquidations by tying it directly to leverage positioning.

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 gives explicit conditions for use: leverage entering/leaving the market, OI changes, or longs/shorts building. It does not name alternatives or provide when-not-to-use guidance, so it falls just short of full routing advice.

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 as read-only and open-world; the description adds useful behavior beyond that: 24h premium comparison, 48h window for prints, venue scope (Deribit/OKX), and a 15-minute refresh cadence. It does not specify how many prints qualify as 'largest' or their sort order, so it stops short of full 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?

Three sentences with no filler: trigger phrase, return summary, refresh cadence. Everything earns its place and the most decision-relevant info is front-loaded.

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

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

For a zero-parameter read-only tool, the description covers the essential return content, assets, venues, and recency. The main gaps are the lack of an output schema and the unspecified number/ordering of the largest prints, but these are minor given the description already enumerates the fields returned.

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 and schema coverage is 100%, so the baseline of 4 applies; the description adds no parameter semantics because there are none to document.

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 concrete trigger ('Call this when the user asks...') and names a precise resource: options flow, block trades, and 24h call vs put premium. The return fields (largest prints with strikes, premium, IV, venue) plus the BTC + ETH scope in the title make it clearly distinguishable from sibling tools like get_iv_surface or get_whale_tape.

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 states when to invoke this tool: when the user asks about big options players' buying, block trades, or call/put premium dominance. It does not explicitly name an alternative or spell out when-not-to-use, but the trigger conditions are clear enough for selection.

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

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

Annotations already declare readOnlyHint and openWorldHint, giving the safety profile. The description adds useful behavioral context: it is a daily snapshot (not real-time), and it enumerates the data components (top strikes by OI, put/call ratio, dealer hedging map, ATM IV by expiry). This exceeds the minimum but stops short of describing data sources or potential refresh times.

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, front-loaded with usage triggers and followed by a compact list of included data. Every sentence provides distinct value, and 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?

The description fully covers the typical user intents (walls, GEX, DVOL, term structure) and explicitly lists the output components, which is essential given the lack of an output schema. It is complete for a read-only, zero-parameter tool.

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

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

With zero parameters, the schema provides no parameter details. The description compensates by clarifying the asset scope (Bitcoin and Ethereum) and the content of the snapshot. Since there are no parameter names to explain, a baseline of 4 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 uses specific verbs and resources: 'where the big options bets sit', 'call/put walls', 'gamma exposure (GEX)', 'zero-gamma level', 'implied volatility (DVOL)', and 'IV term structure'. It clearly distinguishes from siblings like get_options_flow and get_open_interest by focusing on snapshot-level positioning and hedging data.

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

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

Explicitly starts with 'Call this when the user asks...' followed by a list of concrete triggers. This provides strong guidance on when to use this tool versus alternatives, though it does not name alternatives explicitly. The 'Daily snapshot' qualifier also frames the expected temporal scope.

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 valuable context by disclosing the 0-100 composite score inputs, the LONG/SHORT/NEUTRAL direction, and the plain-language regime label, which is important since no output schema exists. It could go further by stating the returned row/symbol field, but this is not a serious gap.

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

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

Three sentences with no wasted words. The first sentence carries the primary trigger, the second routes to an alternative tool, and the third explains the output composition. Important information is front-loaded, and 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 tool with two simple optional parameters and no output schema, the description supplies the essential operational context: when to use it, what it returns, how the score is composed, and which sibling to choose instead. The schema covers parameter details, and annotations cover safety, so nothing critical 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 100%, so the schema already fully documents limit and symbol, including defaults, sorting, and example formats. The description's mention of 'specific coins' and 'each symbol' weakly reinforces symbol semantics but does not add parameter-level meaning beyond the schema, so the 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 names a specific resource (derivatives pressure scores), a precise verb-purpose (responding to crowded/over-leveraged coin queries), and the exact composite construction (funding, OI deltas, basis). It also clearly separates itself from get_top_movers, making the tool's identity 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?

It explicitly states when to call this tool ('when the user asks which coins are crowded or over-leveraged, or asks for the pressure/derivatives-stress score of specific coins') and gives a concrete alternative for a different use case ('For a quick top-10 ranking of the highest-stress coins right now, use get_top_movers instead'). This is model 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 indicate readOnly and openWorld hints, and the description adds meaningful behavioral context: inputs are proprietary, outcomes are always published, and the tool is not to be over-interpreted as a signal or predictor. It also explains the meanings of each state, helping the agent set user expectations.

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 dense but front-loaded with the invocation trigger, followed by return fields and caveats. It is slightly long, and some information repeats the title, but every part still contributes useful context for selection and use.

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 tool with no output schema, the description covers the main return components, defines the state values, and sets expectations. Minor details like what exactly 'stress locality' or 'year-split measured scorecard' contain are left open, but they do not prevent 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 tool has zero parameters, so there is no semantic gap to fill; this matches the baseline 4. The description reinforces that no user-supplied inputs are required by stating inputs are proprietary.

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 resource (PsiCharge hidden liquidity state), the exact subject matter (parked money deploying, stress unwinding), and the returned fields. It distinguishes itself from sibling market-data tools by focusing on a proprietary liquidity-state model rather than generic market metrics.

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

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

It opens with an explicit 'Call this when the user asks...' trigger, which is strong usage guidance. It also gives exclusions ('Not a trade signal, not a crash predictor'), but it does not name alternative sibling tools or state when another tool should be chosen instead.

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

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

The readOnlyHint annotation already signals safety, and the description adds substantial behavioral context beyond annotations: it specifies the data source (ByKaranteli's own Bitcoin Core node), daily frequency, and provenance hashes for re-verification. This tells the agent exactly what kind of computation and guarantees are involved.

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 call trigger and then uses a compact, well-organized list to enumerate return fields. No sentence is wasted, and the provenance-hash detail earns its place because it justifies the verifiability claim.

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 to lean on, the description fully enumerates what the agent can expect: exposed BTC, share of held value, UTXO count, script-family composition, dormancy cohorts, watch set, and provenance hashes. This is complete enough for an agent to select the tool and interpret its result confidently.

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 schema description coverage is 100%, so there is no parameter surface for the description to clarify. The 0-parameter baseline of 4 applies; the description appropriately focuses on output semantics instead.

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 call condition and names the exact resource (quantum-exposed Bitcoin). It lists concrete synonymous user phrasings (quantum-exposed supply, P2PK coins, Satoshi-era exposure), making the tool's purpose unmistakable. It also clearly differentiates from the market-focused sibling tools, none of which cover quantum exposure.

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 call the tool ('Call this when the user asks...'), giving clear contextual triggers. It does not name alternatives or exclusion cases, but the sibling list contains no overlapping quantum-exposure tool, so the absence of explicit alternatives is not a meaningful gap.

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, the description discloses important behavioral traits: results are net of fees, slippage and funding; every signal has a SHA-256 receipt; and only live signals are included. It also states it includes a 24h summary (wins, losses, net bps), which adds return-context beyond the 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?

The description is two sentences, front-loaded with the trigger condition, followed by key output details and caveats. Every sentence earns its place 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?

Given no parameters and no output schema, the description is remarkably complete. It covers what the tool does, what data it returns (outcomes, net bps, 24h summary), and critical distinctions (live only, never backtests). No additional context seems missing for an agent to select and invoke this tool appropriately.

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 effectively 100%. The description does not need to explain parameters and instead adds context about the returned data. This matches the baseline of 4 for a 0-parameter tool.

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 returns recent closed LONG/SHORT signals from the ByKaranteli signal engine with verified outcomes (TP1, SL, TIMEOUT) and net basis-point results. It distinguishes from sibling tools by naming the specific engine and emphasizing 'live signals only, never backtests.'

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 direct trigger conditions: 'Call this when the user asks how the ByKaranteli signal engine is doing today, or wants recent closed LONG/SHORT signals.' It also provides a clear when-not: 'live signals only, never backtests.' However, it does not name alternative tools for backtest or historical queries, so it lacks that explicit alternative mention.

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 openWorldHint=true, so the description doesn't need to restate safety. It adds valuable behavior beyond annotations: the return format (cost ladders in basis points), the exact order sizes, both side coverage, exclusion of fees, and the null semantics for unabsorbable sizes. This is richer than the baseline for annotated read-only tools.

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 the most critical usage trigger. It covers what, when, and return semantics in just two sentences. Every clause adds value (e.g., size range, both sides, null meaning), with no filler or repetition.

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

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

Given the tool has no parameters and no output schema, the description carries full responsibility for explaining return values and edge cases. It does so thoroughly: live cost ladders, order size range, number of perps, both sides, fee exclusion, and null behavior. This makes the tool fully understandable without needing additional information.

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

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

The input schema has zero parameters, which is a baseline 4. The description adds no parameter-specific semantics because there are none, but it implicitly tells the agent that no arguments are needed, consistent with a fixed-market tool. The description does not need to compensate since there is nothing to document.

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: it returns live cost ladders for market orders, addressing slippage, book thickness, and thinnest perp market queries. This distinguishes it from sibling tools like get_funding_arbitrage or get_liquidations, which focus on different data. The verb 'returns' and specific scope ('8 major perpetuals', '$10K to $5M', 'both sides') make the purpose 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 opens with explicit usage guidance: 'Call this when the user asks how much slippage...' It also covers related use cases like book thickness and thinnest market. While it doesn't explicitly mention when not to use it or alternative tool names, the context is clear enough for an agent to select this tool over siblings for slippage-related queries.

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

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

Annotations already declare readOnlyHint=true, so the description adds value by disclosing that rankings come from 'live closed signals only (no backtests), net of fees.' This provides important context about data sourcing and cost treatment beyond the annotation's simple read-only flag.

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, front-loaded with the trigger scenario and key metrics. Every word contributes to understanding when and why to use the tool. 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?

Given no parameters, a readOnly annotation, and no output schema, the description fully covers the tool's purpose, data source, and usage trigger. It explains the computed metrics and the scope of signals, making it complete for a leaderboard retrieval tool.

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

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

The tool has zero parameters, and schema coverage is 100% by definition. The description does not need to explain parameters, and the baseline for no-param tools is 4. It mentions the computed metrics, which are implicit outputs rather than parameters, and that is 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 specific verb ('Call this when the user asks') and resource ('which trading strategies are performing best'), and enumerates the exact metrics (win rate, profit factor, drawdown, Sharpe). It clearly distinguishes from sibling tools by focusing on strategy-level leaderboard data rather than symbol or signal-level data.

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

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

Explicit when-to-use guidance is provided ('Call this when the user asks which trading strategies are performing best, or wants win rate, profit factor, drawdown and Sharpe per strategy'). It implicitly excludes backtests ('no backtests'), but does not name alternative tools or explicitly state when not to use, so a slight gap remains.

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 openWorldHint, which sets the safety baseline. The description adds value by specifying the data source ('live verified track record'), the market type ('Binance USDT-M perp'), and the timeframe windows (30/90/180 days), giving the agent crucial 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?

Two sentences, front-loaded with the invocation trigger. Every clause provides useful information: when to call, what to return, data source, and scope. No fluff 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?

For a two-parameter tool with thorough schema descriptions and read-only annotations, the description is complete. It covers output metrics, recent closed signals, the trading venue, and the lookback window. Since there is no output schema, the description adequately explains return value semantics.

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 descriptive parameter details (e.g., symbol format and window_days allowed values/default). The description adds no new parameter-level information beyond what the schema provides; it merely restates the window options and coin scope. Thus 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: reporting per-symbol signal performance (win rate, profit factor, net PnL, best/worst trade) and recent closed signals for a specific coin. It distinguishes from siblings by emphasizing 'specific coin' and 'one Binance USDT-M perp', contrasting with tools like get_recent_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?

Explicitly provides when-to-use guidance ('Call this when the user asks how signals performed on a specific coin...'). It gives clear context and even a second use case (recent closed signals). However, it does not explicitly name alternative tools or state when not to use, 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?

Beyond the readOnlyHint and openWorldHint annotations, the description discloses index construction (equal-weight, fixed basket), the rebase date (2025-01-01), the available return windows (1d/7d/30d/90d/YTD), the BTC comparison, and the member lists. It also transparently warns that daily points are omitted unless include_points is true and that include_points returns a large payload.

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, no filler. The first sentence front-loads the trigger conditions, and the second packs the output details into one clear, scannable statement. Every element 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?

With no output schema, the description carries the burden of explaining return values, and it does so thoroughly: what indices, how constructed, base date, return windows, BTC comparison, member lists, and the include_points caveat. For a simple one-parameter tool, this 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 schema covers the single boolean parameter include_points with a description, and the tool description adds the default behavior: daily points are omitted unless include_points is true. This extra information about the parameter's effect on response size is valuable beyond the raw 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 names the resource ('eight equal-weight fixed-basket indices') and the exact narrative categories (AI, RWA, DePIN, memecoins, L1, L2, DeFi, quantum), making it unmistakably distinct from generic market-index or single-asset tools. The trigger phrasing 'which crypto narrative or sector is leading' and 'for a theme index' gives the agent a direct signal for when this tool applies.

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 clear when-to-use context: narrative leadership, sector rotation, or theme index requests. It does not explicitly name alternatives or state when not to use this tool, so it stops short of a 5, but the trigger conditions are specific enough to route the agent correctly.

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

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

With readOnlyHint and openWorldHint already supplied by annotations, the description adds valuable context by disclosing the output structure ('four top-10 lists in one call') and enumerating the exact metrics included. This is helpful beyond the annotations, though it stops short of detailing data freshness or list ordering.

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, directly front-loaded with a 'call when' trigger, and every word adds value. It avoids repeating schema or annotation information, making it highly 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 zero parameters, no output schema, and rich annotations, the description is sufficiently complete for an agent to invoke the tool correctly. It clearly communicates the high-level output (four top-10 lists) and categories; only minor details like field names or time window are absent, but these are not critical for selection.

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 accepts zero parameters, so the schema is trivially complete (100% coverage). The description reinforces that no input is needed, and it focuses entirely on output behavior, which is the appropriate use of description space for a no-parameter tool.

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 movers in crypto derivatives, listing specific categories (OI changes, funding, basis, stress). It distinguishes itself from siblings by explicitly aggregating four top-10 lists into one call, which is a unique multi-metric offering compared to single-metric tools like get_open_interest.

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

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

The description provides explicit when-to-use context: 'Call this when the user asks what is moving in crypto derivatives right now' followed by concrete query examples. It does not mention exclusions or alternatives, but the context is clear enough for an agent to route 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 and openWorldHint=true. The description adds behavioral context: results are latest 10-minute snapshots, cover 56 feeds on 43 exchanges, and passing symbol yields per-venue rows. This goes beyond the annotations without contradicting them.

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

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

Two sentences, front-loaded with usage triggers and followed by output details and parameter behavior. Every sentence earns its place with no repetition 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 tool with one optional parameter, no required fields, and simple output, the description covers the core data, temporal scope, venue coverage, and symbol behavior. No critical information is missing for an agent to decide when to call and how 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 coverage is 100% and the symbol parameter is documented as optional. The description adds meaningful semantics by explaining that passing a symbol produces per-venue rows for one coin, while omitting it returns aggregate snapshot data. This clarifies the parameter's effect beyond the schema.

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

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

The description clearly states the tool returns 10-minute snapshot aggregates of OI, volume, funding, and stablecoin pegs across 56 feeds on 43 exchanges. It enumerates specific user intents (total OI, venue OI leaders, DEX vs CEX share, funding dispersion) that distinguish it from sibling tools like get_open_interest or get_funding_heatmap.

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 'Call this when the user asks about...' and lists concrete scenarios, which is strong usage guidance. It does not mention alternatives or exclusions, but the listed triggers make the appropriate context 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 declare readOnlyHint=true and openWorldHint=true, so the safe read-only nature is covered. The description adds useful behavioral context by noting the data is 'recorded live from our own sockets' and includes '24h aggregates,' but it does not explain update cadence, staleness, or edge cases. This is solid but not exceptional.

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 with no filler. The usage trigger is front-loaded, followed immediately by the return-value summary. Every word contributes.

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 zero parameters and no output schema, this description covers what an agent needs: when to call, what it returns, and the key data source context. Nothing important is missing 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 zero parameters, so the schema already fully describes the invocation surface. The description adds no parameter-level detail, but none is needed. The baseline of 4 for zero-parameter tools 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 specific language: 'Call this when the user asks about whale trades, large market orders, or whether big players are buying or selling right now' and defines the resource precisely as '$1M+ aggressive prints' with '24h aggregates with the buy share.' This makes the tool's function unmistakable and clearly distinct from the broad 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 explicitly opens with 'Call this when the user asks about...' and lists three clear user-intent patterns that should trigger this tool. It does not mention alternatives or exclusion criteria, so it misses the full 5, but the contextual guidance is strong and actionable.

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