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

Annotations already provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context beyond these hints: the exact cost ($0.003 per call) and the explicit statement that write methods are never permitted. This aligns with the annotations and gives the agent crucial operational details.

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

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

The description is extremely concise (two sentences) yet packs all key information: purpose, supported chains, example methods, constraint against writes, and cost. It is front-loaded with the core purpose and flows logically. Every sentence earns its place 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?

Given the tool's complexity (multi-chain RPC proxy), the description provides essential information: supported chains, allowed methods, cost, and safety. There is no output schema, but as a proxy the return value is the standard JSON-RPC result, which is implicit. Minor improvements could include note on rate limits or authentication, but the description is largely complete for decision-making.

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

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

Schema coverage is 100% with parameter descriptions for chain, method, and params. The description adds value by stating defaults ('default base' for chain, 'default []' for params) and providing concrete examples like 'eth_call, eth_getBalance' for the method parameter. This enhances the schema information, though the schema descriptions were already adequate.

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 safelisted read-only JSON-RPC proxy across multiple chains (Base, Ethereum, Polygon, Arbitrum, Optimism) and lists specific supported methods like eth_call and eth_getBalance. This distinguishes it effectively from sibling tools that cover more specific blockchain queries (e.g., get_wallet_balance, get_gas_price).

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 states that write methods are never permitted, which tells the agent when not to use the tool. However, it does not explicitly compare this tool to its siblings or provide guidance on when to prefer it over more specialized tools like get_crypto_price or get_wallet_balance. The agent is left to infer that this tool is for arbitrary RPC calls not covered elsewhere.

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?

This description goes beyond annotations to explain match quality: matches are keyword-overlap similarity, not verified same-event guarantees. That is an important behavioral trait. The per-call price is also disclosed. The annotations only declare readOnly, openWorld, and idempotent hints, so the added caveat is valuable.

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

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

Three concise sentences each contribute meaningful content: purpose, key caveat, and pricing. The core capability is front-loaded, and there is no redundant fluff.

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

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

The description gives the essential context for using the tool-cluding the cross-platform differentiator and the match-quality limitation. It doesn't state the exact return structure because there is no output schema, but the caveat about verifying matches fills a key safety gap. A minor gap is the lack of explicit mention of what fields will be returned.

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

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

Schema description coverage is 100%, meaning all three parameters are already fully described in the schema. The description adds a high-leel note about keyword-overlap matching, which anchors results conceptually, but does not enrich the parameter meanings beyond what the schema gives.

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 verb and resource: it finds prediction-market questions priced differently on Polymarket vs. Kalshi. It explicitly calls out the cross-platform divergence signal and differentiates it from any single-platform tool, matching the unique distinguishing angle.

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 clear context: use this when seeking cross-platform price divergence. The caveat that matches must be sanity-checked before treating as a real arbitrage signal communicates when to be cautious. It does not explicitly name alternatives like search_polymarket_markets or search_kalshi_markets, so it stops short of the full 5.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is well-covered. The description adds important behavioral context beyond annotations: pricing model (usage-based, max $0.05), which is a critical behavioral trait for an AI agent deciding to invoke this tool. No contradiction with annotations is present.

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

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

Two sentences, no filler. The first sentence states core purpose; the second adds billing details. Slightly longer than ideal due to the billing explanation but every sentence serves a distinct purpose. Could arguably omit the 'x402...' parenthetical detail without losing essential meaning, but it remains efficient overall.

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 1-parameter generation tool with no output schema, the description covers purpose, pricing, and behavioral constraints well. It doesn't describe the output format or expected length, but that is reasonable given the absence of an output schema and the low parameter count. The annotations compensate for safety concerns.

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

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

Schema coverage is 100% with a single required parameter (prompt) whose description 'Text prompt to generate insights about' is already informative. The tool description adds no additional meaning beyond what the schema provides for this parameter, so baseline 3 is appropriate.

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

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

The description starts with a specific verb+resource combination ('Generates short text output for a prompt'), and explicitly notes billing details and a max cost cap ($0.05), which helps distinguish it from sibling read-only tools like get_weather or get_crypto_price. The purpose is immediately clear.

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

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

The description explains when to use this tool (for generating short text) and crucially adds pricing behavior ('Billed by output length... max $0.05 per call'). It does not explicitly mention when NOT to use it or name alternatives, but the context of 15+ sibling tools (none doing text generation) makes the usage scope evident.

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 as true/true/true/false, clearly indicating safe, read-only, non-destructive behavior. The description adds the pricing information ('$0.002 per call'), which is valuable cost disclosure. However, it does not disclose any behavioral traits beyond what annotations provide, such as rate limits, data freshness, or whether the response is paginated.

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

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

The description is a single line that efficiently captures the tool's purpose and data points, followed by pricing. No filler or redundant information. 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?

Given that the tool has 2 parameters with 100% schema coverage, clear annotations, and no output schema requiring explanation, the description is complete. It lists the key data fields the user can expect (rank, 24h high/low, volume, all-time high) and mentions pricing. However, it omits any note about error cases or missing data (e.g., if coin IDs are invalid).

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

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

Schema description coverage is 100% – both parameters (vs and ids) are described in the schema. The description adds the phrase 'Comma-separated CoinGecko coin ids' to clarify the format, which matches the schema's description. Since coverage is high, a baseline of 3 is appropriate; the description does not significantly deepen understanding 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 identifies the tool as providing 'rich market data for one or more cryptocurrencies' and lists specific data points (rank, 24h high/low, volume, all-time high). This differentiates it from sibling tools like get_crypto_price (which likely only returns price) and get_crypto_trending (trending data). However, it doesn't explicitly state the exclusive differences from these 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 implies the tool is for fetching detailed market data but does not explicitly state when to use it versus alternatives like get_crypto_price or get_crypto_trending. No guidance on prerequisites, required format for coin IDs (though schema shows comma-separated), or scenarios where this tool is inappropriate.

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=false, so the safety profile is well-covered. The description adds the cost per call and specifies the exact data fields returned, which is useful context. However, it does not disclose rate limits, authentication requirements, or any edge cases (e.g., behavior for invalid IDs).

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

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

Two sentences: first sentence states the purpose concisely, second sentence adds a critical cost note. No wasted words, front-loaded, and easy to parse.

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 is simple (2 params, no output schema) and annotations cover safety, the description is reasonably complete. It lists the output fields (price, 24h change, market cap) and the cost. However, it does not describe the return structure (e.g., object keys, data types) which would be helpful since there is 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?

Schema description coverage is 100%, so the schema already documents both parameters (ids and vs_currency). The description does not add meaning beyond the schema; it mentions 'one or more cryptocurrencies' but that is implicit from the comma-separated ids. The cost note is not parameter-related. Baseline 3 applies as the schema carries the burden.

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

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

The description clearly states the action ('current price, 24h change percent, and market cap') and resource ('cryptocurrencies'). It specifies the scope ('one or more'), making the purpose unambiguous. However, it does not differentiate from sibling tools like get_crypto_market_data or get_crypto_trending, which could overlap in intent.

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 includes a cost note ('Price: $0.001 per call') but provides no guidance on when to use this tool versus alternatives such as get_crypto_market_data or get_crypto_trending. There is no explicit mention of prerequisites, context, or exclusions.

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

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

Annotations already indicate readOnly, openWorld, idempotent, and non-destructive. The description adds the cost per call ($0.001), which is useful behavioral context beyond the annotations.

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

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

Two sentences, front-loaded with purpose. Every sentence adds value. 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 gives a high-level idea of the return value (list of trending cryptocurrencies ranked by search interest). It could be more specific about the output format, but it is adequate for a zero-parameter tool.

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

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

There are zero parameters, so the schema provides full coverage. The description does not need to add parameter info. Baseline of 4 is appropriate.

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

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

The description clearly states the tool returns the top trending cryptocurrencies ranked by search interest. The title reinforces this. It is distinct from sibling tools like get_crypto_price or get_crypto_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?

No guidance on when to use this tool versus alternatives like get_crypto_price or get_trend_insights. The description does not mention any prerequisites or exclusions.

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

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

Annotations already declare read-only, open-world, idempotent, non-destructive. The description adds the data source (DefiLlama) and per-call pricing, which provides useful behavioral context beyond annotations. 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?

Three short, focused statements with no wasted words. The most critical information (what it does, result breakdown, data source, cost) is front-loaded and easy to parse.

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 one-parameter read tool with good annotations, the description covers the output (TVL by chain + market cap), data source, and cost. Could mention error handling for invalid slugs, but not required for basic completeness.

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

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

Schema coverage is 100% with a clear description for the 'protocol' parameter. The tool description does not add any additional meaning about the parameter beyond what the schema provides. 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?

Description clearly states the tool retrieves current TVL for a specific DeFi protocol, broken out by chain, plus market cap. The verb-resource combination is precise, and the qualifiers distinguish it from siblings like rank_chains_by_defi_tvl or get_crypto_price.

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

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

The description implies usage when you need a specific protocol's TVL breakdown, but does not explicitly state when to use it versus alternatives, nor are there exclusions. Without explicit guidance, the agent must infer from the sibling tool list.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive behavior. The description adds useful context: the cost ($0.001 per call) and the specific EIP-1559 fee estimate. This goes beyond the annotations without contradicting them. No mention of rate limits or response format, but the core behavioral traits are well covered.

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

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

Two sentences, zero wasted words. The first sentence front-loads the purpose and supported chains. The second sentence adds pricing as a secondary detail. Each sentence earns its place.

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

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

The tool has no output schema, but the description indicates the return type ('current gas price and EIP-1559 fee estimate'). For a simple one-parameter tool, this is sufficient. It could be more precise by mentioning units (e.g., gwei), but the overall completeness is high given the tool's simplicity.

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

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

Schema coverage is 100% and the description does not add any meaning beyond the schema's enum and default. The description lists the same chains already in the schema. Baseline 3 is appropriate as the schema already adequately 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 verb ('get') and resource ('gas price and EIP-1559 fee estimate') for specific chains (Base, Ethereum, Polygon, Arbitrum, Optimism). This differentiates it from siblings like get_crypto_price, which returns token prices, not gas fees. The title reinforces the 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?

No guidance is provided on when to use this tool versus alternatives. Siblings include get_crypto_price and get_crypto_market_data, which could be confused for gas-related queries. The description only lists supported chains but does not exclude other tools or explain prerequisites (e.g., chain must be in the enum).

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

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

Annotations already indicate readOnlyHint, idempotentHint, and no destructiveness. The description adds value by stating the call cost ($0.002) and specifying the returned fields. This provides useful behavioral context beyond the annotations, though it omits potential error handling or rate limiting details.

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

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

The description is extremely concise, using only two sentences. The first sentence front-loads the purpose and output details, and the second adds pricing information. Every word earns its place with no fluff.

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

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

Given the tool's simplicity (single required parameter, no nested objects, no output schema), the description covers key aspects: purpose, how to specify the market, what fields are returned, and cost. It does not mention error conditions or pagination, but these are unlikely for a single-market detail tool. The description is largely complete for safe 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 100%—the 'ticker' parameter is already described in the schema as 'Kalshi market ticker (from search_kalshi_markets).' The description adds no additional semantic information beyond confirming the parameter is a ticker, meeting the baseline expectation.

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

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

The description clearly states it provides 'full detail for a single Kalshi market by ticker' and enumerates the fields returned (yes/no prices, volume, status, result). This verb+resource combination unambiguously indicates the tool's operation and, in the context of siblings, distinguishes it from search_kalshi_markets which returns a list.

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

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

No explicit guidance is provided on when to use this tool versus alternatives. While the sibling set includes related tools (search_kalshi_markets, get_polymarket_market), the description does not explain when one should prefer this over others. The use case is implied but not stated.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, which together indicate a safe, idempotent read operation. The description adds a pricing note ($0.002 per call), which is useful behavioral context beyond what annotations provide. However, it doesn't mention potential network variability or failure modes, which with strong annotations is acceptable.

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

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

The description is extremely concise with two sentences covering purpose, return data, and pricing. Every sentence adds value with no redundancy or fluff.

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

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

Given the tool has only one parameter, no output schema, and strong annotations, the description adequately covers what the tool returns and costs. It misses mentioning whether prices are in USD or another unit, but the presence of sibling tools like get_crypto_price provides broader context. Overall sufficient for a simple lookup tool.

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

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

Schema coverage is 100% as the slug parameter is well-documented in the schema with a clear description. The description adds no further parameter details but is not required to; it simply clarifies the return fields. 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 retrieves 'Full detail for a single Polymarket market by slug' and lists the specific data returned (prices, volume, liquidity, resolution status). This distinguishes it from sibling tools like search_polymarket_markets which searches multiple markets.

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 to use a slug from the URL or from search_polymarket_markets, providing clear context for when to use this tool. It doesn't explicitly state when not to use it or name alternatives beyond the search tool, but the sibling list helps.

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. The description adds value by disclosing pricing ($0.001 per call), that the protection is page-level (not just API-level), and that the return is a short confirmation message. This provides behavioral context beyond the annotations.

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

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

Three sentences, each earning its place: first describes the feature, second states the return type, third gives pricing. 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?

With no parameters and no output schema, the description adequately covers what the tool does, what it returns, and its cost. It could mention that it is open-world (implied by annotations) but this is not critical. Overall sufficient for a simple demo tool.

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

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

The tool has no parameters and schema coverage is 100%, so the description does not need to add param semantics. Baseline for 0 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 is a demo of page-level x402 protection that returns a short confirmation message. The verb 'returns' and resource 'confirmation message' are specific, and the purpose (testing x402 protection) is distinct from all listed 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 implies usage for demonstrating x402 protection but provides no explicit when-to-use or when-not-to-use guidance. No alternatives are mentioned, though given the unique nature of this demo tool, alternatives may not exist.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the agent knows this is a safe, idempotent read operation. The description adds value by disclosing the cost implications of the two tiers, which goes beyond what annotations provide. 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?

Two sentences with no wasted words. The first sentence defines the core purpose, and the second adds critical usage context (tier pricing and outputs). Every sentence earns its place, and key information is front-loaded.

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

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

For a simple tool with 2 parameters, 100% schema coverage, and clear annotations, the description is fully adequate. It explains the two tiers, their cost, and what each returns. There's no output schema, but the description effectively communicates the return structure ('basic score' vs 'full breakdown including related trends'), making it complete for agent decision-making.

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

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

Schema description coverage is 100% and both parameters have descriptions in the schema (topic and tier with enum). The description adds marginal value by clarifying the tier pricing ('$0.001' vs '$0.005') but doesn't add format details beyond what the schema provides. Baseline 3 is appropriate since schema already documents the parameters adequately.

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 'Trend score, momentum, and related trends for a topic', which is a specific verb ('get') and resource ('trend insights'). It also distinguishes between two tiers (standard vs premium) and what each returns, differentiating it from sibling tools like get_crypto_trending (which likely focuses on crypto) and general search 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 implicitly tells when to use each tier ('standard returns a basic score, premium returns full breakdown'), providing clear cost-benefit context. However, it does not explicitly tell the agent when NOT to use this tool or suggest alternative tools for related tasks (e.g., web_search for broader trend exploration), though the siblings list makes some alternatives apparent.

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=false. The description adds valuable behavioral context: that the call costs $0.002, supports five specific chains with a default, and optionally checks an ERC-20 token. These details go beyond annotations, though the return format (e.g., wei vs ether) is not 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 a single sentence plus a cost note, front-loaded with the core purpose. Every word earns its place; there is no redundancy or fluff.

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

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

Given the tool's simplicity (3 parameters, no output schema), the description covers the input purpose and constraints. However, without an output schema, the description should ideally hint at the return format (e.g., numeric value in wei) to fully inform the agent. This omission leaves a gap in completeness.

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

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

Schema coverage is 100% with clear descriptions for all three parameters. The description confirms the purpose of the parameters (native balance + optional ERC-20) but adds no new meaning beyond the schema. The cost note is not parameter-specific. 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 verb ('get balance'), resource ('wallet address'), and scope ('native token plus optional ERC-20 token across 5 chains'). This definitively distinguishes it from sibling tools like get_crypto_price or get_crypto_market_data, which serve different purposes.

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

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

The description implies usage (if you need a wallet balance, use this tool), but it does not explicitly state when to use it over alternatives, nor does it mention when not to use it. No alternative tools are named or excluded, leaving usage guidance implicit.

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

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

Annotations already declare readOnlyHint, idempotentHint, etc. The description adds value by disclosing the data source (Open-Meteo), pricing per call, and the specific fields returned. This goes beyond annotations to clarify what the tool does. No rate limits or error scenarios are mentioned, but the safety profile is well covered 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?

Two sentences fully capture the tool's purpose, output, source, and pricing. Every word adds value; no redundancy or filler. Front-loaded with the core function.

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 one-parameter tool with strong annotations and no output schema, the description covers the return format, source, and pricing. It lacks details like error handling for invalid cities or pagination, but such depth is not critical for this low-complexity tool. Minor gap: no mention of whether the output is structured or raw.

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%: the 'city' parameter is described with a name, example, and default. The tool description reinforces that it works for 'any city' and lists output fields, but this adds only marginal context beyond the schema. Baseline 3 is appropriate given high schema coverage and no additional parameter constraints.

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

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

The description clearly states it provides 'live current weather conditions' with specific data points (temperature, conditions, humidity, wind). The verb 'provides' and resource 'weather for any city' are unambiguous. No sibling tool offers weather, so differentiation is inherent, but the description itself is self-sufficient.

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

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

The description does not explicitly state when to use or avoid this tool versus alternatives like web_search for weather. Usage is implied by the name and description, but there is no guidance on prerequisites (e.g., valid city names) or exclusion of edge cases. Pricing is mentioned but not framed as a usage consideration.

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

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

The annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description agrees fully and adds valuable behavioral context about the billing mechanism (batch-settlement payment channel) and exact cost ($0.001 per call), which goes well beyond what annotations 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 extremely concise at two sentences, front-loads the core purpose, and every word earns its place by specifying the pricing model and suitability for repeated calls. No redundancy or filler.

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

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

For a zero-parameter, no-output-schema heartbeat tool, the description is completely adequate. It tells the agent the purpose, cost, billing model, and suitability for repeated use. No missing information given the tool's simplicity and richness of annotations.

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 parameters and 100% schema definition coverage, the schema already fully documents what inputs are needed (none). The description adds no parameter info, which is appropriate. Baseline 4 is justified because the description adds value by explaining the pricing and repeatability context beyond the empty schema.

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

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

The description explicitly states the tool is a minimal heartbeat/ping endpoint, using the verb 'ping' which matches the tool name. It clearly distinguishes this as a cheap, repeatable health-check tool, setting it apart from siblings that fetch data or generate content.

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 clearly states when to use it: for repeated calls in a session to check liveness or keep connection alive, at a low price. However, it does not explicitly say when NOT to use it or suggest an alternative, though the sibling context makes it obvious no other tool serves this function.

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=false, covering safety and idempotency. The description adds the pricing detail ($0.002 per call), which is a behavioral constraint beyond what annotations express. It doesn't describe return format or pagination, but as a read-only ranking with a single parameter, the behavioral profile is well-enclosed.

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

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

The description is two sentences with minimal waste. The first sentence clearly states the purpose. The second sentence adds pricing, which is relevant context. However, the pricing information might be better placed in annotations or outside the core tool description, slightly reducing focus.

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 is simple (one optional parameter, no output schema, reads only), the description is almost complete. It lacks details about what the output looks like (e.g., which fields are returned: name, TVL, rank?). However, with no output schema, this is a minor gap. The tool's simplicity makes the missing output format less critical for agent invocation.

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

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

Schema description coverage is 100% (the 'limit' property has a one-sentence description defining range and default). The description does not add any parameter-specific semantics beyond what the schema provides. Baseline score of 3 is appropriate since schema already documents the single parameter adequately.

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 ranks blockchains by total DeFi TVL. The verb 'ranks' combined with the resource 'blockchains by total DeFi value locked' is specific and fully distinguishes it from siblings like 'get_defi_protocol_tvl' which returns data for a single protocol.

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

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

The description provides no guidance on when to use this tool versus siblings. Notably, the sibling 'get_defi_protocol_tvl' does a related but different function, yet no comparison or when-to-use/not-to-use advice is given. The only usage-adjacent detail is the limit parameter default, but this is about how to use, not when.

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 openWorldHint. The description adds the pricing ($0.002 per call) and the Ethereum mainnet scope, which are behavioral traits not covered by annotations. 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?

Two sentences: first covers purpose and mutual exclusivity, second covers pricing. No filler, every word adds value. Front-loaded with the key action.

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 clear for a simple tool, but omits the return format (e.g., hex address string, null on failure) and error handling. Since there is no output schema, the agent is left to guess the result structure. Adequate but not fully complete.

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

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

Schema coverage is 100% with both parameters described. The description adds crucial semantics: 'Provide exactly one of name or address' (mutual exclusivity constraint not in schema) and provides an example value ('vitalik.eth') and clarifies 'EVM address' for reverse resolution. This adds significant meaning 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 states the tool resolves ENS names to addresses and reverse-resolves addresses to ENS names, explicitly mentioning Ethereum mainnet. It uses a specific verb (resolves) and resource (ENS name/address), and distinguishes between forward and reverse resolution. No sibling tool overlaps with this specific function.

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

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

The description provides clear guidance: 'Provide exactly one of name or address.' It also mentions the cost per call. However, it does not give explicit when-not-to-use instructions or compare with alternatives, though none are apparent among siblings.

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

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

Annotations already declare readOnlyHint (true), openWorldHint (true), idempotentHint (true), and destructiveHint (false), so the behavioral profile is well-covered. The description adds useful cost information ($0.003 per call) but does not elaborate on rate limits, pagination, or what happens on empty results. With annotations handling most behavior disclosure, this is adequate but not exceptional.

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

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

The description is two sentences: the first clearly conveys purpose and outputs, the second adds pricing context. No filler. It is front-loaded with the key action and result. Could be slightly improved by stating the data source or structural note, but overall efficient.

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

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

Given the tool is a simple search (2 params, read-only, no output schema), the description is reasonably complete. However, with no output schema, the description should clarify the return format more explicitly – e.g., is it a list of objects? What fields exactly? It mentions fields but not structure. For a non-complex tool, this is acceptable but leaves some ambiguity.

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

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

Schema coverage is 100% and both parameters have descriptions. The description adds no extra meaning beyond the schema – 'q' and 'limit' are already described in the input schema. Baseline 3 is appropriate since the schema does the heavy lifting, but the description could provide example values or clarify that 'q' is a keyword filter (already stated) and that 'limit' is a string, not integer.

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

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

The description clearly states it searches or lists open Kalshi prediction markets, and lists the returned fields (title, bid-ask, volume, close time). It distinguishes itself from siblings like search_polymarket_markets by mentioning 'Kalshi' and 'regulated US event contracts', though it could more explicitly contrast with the sibling get_kalshi_market.

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

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

The description provides no explicit guidance on when to use this versus alternatives. While the sibling list includes get_kalshi_market, search_polymarket_markets, and web_search, no comparison or when-to-use advice is given. The mention of '$0.003 per call' pricing is useful cost context, but usage boundaries are absent.

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

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

Annotations already convey safety (readOnlyHint, idempotentHint, openWorldHint). The description adds valuable behavioral traits: ranking by 24h volume, returned fields, cost ($0.003 per call), and the 'active' filter. This goes beyond what annotations 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 a single sentence with a brief pricing note, all front-loaded with the core purpose. No wasted words; every phrase 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 simple search tool with 2 optional params, no output schema, and strong annotations, the description is fairly complete. It covers output fields, ranking, cost, and active filter. It could mention output format or error handling, but given the tool's simplicity, this is adequate.

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

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

Schema coverage is 100% with both parameters described. The description does not add new meaning beyond the schema; it only lists 'question' in the returned fields, which is already clear from the schema's 'q' description. 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 action ('Search or list'), the resource ('active Polymarket prediction markets'), and the ranking ('by 24h volume'). It also lists the returned fields, making it distinct from sibling tools like get_polymarket_market (single market) and search_kalshi_markets (different platform).

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

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

The description implies usage for searching/listing polymarket markets but does not explicitly differentiate from sibling tools (e.g., when to use this vs. get_polymarket_market). The pricing note is a cost hint, not a usage guideline. No exclusions or alternatives are mentioned.

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

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

The annotations already declare readOnlyHint: true, openWorldHint: true, idempotentHint: true, and destructiveHint: false, which cover safety and side-effect behavior. The description adds the cost detail and the specific result fields (title, URL, etc.), which are useful beyond the annotations. However, it does not elaborate on other behavioral aspects like rate limits, data freshness, or what happens if the query is empty, so the added value is moderate.

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-loading the core purpose and output fields, then appending cost. Every word adds value, with no fluff or redundancy. It is as concise as possible while being informative.

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

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

Given the tool's simplicity (2 params, no output schema, no nested objects, rich annotations), the description provides enough: purpose, output fields, cost, and implicit usage context. It lacks an explicit example or mention of return format limitations (e.g., pagination), but the annotations and schema already cover safety and parameter constraints, making this adequately complete for a search tool.

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

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

Schema coverage is 100%, meaning the schema already documents both parameters (q and numResults) with descriptions. The description adds the default count (5) and the range (1-10) for numResults, and the cost per call, but does not further clarify query syntax or formatting. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states 'Real-time web search — ranked results with title, URL, published date, author, and relevance score for a query.', which specifies the verb (search), resource (web), and output fields. It distinguishes from siblings like get_protected_content (which likely retrieves a single protected page) and search_polymarket_markets (which is domain-specific), by indicating it searches the general web.

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 real-time web searches where you need ranked results with structured metadata. It does not explicitly say when not to use it or name alternatives (e.g., for protected content, use get_protected_content), but the context signals and sibling list provide implicit guidance. The mention of cost ($0.003 per call) is an additional usage hint, though not a direct exclusion.

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