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

Beyond the destructiveHint=true annotation, the description adds crucial behavioral details: 'REAL, irreversible USDC payment', balance lands only after settlement confirmation, and requires HOODGROW_PRIVATE_KEY. These go well beyond what annotations 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?

Three sentences, each carrying distinct information: payment mechanism, prerequisites, and settlement/verification steps. The final sentence about HOODGROW_USE_CREDITS is slightly tangential but still relevant for follow-up action. Dense but not bloated.

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

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

Given the tool's complexity (real payment, side effects, setup requirements), the description covers all key aspects: what it does, when to use it, irreversibility, settlement timing, prerequisites, verification, and next steps. No output schema needed; return behavior is implicitly covered.

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 covers bundleId with examples and source. The description adds the fact that list_credit_bundles also provides prices (not just IDs), giving the agent additional useful context for selecting a bundle. This slightly exceeds the schema baseline.

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

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

The description uses a specific verb ('Pays for') with a clear resource ('prepaid credit bundle via x402') and explicitly points to list_credit_bundles for IDs/prices, distinguishing it from sibling tools that list bundles or check balances.

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

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

It provides explicit when-to-use context: required only with HOODGROW_PRIVATE_KEY, while noting bearer-key setups don't need credits. It also directs to get_credit_balance for verification and explains the HOODGROW_USE_CREDITS setting to start spending, effectively telling when to use this vs. per-call x402.

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 read-only and idempotent behavior, and the description adds substantial context: reads are performed directly from token contracts, data is refreshed every 4 hours, status is derived from on-chain totalSupply(), and current supply is zero pre-launch. It also discloses access/pricing details. There is 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 front-loaded with the core purpose and provides dense, useful detail. However, it repeats the chain ID ('Base mainnet (chain 8453)' and 'on Base (chain 8453)') and the totalSupply-based status logic twice, which is slightly redundant though not bloated.

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 registry tool with no output schema, the description covers the essential return fields, source chain, refresh cadence, liveness semantics, pre-launch caveats, and access cost. This is sufficient for an agent to select and safely call the 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, so parameter documentation is inapplicable and the baseline is 4. The description compensates by explaining what the tool will return conceptually (symbol, name, decimals, status) without needing to document any 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 identifies the tool as a registry of Base mainnet (chain 8453) B20 native-equity-token metadata plus a liveness signal. It specifies the exact scope ('fixed set of known tokens') and distinguishes it from siblings like get_token or get_markets by describing a registry-level read, not price/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 provides clear operational context, including the pre-launch state, the automatic transition to 'live' when totalSupply() > 0, and the explicit warning not to treat pre_launch entries as tradable. It does not name alternative tools for prices, liquidity, or individual token details, so it falls short of full when-to-use-versus-alternatives 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?

Description adds substantial behavioral detail beyond annotations: no API key or payment, doesn't consume daily units, prices read directly from Chainlink on-chain (not relayed), refresh interval of 15 minutes, observedAt field for age, priceSource for fallback logic, and corporate-action adjusted supply explanation. No contradiction with readOnly/idempotent/openWorld hints.

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?

Though lengthy, every sentence adds value—covering scope, return data, pricing mechanism, freshness, and edge cases. It is front-loaded with the core purpose and progressively details specifics, with no wasted words.

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

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

Given no output schema, the description thoroughly explains what the response includes (symbol, name, contract address, live price, priceSource, 24h change, adjusted supply, corporate actions) and clarifies snapshot semantics (observedAt). It compensates fully for missing structured output documentation.

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

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

The tool has zero parameters, so there is nothing to document. Baseline for 0 params is 4, and description correctly omits parameter details since none exist.

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

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

Description explicitly states 'Free catalog and live price feed for all Robinhood Chain stock tokens' with specific resources (symbol, name, contract address, live price, etc.). Distinguishes from siblings by noting it lacks per-token DeFi depth and referencing get_token/get_defi for that.

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

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

Clearly states use cases: 'Use for token discovery, spot prices, and tracking market movers.' Also explicitly mentions what it does NOT do (no DeFi depth) and points to alternative tools, providing unambiguous when-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?

The description reveals rich behavioral details beyond annotations: it explains the two data sources (on-chain ERC-8056 vs official registry cache), the polling interval (every minute), ordering (pending vs recent), and cost implications. This far exceeds the simple read-only/idempotent hints provided 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?

Three sentences, each earning its place: purpose and action types, parameter usage with cost implication, and technical source/update details. No redundancy or fluff, and the most important info is front-loaded.

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

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

For a read-only tool with one optional parameter and no output schema, the description fully covers what the tool does, what data it returns (pending and recent actions, types), how it detects them, and update cadence. Nothing essential is missing for an agent to decide when and how 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 schema already covers the single 'symbol' parameter with a good description (100% coverage). The tool description adds the 'cheaper' nuance and explicitly reinforces the scope-vs-all behavior, which is meaningful extra value beyond the schema.

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

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

The description clearly states the tool retrieves corporate actions (splits, dividends, name changes) and differentiates it from sibling tools by focusing on a unique data domain. The verb 'get' plus explicit resource and examples make the purpose unambiguous.

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

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

The description gives concrete usage context: pass a symbol for a scoped, cheaper query, or omit it for all tokens. It doesn't explicitly name alternatives or state when not to use, but the parameter guidance is clear and actionable.

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

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

Annotations already mark the tool as read-only, idempotent, and non-destructive. The description adds meaningful behavioral context: the call is free (no x402 charge or credit spend) and requires HOODGROW_PRIVATE_KEY to be configured. These details go beyond the structured hints and do not contradict 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 a single, front-loaded sentence that states the tool's purpose and includes only essential caveats (free, key requirement). There is no filler or redundant information.

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

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

This is a zero-parameter, read-only getter and the description covers the return concept (balance), cost behavior, and auth prerequisite. With no output schema, the description still sufficiently conveys the result. Given the low complexity and rich annotations, the description is complete.

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

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

The input schema has zero parameters, so there is nothing for the description to clarify at a parameter level. However, the description adds that the wallet is implicitly identified via HOODGROW_PRIVATE_KEY, giving useful semantic context about how the tool determines which balance to return.

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 the wallet's current prepaid credit balance and explicitly notes it is free with no credit spend. This distinguishes it from sibling tools like buy_credits and list_credit_bundles by focusing on the balance-query resource.

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

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

The description implies use when checking the wallet's available prepaid credit and provides a clear prerequisite: HOODGROW_PRIVATE_KEY must be configured. It does not explicitly name alternatives or exclusions, but the context is clear enough for a simple read-only 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 indicate readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so safety is already clear. The description adds that the tool reads on-chain state with 15-minute snapshots, which is helpful context for data freshness. It also notes failure on unknown symbols and cost/pricing, which is additional value beyond annotations.

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

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

The description is concise and front-loaded: the first sentence explains the tool's scope intuitively, followed by pricing, failure conditions, and data freshness. Every sentence adds distinct value 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?

The tool has a single parameter, no output schema, and rich annotations. The description covers scope, examples of comparison, data sourcing, snapshot frequency, pricing, and error cases. It is sufficiently complete for an agent to invoke correctly, though return format is not described, but that is not required given no output schema.

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

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

The schema covers 100% of parameters with a description of 'symbol' as a ticker symbol. The description does not add much beyond reiterating the symbol usage, but the schema is already clear. Baseline 3 is appropriate since the schema fully documents the parameter.

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

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

The description clearly states the tool lists every Morpho lending market and Uniswap V3 pool involving a given token. It explicitly distinguishes itself from get_token by providing the full picture rather than just the best-APY figure.

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 explains the tool is meant for comparing yield or borrow options, and contrasts it with get_token which provides a single best-APY figure. However, it does not explicitly mention when not to use it or list alternatives for other DeFi insights, but the contrast with get_token is useful.

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 read-only/idempotent behavior, and the description adds valuable context beyond that: x402 pricing and free daily quota, unknown-symbol failure, explorer sourcing, 4-hour refresh cadence, and on-chain supply snapshots. It also clarifies the real mint/burn semantics of total_supply change.

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: metrics, pricing, failure mode, and data provenance. It is front-loaded with the core analytics and uses a parenthetical only where precision matters (mint/burn vs. multiplier change).

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 returned analytics, states the data source and refresh policy, documents failure behavior and cost, and the input parameters are fully covered by the schema. This is sufficient for correct selection and invocation.

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

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

Schema coverage is 100%, so the baseline is 3. The description's 'one token' and 'top-holder concentration' loosely reinforce the symbol and limit parameters, but it adds no syntax, default, or format details beyond what the schema already provides.

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

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

The description enumerates the exact analytics returned—holder-count trend, 24h net supply change, and top-holder concentration—for one token. It also explicitly distinguishes the supply-change metric from a corporate-action multiplier change, which separates it from the sibling get_corporate_actions tool.

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

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

The description provides clear usage context: it is for a single token's holder analytics, fails on unknown symbols, refreshes every 4 hours, and carries a specific cost. The corporate-action multiplier clarification is an explicit exclusion that guides the agent toward or away from a sibling 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?

Beyond the readOnly/idempotent annotations, the description richly explains data provenance (Chainlink on-chain feeds, not off-chain aggregator), refresh cadence, snapshot semantics, observedAt age, priceSource fallback behavior, and Morpho/Uniswap pool state. It also discloses cost and API-key access, which is valuable operational 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 longer than average but every sentence adds substantive detail about data quality, freshness, or usage constraints. Information is front-loaded with the core behavior and then supports it with source/refresh details. It is dense yet well-organized.

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 simple parameter set and annotations, the description is unusually thorough. It explains edge cases (empty lists on flat markets), pricing/access, return snapshot timing, and fallback semantics. Even without an output schema, an agent can predict the response shape and meaning well.

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 documents limit with its range and default, so the description adds little for this parameter. The added detail that the limit applies to 'each list' is helpful, but it is largely a restatement of the schema description provided with the parameter.

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

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

The description opens with a specific resource and scope: 'Market movers across the Robinhood Chain stock-token catalog,' and enumerates exactly what is included (gainers/losers by 24h change, top swap volume, Uniswap V3 liquidity). This clearly differentiates get_markets from sibling tools like get_token or get_catalog.

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

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

The description gives clear context for when this tool is relevant—looking at aggregated market moving data rather than individual tokens or corporate actions. It does not explicitly name alternatives or exclusion criteria, but the offered behavior and data types make the intended use fairly obvious.

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/openWorld/idempotent annotations, the description discloses pricing, unknown-symbol failure behavior, Chainlink feed sourcing, 15-minute refresh cadence, observedAt freshness, volumeUsd/swapCount null backfill behavior, and priceSource fallback semantics. This is far richer than the structured annotations 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?

Four dense sentences convey purpose, defaults, limits, pricing, failure modes, data source, freshness, and result fields without filler. It is front-loaded with the core purpose, 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?

Even without an output schema, the description explains key return-value aspects such as candle buckets, volumeUsd/swapCount, observedAt, and priceSource. It also covers limits, defaults, cost, and error behavior, making the tool sufficiently complete for an agent to select and invoke it 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?

Schema coverage is 100%, but the description adds meaningful parameter behavior: from/to default to 30 days, the window is capped at 730 days, and unknown symbols fail. It does not need to repeat schema enum or type details, and the added semantics justify a score above baseline.

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 'OHLC price candles for backtesting,' clearly naming the specific resource and intent, and distinguishes it from sibling tools like get_trades or get_markets by emphasizing bucketed candle history sourced from Chainlink feeds.

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: this is for backtesting OHLC price data, defaults to 30 days, caps at 730 days, and notes failure on unknown symbols. It does not explicitly name alternative tools or say when not to use it, 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?

Annotations declare readOnlyHint=true and destructiveHint=false, confirming this is a safe read. The description adds crucial context beyond annotations: it explains the estimate is derived from a snapshot (not live), may understate slippage for large trades, and can fail for unknown symbols. It also discloses pricing via x402, which is not in annotations, providing a complete behavioral profile.

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 block but front-loaded with the core functionality in the first sentence. Every sentence adds meaningful information: best-pool selection, limitations, tick-range accuracy, failure mode, data freshness, and pricing. No redundancy; it efficiently packs specifications 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?

Given the moderate complexity (per-pool estimation, flags, freshness), the description covers all critical usage aspects: what it computes, how to interpret results (likelyCrossesTick), failure cases, data source, and pricing. With no output schema, the description preempts common questions about return format (bestPoolAddress, flags). It's complete for the tool's purpose.

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 covers 100% of parameters with clear descriptions, so the baseline is 3. The description adds semantic context by explaining that amountUsd represents a 'USD-sized trade' and that side determines the flow (buy/sell). It also clarifies the interplay with the per-pool estimate, but since schema is already detailed, the description's contribution is modest but non-trivial, hence 4.

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

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

The description clearly states the tool estimates price impact for a USD-sized trade across Uniswap V3 pools, and highlights the best pool selection. It distinguishes itself from potential route optimization and notes it's per-pool, not a multi-pool route. This differentiates it from sibling tools like get_markets or get_trades.

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

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

The description explicitly states when to use this tool (to get per-pool slippage estimates) and when not to (for optimal multi-pool routes). It also provides guidance on handling large trades: consider TWAP splitting if likelyCrossesTick is flagged. It notes the data is from a 15-minute snapshot, not live, which sets expectations for usage in live trading.

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

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

Annotations already indicate read-only and idempotent behavior. The description adds substantial behavioral detail: price source (Chainlink on-chain), refresh rate (15 minutes), supply adjustment mechanism (ERC-8056), fallback behavior (priceSource), and failure on unknown symbols. No contradictions.

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

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

The description is longer than average but every sentence provides essential information (cost, failure, price source, freshness, supply adjustment). It is front-loaded with the core purpose and then details. While verbose, it remains tightly organized with 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?

Despite no output schema, the description explains key return fields (observedAt, priceSource) and critical nuances (corporate-action adjustment, refresh cadence, source). It also discloses cost and failure behavior, making it complete for an agent to select and invoke the tool correctly.

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

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

Schema covers 100% of the single parameter 'symbol' with a clear description including case-insensitivity. The description does not add additional parameter meaning beyond the schema, but it does mention failure on unknown symbols, which is behavioral rather than semantic. 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 returns live price, corporate-action adjusted supply, DeFi depth, and corporate actions for a single token by symbol. It explicitly distinguishes itself from the free catalog by mentioning DeFi depth, making it unique among siblings.

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

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

The description notes the cost model (x402 or free API key) and differentiates from the catalog, but does not explicitly mention when to prefer other sibling tools like get_corporate_actions or get_defi. It provides context for its use case without explicit 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, openWorldHint, idempotentHint, and destructiveHint, but the description adds substantial beyond-annotation behavior: data comes from Uniswap V3 Swap events, side and USD size are derived from the USDG leg, results are ordered newest first, and there is pricing in x402 or daily units. 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: it states the core purpose, adds ordering and return fields, gives parameter usage, mentions cost, and closes with the data source. Every sentence contributes useful information 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?

There is no output schema, so the description compensates by listing the per-trade fields, ordering, limit behavior, global feed option, and provenance. For a simple 2-parameter list tool, this gives the agent enough context to invoke it 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?

Schema coverage is 100%, so the schema already documents limit and symbol fully, including defaults and semantics. The description essentially restates 'limit caps the list (1-100, default 20)' and 'omit symbol for the global feed' without adding meaning beyond the schema, so a 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 uses a specific verb ('get') and clearly identifies the resource: recent large whale trades in Robinhood Chain stock-token Uniswap V3 pools, newest first. It differentiates itself by specifying the exchange/pool context and the included fields (buy/sell side, USD size, transaction hash), which distinguishes it from sibling tools like get_markets or get_ohlc.

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

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

The description gives clear usage context: omit symbol for the global feed, and limit caps the list. It does not explicitly name alternative tools or describe when not to use this tool, but the concrete behavior around symbol and limit provides adequate practical guidance.

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

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

Annotations already declare read-only, open-world, idempotent, and non-destructive. The description adds behavioral context beyond annotations by explaining the credit spending mechanism (paid once via x402, then cheap wallet signatures) and reinforces the no-credentials requirement, matching the openWorldHint.

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 resource name and output structure. The second sentence adds valuable context about credit mechanics without waste, earning every word's 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?

Despite lacking an output schema, the description embeds the return format inline, making the tool fully self-contained. With annotations covering safety and zero parameters, there are no significant gaps in what an agent needs to know.

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 trivially 100%. The description doesn't need to explain params; it correctly omits any, and the baseline for no parameters is 4.

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

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

The description clearly states the tool returns the 'Current prepaid credit bundle catalog' with an explicit data shape. It distinguishes itself from siblings by referencing buy_credits and the credit usage model, making it unambiguous that this is a read-only listing tool.

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

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

The description provides clear context: it's free, requires no credentials, and points to HOODGROW_USE_CREDITS for credit usage. While it implies this is the catalog to list before purchasing via buy_credits, it doesn't explicitly state when not to use it or name an alternative for listing.

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

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

The description adds significant behavioral context beyond the annotations: the webhook signature verification requirement, the one-time display of webhookSecret, and the billing implications (idle webhook costs nothing). This supplements the idempotentHint (update/register) and side-effect-free nature.

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

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

The description is dense but every sentence adds value: purpose, security, authorization, billing, parameter semantics, output, and alternatives. It is front-loaded with the main purpose and structured logically, without 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 only two parameters and no output schema, the description is remarkably complete. It covers return value (webhookSecret shown once), authentication requirements, billing model, security signature, and an alternative for Builder-subscription users. The idempotentHint in annotations complements the 'register or update' wording.

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%, so the baseline is 3. The description enriches the symbols parameter by explaining that it affects both delivery and billing ('what you're charged for'), which is critical for understanding cost implications. The url parameter's purpose is also clarified as the POST target. This goes beyond the schema descriptions.

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

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

The description clearly states the verb ('Register (or update)') and the resource ('a credit-funded corporate-action webhook for this wallet'). It goes on to explain the tool's behavior (HoodGrow POSTs events to url), which distinguishes it from the read-only get_* siblings and the credit-purchase 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 provides explicit usage context: requires HOODGROW_PRIVATE_KEY, registration is free, and billing is per delivered event. It also names an alternative path ('a Builder-subscription webhook is set from the website instead'), making clear 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.