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

Annotations already mark this as read-only and non-destructive. The description adds useful behavioral context beyond that: rows are normalized to oldest->newest even though the indexer sends newest-first, and limit is capped at 1000. This is meaningful and not contradicted by 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 dense but every sentence contributes: candle fields, ordering behavior, limit cap, and an example. The resolution list slightly duplicates the schema enum, but its placement is efficient and front-loaded.

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

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

For a simple 3-parameter read-only tool with no output schema, the description is complete: it explains what each candle contains, the ordering guarantee, the limit cap, and the resolution options. An agent has enough to call it correctly and interpret the result.

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

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

Schema description coverage is 0%, so the description carries the burden for parameter meaning. It covers resolution with the full enum list, limit with its 1000 cap, and ticker with a concrete 'ETH-USD' example. It could be more explicit about ticker being the market identifier, but it compensates well overall.

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

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

Description clearly states the tool returns OHLCV candles with open interest for a market, and enumerates the candle fields. It lacks an explicit verb like 'fetch' or 'return' and does not distinguish itself from sibling tools, so it falls short of a 5.

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

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

The description shows invocation with an example and lists valid resolutions, which implies usage context for market candle data. However, it never explicitly states when to prefer this over sibling tools like market_ta, cvd, or recent_trades, nor does it give 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?

Beyond the readOnlyHint and destructiveHint annotations, the description discloses critical behaviors: candle series are joined by startedAt so only same-timestamp candles pair, tickers are validated, and an error is returned for insufficient or constant data. This is exactly the behavioral nuance that annotations alone cannot convey.

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

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

The description is informative without being bloated, covering output semantics, matching behavior, validation, error handling, and an example. It is slightly dense due to multiple parenthetical clarifications, but each sentence adds substantive value.

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

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

For a statistical tool with an output schema, the description covers the main operational aspects: what is computed, how candle histories align, validation requirements, and failure conditions. The only notable gap is the undocumented limit and resolution parameters, but the rest of the context is strong.

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

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

With schema_description_coverage at 0%, the description must compensate. It explains ticker_a and ticker_b through the example and format hint, but it says nothing about limit or resolution beyond the raw schema defaults. Two of the four parameters receive no semantic explanation.

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 statistical operation (Pearson correlation of log returns) and the resource (two markets' candles), and names the exact outputs: correlation r and beta. This clearly distinguishes it from siblings like market_ta or candles by defining a unique analytical purpose.

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

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

The description gives clear context for use: comparing two markets' log-return sensitivity, and explicitly instructs the agent to call list_markets for valid tickers in 'ETH-USD' format. It does not explicitly name when-not alternatives, but the usage context is strong 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?

Beyond the readOnlyHint=true and destructiveHint=false annotations, the description discloses important behavior: volumes are in base coin, the running sum order, the compact response design, and that unknown/delisted tickers raise an MCP error. No contradiction with annotations exists.

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

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

The description is dense but every sentence adds value: definition, computation, interpretation, volume units, return fields, error behavior, and a usage example. It is front-loaded and contains no 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?

The description covers the calculation, output fields, error case, valid ticker source, and an example invocation. An agent has enough to correctly select and call this tool even with an output schema and read-only annotations present.

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

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

Schema description coverage is 0%, so the description must compensate. It does explain the ticker format ('ETH-USD') and provides a concrete example with trades_limit=500. However, trades_limit semantics are only implied through the name and example; the description does not explicitly state its meaning, default, or range.

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 computing Cumulative Volume Delta from the latest public trades, with a concrete formula and output fields. It is distinguishable from sibling tools by its focus on CVD, but it does not explicitly contrast itself with any sibling, so it falls short of a 5.

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

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

The description gives clear context: it is for analyzing net aggressive buying/selling from recent trades, and it explicitly directs the agent to call list_markets for valid tickers. However, it does not explicitly state when not to use it or how it compares to alternatives like recent_trades or market_ta.

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 this as readOnly and non-destructive, so the bar is lower. The description adds meaningful behavioral detail: traders are 'registry candidates probed for live equity,' and output rows are specified as address, equity (USD, >= min_equity), registry_hits, and last_seen. It does not contradict the annotations and provides more context than the schema alone.

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 information-dense. It front-loads the purpose, then gives workflow direction, output shape, and a concrete example in four sentences with zero redundancy. Every sentence contributes to effective tool 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 simple two-parameter read-only screener, the description covers what the tool does, how to use it, what each output row contains, and a worked example. The output schema exists, so detailed return structure is not needed, and annotations cover safety behavior. No critical information for invoking the tool correctly is missing.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It partially does: min_equity is defined as the equity threshold ('USD, >= min_equity') and the example discover_traders(limit=5, min_equity=100.0) clarifies how both parameters are passed. However, limit is only illustrated, not explicitly described as a result count, so the compensation is good but not perfect.

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 'Screener: funded, recently active traders discovered from the chain,' which names a specific resource (traders), a clear scope (on-chain discovery), and an implicit filter (funded, recently active). It also distinguishes itself from the sibling trader_profile by explicitly saying 'Start here, then analyze each with trader_profile,' making the tool's role in a workflow 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 gives direct workflow guidance: 'Start here, then analyze each with trader_profile.' This tells an agent when this tool fits relative to a key sibling, though it does not explicitly enumerate when to avoid list_traders or other related tools. The guidance is clear but not exhaustive.

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 show read-only, non-destructive, open-world behavior. The description adds valuable behavioral details: the indexer does not expose per-fill PnL, the tool returns a 'no fills' summary for empty accounts, and returned fields are sampled aggregates.

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 every sentence earns its place: purpose, exclusions, key fields, edge case, and example. It is front-loaded and avoids filler while still giving enough detail for an agent.

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

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

For a read-only aggregation tool with an output schema, the description covers the main return fields and edge behavior. However, the lack of parameter documentation for `limit` and `account` leaves a real gap for correct invocation beyond the minimal address example.

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

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

Schema description coverage is 0%, so the description should explain parameters. It gives an example for `address`, but `limit` and the `account` parameter are not semantically described. The 'Key fields' section refers to response fields, not input parameters.

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

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

The description clearly states what the tool produces: an execution review from latest fills, with maker/taker split, per-market distribution, volume, and average fill size. It also differentiates itself from sibling `trader_pnl_stats` by explicitly stating per-fill PnL is not exposed.

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 an explicit alternative: use `trader_pnl_stats` for win-rade or per-fill PnL. It also describes the no-fills edge case. It does not enumerate every alternative like `raw_fills`, but the 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?

Goes well beyond the readOnlyHint annotation by disclosing row-level semantics: positive = longs pay shorts, exactly one of longs_pay/shorts_pay is true, zero-rate and low-OI markets are skipped, and the return envelope contains count_nonzero, top, summary, offset, and has_more. This is rich, non-obvious behavioral detail.

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

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

Every sentence adds value: the ranking basis, side-payment semantics, OI guidance, row schema, exclusion rules, return envelope, and an example call. It is dense but well-organized and front-loaded with the core ranking concept before enumeration details.

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

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

Given that this is a read-only, filtered, paginated listing tool with no required parameters, the description covers everything an agent needs: what is ranked, what fields appear per row, which rows are skipped, how to paginate, and a concrete example call. The output envelope is described even without needing a separate output schema.

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

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

With 0% schema description coverage, the description compensates well: it explains min_oi_usd as a noise filter, mentions offset for pagination, and shows limit=15 in the example. It stops short of explicitly defining limit as the max number of rows returned, but the example and ranking context make this reasonably inferable.

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

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

States exactly what the tool does: ranks all markets by absolute next funding rate (1h, annualized) and shows which side pays. The phrase 'All markets ranked by |next funding rate|' clearly identifies the resource and the organizing metric, distinguishing it from funding history or market detail tools.

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

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

Provides clear operational guidance: rows carry OI so agents can ignore micro-markets, and min_oi_usd should be raised to filter noise. It also explains pagination with offset when has_more is true. It does not explicitly name sibling alternatives or state when not to use this tool, but the context is strong enough for an agent to select it 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 the operation read-only, idempotent, and non-destructive, so the description does not need to repeat those. It adds useful context by describing the return fields, but there are no deeper behavioral traits or edge cases disclosed.

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

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

The description is compact, front-loads the purpose, and provides an example without wasted words. Every sentence adds value.

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

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

For a zero-argument liveness tool with strong annotations and an output schema, the description covers purpose, use context, and return shape. Nothing essential is missing for an agent to select and invoke it correctly.

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

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

The tool has zero parameters and the schema is empty, so the baseline is 4. The description adds an example invocation and states the return shape, which fully compensates for any lack of parameter-level documentation.

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

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

States a specific operation: returning the current dYdX chain height and time, and explicitly frames it as a liveness check. This distinguishes it clearly from the sibling tools, none of which serve this purpose.

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

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

Explicitly says 'use for liveness checks', giving clear context for when to invoke it. It does not name alternative tools or exclusion cases, but no sibling tool is a close alternative for this simple liveness query.

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/openWorldHint annotations, the description discloses important behaviors: points are ordered oldest to newest, limit is capped at 500, positive values mean longs paid shorts, and unknown/delisted tickers raise an MCP error. No annotations are contradicted.

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 every sentence adds information: semantics, scale formula, default, ordering, sign convention, error handling, and a call example. It is front-loaded with the core purpose and uses the remaining sentences efficiently.

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

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

Given the output schema exists, return values do not need to be described. The description covers the input format, defaults, error behavior, sign convention, ordering, and relationship to sibling tools, making it complete enough for an agent to invoke correctly without additional lookups.

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 parameter coverage is 0%, so the description fully carries the burden. It explains the ticker format with a concrete example ('ETH-USD'), states the default limit of 168, and caps it at 500. Both parameters are meaningfully documented in prose.

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

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

The description opens with a specific verb and resource: 'Raw 1h funding rate history of a market'. It further distinguishes itself from the sibling market_detail by clarifying it is the realized rate, not the next-rate preview. An agent can tell exactly what this tool does and how it differs from nearby 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 explicit usage context: it is for realized hourly funding history, not the market_detail preview, and it directs users to call list_markets for valid tickers. It also explains ordering convention, default window, and limit cap, so an agent knows when and how to use the tool 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?

Beyond the readOnly/idempotent annotations, the description discloses the pruning limit, the exact return shape for offset+limit beyond the newest slice ([]), and that events are returned newest-first. No contradictions with annotations.

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

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

The description is a tight paragraph: resource, row schema, filter semantics, pruning behavior, alternative subscription channel, and an example—all in five dense but efficient sentences. No filler.

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

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

For a simple read-only list tool with an output schema present, the description covers the core data, filtering, pagination edge cases, and alternative delivery mechanism. An agent has everything needed 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?

With 0% schema coverage, the description fully compensates: it defines 'kind' by listing the valid detector names, explains 'offset' as pagination past the newest slice, and 'limit' through the pagination semantics and a concrete example.

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 'Latest anomaly events from our detectors' and names the four concrete event kinds, which makes the resource and scope unmistakable. It also defines the row structure (ts, kind, subject, payload), distinguishing it from the trading/market 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 explains the optional kind filter, how limit and offset interact, and the pruning behavior at 5000 events. It also points to webhooks/Telegram for alert-style consumption, giving an explicit alternative to polling this endpoint.

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

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

Beyond the annotations, the description discloses that data is batch-computed, that an error is returned if no batch run exists, and that farmer_flag is heuristic ('v0'). It also clarifies field semantics like 'USD where monetary' and day_winrate as 'pct 0-100', which materially helps an agent interpret results.

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

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

The description is dense but front-loaded: the first sentence establishes the core purpose, and the error contract and example are practically useful. Some repetition with the output schema exists in the column list, but there is no 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?

With an output schema and annotations present, the description covers the non-obvious context: batch-run dependency, error behavior, heuristic farmer flags, and metric options. The main gap is that the metric parameter's effect on the leaderboard is not explicitly defined, but the example partially compensates.

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

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

Schema description coverage is 0%, so the description must compensate, but it only lists the metric enum values and gives an example. It does not explain what the metric parameter controls (sorting? selecting?), nor does it describe limit or offset semantics beyond what their names and defaults imply.

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 'Verified trader leaderboard from our registry + PnL engine (batch-computed)' and enumerates the rows returned, so the resource and aggregation nature are clear. It does not explicitely name a sibling like trader_pnl_stats or list_traders to contrast with, but the batch-computed leaderboard scope makes it distinguishable enough.

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 a concrete precondition — 'Requires a batch run — otherwise returns {error}' — and a valid example invocation. However, it never states when to prefer this tool over alternatives such as trader_pnl_stats or list_traders, nor gives when-not-to-use guidance.

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

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

Beyond the readOnlyHint/openWorldHint annotations, the description discloses important behavior: only active markets are returned, delisted/settled markets are excluded, results are sorted by volume or OI, and the response contains specific keys including pagination fields. This gives the agent a clear model of the tool's runtime behavior without relying on inference.

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: it opens with the resource and key fields, then details output structure, filtering behavior, and pagination, and closes with a concrete example. Every sentence adds useful information; there is 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?

The description is complete for this tool's complexity: it covers parameters, return structure, default behavior, filtering, pagination, and includes a call example. The output schema exists, but the description still summarizes the response shape, making the tool self-contained for an agent evaluating it.

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

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

The schema has 0% parameter description coverage, but the description fully compensates: it explains 'sort' values ('volume' default, 'oi' for open interest), demonstrates 'limit' with an example, and explains 'offset' in the pagination context. This adds real meaning beyond the raw enum/default values in the schema.

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

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

The description names a specific resource ('All dYdX v4 perpetual markets') and lists the exact fields returned (oracle price, 24h volume, open interest, next funding rate). It clearly differentiates this as a market list endpoint with sorting and pagination, so an agent knows what it does and how it differs from a single-market tool like market_detail.

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 practical usage guidance: default sort by 24h USD volume, optional 'oi' sort, pagination via offset when has_more is true, and an explicit call example. It does not explicitly list alternatives or when-not-to-use, but the context is clear enough for correct selection among the sibling tools.

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

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

The annotations already mark the call readOnly and non-destructive, and the description adds substantial behavior beyond that: it discloses the pagination schema, the empty-result behavior (traders == [] when registry is not built), and the max_hits filtering semantics. No annotation contradiction exists.

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

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

The description is compact yet dense: purpose, row shape, return shape, edge case, pagination, workflow, and example are each one short clause or sentence. Nothing is filler, and the most important identifying information appears first.

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

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

For a simple paginated list tool with no required parameters and an output schema available, the description covers all essentials: what is listed, the filter, row fields, return fields, empty-registry fallback, pagination rule, example call, and follow-up usage. There is no significant missing context for an agent to call it correctly.

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

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

With 0% schema_description coverage, the description fully compensates: it explains max_hits as filtering out high-frequency validator committers, offset via the pagination instruction, and limit via the example list_traders(limit=10, max_its=100). It also clarifies the returned counter fields total, count, if_set, has_more, next_offset, so parameter roles are inferable.

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

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

The description clearly states a specific verb and resource: 'Recently active trader addresses from the block-scanner registry' plus the filtering rule for max_hits. It also names related next-step tools (trader_profile / trader_pnl_stats), but it does not explicitly differentiate this tool from siblings like discover_traders or leaderboard, so it is clear but not fully sibling-distinguished.

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

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

The description gives a concrete workflow: list active traders, then feed an address into trader_profile / trader_pnl_stats. It also provides operational usage guidance such as 'Page with offset when has_more is true' and notes when the registry is unavailable. It omits explicit 'use this instead of X' guidance, but the intended context is clear.

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

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

The description discloses significant behavioral detail beyond the annotations: it warns that the raw API priceChange field is unreliable, explains that 24h stats are computed from 25 x 1h candles, gives the exact basis formula, and documents error behavior for unknown/delisted tickers. These are exactly the kind of non-obvious behaviors that help an agent use the tool correctly.

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 information-dense but well organized: a one-sentence summary up front, then the returned fields, then error behavior, then an example. Every sentence contributes either to what the tool does, how it computes values, or how to call it. 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?

For a single-parameter tool with an output schema present, the description is complete. It explains the input, the returned fields, the derivation logic, the reliability caveat, and the failure mode for invalid inputs. An agent has everything it needs to select and invoke this tool correctly.

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

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

The schema only defines ticker as a string with zero description coverage, so the description must compensate. It does by providing a concrete example, market_detail(ticker="BTC-USD"), and by explaining that the ticker must refer to a currently served perpetual market. It could be even more explicit about ticker format rules, but for a single required parameter the example is sufficient guidance.

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 'One perpetual market in depth,' naming the exact resource and scope, then enumerates the concrete data returned: prices, 24h stats, OI, funding, candles, and basis. This makes the tool's purpose unambiguous and distinguishes it from list-level tools like list_markets and from pure candle history tools like candles. The example call reinforces the intended usage.

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

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

The first sentence gives clear context for when to use the tool: when you need detailed stats for a single perpetual market. It also provides a useful negative constraint by stating that unknown or delisted tickers raise an error and that settled markets are not served. However, it does not explicitly name sibling alternatives or state when to prefer one of those 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the description is not burdened with basic safety disclosure. It adds meaningful behavioral details beyond annotations: result caps (up to 5 events, top-5 funding, top-3 leaderboard), filtering thresholds (>= $100k OI), and payload flattening. No contradiction with annotations.

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

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

The description is compact and front-loaded: the first line summarizes the entire purpose, and the following lines detail return structure. Every sentence adds value; there is no fluff or restatement of the tool name. The example is short and useful.

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, rich annotations, and an output schema, the description provides sufficient context for correct invocation. It explains what data is included, how much, and under what filters, which is complete for an agent to decide to call it.

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

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

The tool has zero parameters and schema description coverage is 100%, so there is no parameter ambiguity. Per the baseline for zero-parameter tools, a 4 is appropriate. The included example call, 'market_digest()', reinforces the no-argument invocation.

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

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

The description states a specific verb and resource: it is a one-call market briefing combining latest detector events, funding extremes, and verified leaderboard top. It clearly differentiates itself from siblings like latest_events, funding_heatmap, and leaderboard by framing itself as an aggregate digest. The return components are explicitly enumerated.

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 says this is 'The daily briefing an agent (or human) needs before anything else,' which clearly implies it should be used for initial market orientation. It does not explicitly name alternatives or conditions for when not to use it, but the composite nature makes the intended use case reasonably 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?

Beyond the readOnly/destructive annotations, the description discloses meaningful behavior: pure local math with no external TA library, a 55-candle minimum, and an error return for thin markets. It also explains conventions such as hist > 0 = bullish momentum and bollinger_pctB boundaries, which help the agent interpret results.

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

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

The description is long but well structured: a one-sentence summary, an organized key-fields list, then operational notes and an example. Some indicator formulas overlap with what an output schema would provide, but each section serves a distinct purpose.

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

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

For a read-only technical indicator tool with an output schema, it supplies the prerequisites, failure behavior, key output fields, and a usage example. The only notable gap is the lack of enumeration or definition of valid resolution values, though the example and schema default cover most invocation needs.

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

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

The schema has 0% description coverage, so the description must compensate. It provides a concrete example (ticker="BTC-USD", resolution="1HOUR") and contextual meaning via dYdX candles, but it does not define valid resolution values or fully explain the ticker market identifier semantics.

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 (dYdX candles) and a concrete output (technical snapshot) while enumerating indicators such as RSI(14), EMA20/EMA50, ATR(14), Bollinger(20,2), MACD(12,26,9), VWAP(20), and annualized realized vol. It is clear enough to distinguish from raw-candle siblings, though it does not explicitly name an alternative.

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

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

Usage is implied rather than stated: an agent needing technical indicator values rather than raw candles would pick this tool. It adds a data prerequisite (>=55 candles) and a thin-market error case, but it never says when to prefer candles/market_digest or when not to use this tool.

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

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

Annotations already declare readOnly/openWorld/non-destructive, and the description adds real behavioral detail: the output is the unchanged indexer tape, newest first, with a 1000-fill cap, and it enumerates the per-fill fields including position context. This goes well beyond the annotations.

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

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

The description is front-loaded with purpose, then packs the field list, ordering, cap, address provenance, and an example into compact high-signal sentences. 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?

With an output schema present and annotations covering the safety profile, the description supplies nearly everything else: purpose, alternative tool, sort order, cap, field contents, and address source. The only meaningful gap is the semantics of the optional subaccount parameter.

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

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

Schema description coverage is 0%, so the description must compensate. It partially does: 'limit capped at 1000' defines the limit parameter, and the example plus address-source guidance clarify address. However, the optional subaccount parameter is only mentioned narratively as 'for a subaccount' and its integer/default behavior is never explained.

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 says exactly what the tool returns: the raw execution tape for a subaccount, 'every field the indexer gives, unchanged'. It also distinguishes itself from fills_review by noting the aggregated view lives there, so there is no sibling-confusion.

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 clearly scopes usage to agents doing their own execution-quality math and points to fills_review as the aggregated alternative. It also tells where valid addresses come from (discover_traders / leaderboard / list_traders), though it does not give an explicit when-not-to-use directive.

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 destructiveHint annotations, the description adds useful behavioral details: results are newest-first, limit is capped at 100, side values are BUY/SELL, and size is in base coin. This gives the agent expectations about ordering and data semantics.

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 information-dense: scope, fields, ordering, cap, units, enum values, and an invocation example in three short sentences. Every sentence contributes value, and the most important facts 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?

For a simple listing tool, the description covers the key invocation details: what is returned, ordering, limit behavior, side/size semantics, and an example call. It does not define the 'type' field or the full return structure, but annotations and schema already cover safety and parameters, so nothing blocks 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?

Schema description coverage is 0%, so the description must compensate for parameter meaning. It partially does via the example and the limit cap, but it does not explicitly explain the ticker format or the limit default beyond what the schema shows. The example provides minimal but usable semantics.

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

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

The description clearly identifies the tool as returning the latest public trades of a market, lists the returned fields, and states ordering and limit behavior. This is specific enough to distinguish it from sibling tools like candles or historical_funding without ambiguity.

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

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

The phrase 'Latest public trades of a market' establishes a clear use case: retrieving recent trade-level activity. It does not explicitly name alternatives or when-not-to-use conditions, but the context is clear enough that an agent would know when to select it.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds meaningful behavioral detail beyond annotations: the exact returned fields, the sqlite path, and the fallback note behavior when the scanner has not run. No contradiction with annotations.

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

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

The description is compact and well-organized: purpose first, then return fields, then edge-case behavior, then an example. Every sentence contributes useful information without padding 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 zero-parameter read-only stats tool with an output schema present, the description is complete. It covers what the tool returns, the failure/fallback case, and the relationship to sibling tools, leaving no ambiguity for an agent deciding to invoke it.

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

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

The tool has zero parameters, so there is no parameter schema burden to fulfill. The description still adds value by showing the example call registry_stats() and enumerating the return fields, which is plenty for a no-argument 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's purpose: returning live stats from the on-chain address registry (block scanner), including specific fields like addresses_total and scanned_up_to_height. It distinguishes itself from the market/trader sibling tools by domain, though it does not name a specific sibling tool for direct comparison.

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 useful when-to-use context: it explains that registry stats come from the scanner, and if the scanner hasn't run, a note is returned instead while market/trader tools still work via the public indexer. This effectively guides an agent toward alternatives in the degraded case, though it could be more explicit about naming specific 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?

Description goes well beyond the readOnlyHint/openWorldHint annotations: it discloses exact error behavior (MCP isError for unknown ticker vs. error object for thin markets), output price units, the entry default, the breakeven trigger rule, and the risk_reward formula. This is substantial behavioral detail that the annotations alone could not convey.

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

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

The description is dense but every clause earns its place: purpose, formulas, defaults, error modes, and an example. The most important scoping (ATR-based risk plan) is front-loaded, and the worked example at the end makes the call format immediately clear without bloat.

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?

Nothing critical for invocation is missing: required params, defaults, error paths, output-value meaning, and an example are all covered. The presence of an output schema means the return shape does not need to be re-described, and the description still explains the key computational relationships. A complete, self-sufficient definition for 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?

With 0% schema coverage, the description carries the parameter-documentation burden. It explains side via 'long/short entry', entry default via 'current oracle price', and atr_mult_sl/atr_mult_tp via the ATR(14) multiplier formula. Resolution is the only parameter left unexplained; the example does show ticker format and a typical 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 opens with a specific verb+resource: 'ATR-based risk plan' and names the concrete outputs (stop-loss, take-profit, breakeven trigger, trailing level). The example call further anchors it as a position-entry helper. This is clearly distinct from all sibling tools, which are market data, trader stats, or 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 phrase 'Agent-managed position helper' and 'for a long/short entry' give clear usage context, and error conditions (unknown ticker, missing ATR) tell the agent when the tool won't work. There are no explicit alternatives to compare against, but no visible sibling tool fills the same niche, so the absence of an explicit when/ when-not does not much hurt.

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/open-world/non-destructive behavior. The description adds meaningful context on top: deposit-adjusted drawdown, the dd_pct_unreliable trust guidance, and the identity_max_residual_usd expectation on clean data. This goes beyond what annotations alone provide.

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 every clause earns its place. Key caveats, parameter traps, unit conventions, and reliability notes are all included without padding, and the structure makes the critical information easy to scan.

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 presence of an output schema covers the return shape, and the description handles non-obvious reliability caveats and limit semantics. It is slightly incomplete only in that it never states when to prefer this tool over trader_profile or registry_stats, and subaccount meaning remains implicit.

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

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

With 0% schema description coverage, this description compensates well: it warns that limit must be a keyword argument, explains limit as history depth with a performance/latency hint, and surfaces subaccountNumber as the positional trap. However, address and subaccount semantics are only shown through an example and are not fully defined.

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 ('equity curve') and a specific intent ('Deep PnL statistics'), then enumerates distinctive outputs such as day-winrate, drawdown, Sharpe-like ratio, and the phantom-PnL residual. This makes it easy to distinguish from siblings like trader_profile or registry_stats.

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

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

The use case is implied—if an agent needs deep PnL diagnostics, this is the tool—but there is no explicit statement of when to use it versus alternatives, nor any exclusions. The keyword-argument note is about invocation, not usage selection.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description aligns with them by presenting a read-only snapshot. The description adds useful behavioral detail beyond annotations, including the 'all-time window from up to 1000 history points' and the specific PnL/open-position fields returned.

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 core purpose. The output list and the example are valuable without adding fluff, 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 simple two-parameter read-only tool with an output schema and safety annotations, the description is largely complete: it covers purpose, output shape, window behavior, and the relevant sibling tool. The main gap is subaccount semantics, but the schema default and example partially mitigate that.

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

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

The input schema has 0% description coverage, so the description needed to compensate. It provides an example address but never explains what the address represents or what the subaccount parameter means beyond being an integer with a default. The agent must infer the semantics from the parameter names and tool context.

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 'Snapshot of any trader's subaccount', which clearly identifies the resource and the action. It enumerates the exact returned fields and explicitly distinguishes itself from trader_pnl_stats with 'Pair with trader_pnl_stats for deeper statistics.'

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

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

The description implies this tool is for a quick snapshot view and points to trader_pnl_stats for deeper analysis, giving the agent a routing signal. It does not spell out exhaustive when-to-use/when-not-to-use conditions, but the sibling guidance is clear enough.

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

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

Annotations already disclose readOnly=true, idempotent=true, and destructive=false. The description adds meaningful behavioral context by specifying that counts are since deployment, gateway-scoped, and include a top-5 breakdown. This complements 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?

Three short sentences: what it is, what it returns, and how to call it. Every sentence earns its place, and the main purpose is front-loaded. 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?

For a zero-parameter, read-only tool with an output schema available, the description covers the return fields, scope, and invocation format. An agent has everything it needs to select and call this tool correctly.

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

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

The tool has zero parameters and 100% schema description coverage, so the baseline is 4 under the rubric. The description reinforces this with an explicit no-argument example, though no parameter explanation is needed.

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

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

The description states a specific resource ('tool-call counters') and a clear scope ('since deployment', 'recorded by this gateway instance'). It also enumerates the exact response fields, so an agent can distinguish this from sibling tools like registry_stats or list_markets 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 phrase '(traction/uptime metrics)' clearly identifies when this tool is relevant, and the example usage_stats() shows there are no arguments to supply. It does not explicitly name sibling alternatives or exclusions, but the context is sufficient for an agent to decide to call it.

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