x402-services

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

No annotations are provided, so the description must carry the full burden. It discloses output composition (score, tier, components) and mentions it's a paid tool (cost, endpoint). However, it does not explicitly state it is read-only or describe any side effects beyond the cost.

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

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

The description is concise (four lines) and front-loaded with key information (score range, tier, components). It includes useful extras (cost, endpoint) without excessive verbosity. Could be slightly tighter but is well-structured.

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 input (one parameter) and no output schema, the description covers purpose, input, output composition, and pricing. It does not detail the return format or tier interpretation, but it is sufficiently complete for informed use.

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 parameter described as '0x wallet address to score'. The description repeats this ('Send { address }') but adds no additional semantic meaning beyond the schema description. Baseline 3 applies.

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

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

The description clearly states it returns a reputation score (0-100) and tier for an address, listing components (activity, holdings, etc.) and the use case (decide whether to transact). It distinguishes from siblings like 'wallet_reputation' by mentioning 'agent economy', though overlap remains.

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

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

The description gives a clear use case ('Decide whether to transact with a wallet in the agent economy') but does not specify when not to use it or mention alternative sibling tools (e.g., compliance tools). No explicit exclusions or alternatives.

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

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

With no annotations, the description discloses payment ($0.005), input/output caps (8k chars / 1024 tokens), and model list. It omits failure behavior and latency but covers key traits.

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?

Single paragraph with all essential info front-loaded. Every sentence adds value, including the concise metadata footer. No unnecessary 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?

Lacks explicit return format description (no output schema), but chat completion's output is standard. Missing error handling details, but adequate for a simple 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%, and the description adds significant value by explaining defaults (model, temperature), constraints (maxTokens up to 1024), and format (OpenAI-compatible messages).

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's an LLM chat completion via x402, lists models, and mentions no accounts/API keys. It distinguishes from generic tools but doesn't explicitly differentiate from sibling 'ai_chat_pro'.

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 ease of use with no accounts/API keys, but does not provide explicit guidance on when to use this tool versus alternatives like 'ai_chat_pro' or 'ai_models'.

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?

No annotations provided, so description carries burden. Discloses payment method, character/token caps, price, and model selection. Lacks error handling or failure modes, but adequately informs about constraints.

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?

Single sentence covering purpose, models, compatibility, payment, caps, and price. No wasted words; front-loaded with key 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?

No output schema, but return format is standard for chat completions. Covers payment, caps, and models. Minor gap: no description of response structure.

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% (baseline 3). Description adds 'OpenAI-compatible messages' clarifying format, and mentions default model and caps. Does not elaborate on temperature range or maxTokens beyond 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?

Description clearly states it's a 'Frontier-model chat completion' tool listing specific models, OpenAI compatibility, payment details, and caps. Distinguishes from sibling 'ai_chat' (likely simpler/free) through explicit features.

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

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

Provides explicit context: supported models, payment requirements (USDG on Robinhood Chain or USDC), output caps, and price ($0.03). Does not directly compare with siblings, but sibling list includes 'ai_chat' implying alternative.

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?

No annotations provided, description carries full burden. Mentions payment and endpoint, but lacks details on authentication, rate limits, or other behavioral traits beyond listing models.

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 plus a bracketed note, front-loads purpose, 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?

For a simple list tool with no parameters and no output schema, description adequately covers what the tool returns (models per tier, prices, caps) and how to use it (POST endpoint, paid). Could mention output format but not critical.

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?

No parameters, schema coverage 100%. Description adds value by specifying the endpoint and payment requirement, which is helpful for invocation.

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

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

Clearly states it lists available LLMs per tier with prices and caps, distinguishing from sibling tools like ai_chat and ai_chat_pro which are for chatting, not listing models.

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 when to use this tool vs alternatives. Mentions it's a paid tool and the first of its kind, but no guidance on 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?

With no annotations, the description carries the full burden. It discloses the computation basis (daily closes), the indicators included, and the paid nature with price. However, it does not clarify what 'bullish/bearish signals' entail or any potential limitations, rate limits, or authorization requirements beyond the price note.

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 with a single sentence summarizing functionality and a bracketed note for pricing/endpoint. It is front-loaded with the key purpose, though the pricing info could be more integrated.

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 lack of output schema, the description does not explain the return format or structure. It mentions signals but leaves ambiguity. For a tool with two simple parameters, it covers input requirements adequately but omits output details, making it somewhat incomplete.

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 baseline is 3. The description adds the input format 'Send { coin, days? }' but does not provide additional meaning beyond what the schema already specifies for the 'coin' and 'days' parameters.

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

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

The description clearly states it computes technical indicators (RSI, SMA, EMA, MACD) from daily closes and provides bullish/bearish signals. It distinctly identifies the tool's purpose and differentiates it from sibling analytics tools like analytics_ohlcv (OHLCV data) and analytics_price_at (price at a point).

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 technical analysis but does not explicitly state when to choose this tool over alternatives. It mentions it's a paid tool (x402) but provides no guidance on when to use or not use it compared to other analytics 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?

No annotations provided, so description must carry burden. It mentions it's a paid tool ($0.005, POST endpoint), but does not disclose side effects, auth requirements, error handling, rate limits, or whether it's read-only. Lacks critical behavioral context.

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

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

Two concise sentences plus one-line cost/API note. Purpose is front-loaded, no wasted words. Every sentence adds value.

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

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

No output schema, so description should explain return values (e.g., format, fields). Also missing defaults for chain and limit, max candles, and behavior for missing pools. Incomplete for a paid tool with 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 coverage is 100%, so baseline is 3. Description adds no new meaning beyond listing parameters in a different format, except for clarifying timeframe resolution options (minute, hour, day), which is already in the schema's description. Little added value.

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?

Clearly states it returns OHLCV candles for a DEX pool at multiple resolutions. The verb 'candles' and resource 'DEX pool' are specific. Distinguishes from sibling analytics tools (e.g., analytics_indicators) by providing raw price-volume 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?

Implies use for charting data ('Charting data for any pool'), and notes it's a paid tool. But no explicit guidance on when to use vs. alternatives (e.g., analytics_price_at for single price points) or when not to use.

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?

No annotations are provided, so the description carries full burden for behavioral transparency. It discloses that the tool is paid (x402) and the endpoint. However, it does not mention data freshness, error behavior for invalid inputs, rate limits, or other behavioral traits. Given the lack of annotations, the description is insufficient.

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, consisting of a single clear sentence and a note with cost and endpoint. It conveys the core purpose efficiently. While there is minor redundancy, it is well-structured and easy to parse. The presence of extra details (cost/endpoint) slightly reduces conciseness but remains appropriate.

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 is simple with two parameters and no output schema. The description explains the purpose and basic input. However, it omits details about output format, error cases, and data availability. Given the low complexity, the description is adequate but could be more complete with expected behavior and return structure.

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 for parameters is 100%, with detailed descriptions for each parameter. The description repeats the parameter names ('Send { coin, when }') but adds little beyond what the schema provides. It does not clarify formats or constraints further. Therefore, the description adds minimal semantic value, earning a baseline score of 3.

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's purpose clearly: retrieving a historical price at a specific point in time. The verb 'get' is implied, and the resource is specified as token price at a past date/timestamp. The mention of use cases (backtesting, accounting, audits) reinforces the purpose. However, it does not explicitly differentiate from siblings like crypto_price or analytics_ohlcv, though the context implies it's for historical point 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 usage context by listing use cases (backtesting, accounting, audits) and includes a cost note. However, it offers no explicit guidance on when not to use this tool or alternatives. The context is sufficient to infer appropriate usage but lacks exclusionary 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?

No annotations provided, so the description carries the full burden. It discloses it's a paid tool (price $0.003) and the HTTP method, but does not mention error handling, authentication details beyond token, or rate limits. It adequately describes the read behavior but lacks depth.

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: the first states purpose, the second gives call format and pricing. No unnecessary words, front-loaded with key info.

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 hints at return values (value for a key, or list of key-entry pairs). It covers input, behavior, and pricing. Missing explicit return format but adequate for a simple read tool.

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

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

Schema coverage is 100% with all parameters described. The description repeats the parameter structure but adds no additional semantics beyond the schema. Baseline 3 is appropriate.

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

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

The description explicitly states 'read one key or list all keys+entries', clearly indicating the verb (read/list) and resource (shared blackboard). It distinguishes itself from the sibling tool 'board_set' which is for writing.

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 the required parameters and an optional key, but does not explicitly state when to use this tool versus alternatives like 'board_set'. The pricing and endpoint are included, but usage context is only implied.

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?

No annotations exist, so description must fully disclose behavior. It mentions 'shared blackboard' and 'multi-writer' implying concurrency, but fails to explain versioning behavior, idempotency, error handling, or response details. Critical gaps remain.

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-load purpose and input format. No wasted words, includes pricing and endpoint. Efficient and well-structured.

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?

Without output schema, the description should explain return values, versioning details, and concurrency semantics. It lacks this context, leaving the agent underinformed for a mutating shared resource.

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 parameters are documented. The description echoes the required fields without adding new semantics (e.g., what 'versioned key' means for the 'key' parameter). Minimal value beyond 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 sets a versioned key on a shared blackboard, with a distinct verb and resource. It distinguishes from sibling 'board_get' which reads, making 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 provides a usage example but no explicit guidance on when to use vs alternatives, such as when to prefer board_get or conditions for avoiding this tool. Context is limited to input format.

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

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

With no annotations, the description must disclose behavioral traits. It mentions weekend/holiday skipping but fails to describe output format, error handling, or timezone effects, leaving significant gaps.

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 defines purpose, second lists input shape and pricing. Front-loaded and efficient, though pricing info could be moved to reduce verbosity.

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?

No output schema exists, so the description should clarify return values (e.g., 'returns an ISO date string'). It does not, leaving the agent unsure of the tool's output format.

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

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

All 4 parameters are documented in the schema (100% coverage). The description adds minimal extra meaning beyond repeating parameter names and noting addDays can be negative. Baseline 3 applies.

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

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

The description clearly states the verb 'add/subtract' and resource 'business days', with specific behavior 'skips weekends + given holidays'. This distinguishes it from siblings like 'datetime' which does not specialize in business days.

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. The description includes pricing and endpoint but no context on prerequisites or when not to use it.

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

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

No annotations are provided, so the description carries full burden. It describes the tool as an 'exact calculator' with arbitrary precision and mentions pricing and endpoint. However, it does not disclose behaviors such as error handling, rate limits, or the format of results, which are important for an agent to use it correctly.

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

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

The description is a single sentence that efficiently conveys the core functionality, provides examples, and includes essential meta-information (pricing, endpoint). Every part serves a purpose with no redundancy.

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

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

For a calculator tool with well-documented parameters and no output schema, the description covers the primary functionality, examples, and pricing. It could additionally explain return format or error cases, but is sufficiently complete for an agent to invoke 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?

Schema coverage is 100% with descriptions for both parameters. The description adds value by providing usage examples ('3 inch to cm', 'sqrt(2)^10') that illustrate how parameters can be used together, and it indicates that 'precision' is optional with a question mark, going 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 'Exact calculator + unit conversion (arbitrary precision)' and provides concrete examples like '3 inch to cm' and 'sqrt(2)^10', making the tool's purpose unmistakable. Sibling tools are analytical or data retrieval tools; this is the only calculator, so it is well-differentiated.

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 mathematical and unit conversion tasks through examples but does not explicitly state when to use this tool versus alternatives, nor does it provide guidance on when not to use it.

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

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

No annotations are provided, so the description must define behavioral traits. It correctly identifies this as a read-only query and discloses it is a paid tool ($0.005). However, it does not mention rate limits, data freshness, error handling, or side effects – though none are expected for a calendar query.

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 relatively concise at two sentences plus a bracket. It front-loads the main purpose and includes practical details (paid tool, endpoint). The bracket notation is slightly cryptic but acceptable.

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 simplicity of the tool (2 optional parameters, no output schema), the description covers the core functionality and input. However, it lacks explanation of the output format (e.g., what data is returned per unlock) and does not differentiate from the sibling catalysts_unlocks tool, leaving the agent to guess usage boundaries.

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 has 100% coverage with clear descriptions for both 'days' and 'protocols'. The description merely restates them in a shorthand and adds no additional context, such as how to obtain protocol slugs or the meaning of default token basket.

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 an 'upcoming token-unlock calendar' with specific features: biggest unlocks, basket of tokens, time window, ranked by USD value. It distinguishes from siblings like catalysts_unlocks by emphasizing calendar format and ranking.

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 example input '{ protocols?, days? }' and explains the output purpose ('see which supply shocks are coming and when'). However, it lacks explicit guidance on when to use this versus related tools (e.g., catalysts_unlocks) or when not to use it.

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

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

No annotations provided, but description discloses paid nature ($0.005), HTTP method (POST), and endpoint path. It also describes the output structure, covering behavioral aspects 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?

Description is concise, front-loading the main purpose. Includes extra details (price, endpoint) but these are not excessive and provide useful context for an agent.

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

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

For a tool with no output schema, the description adequately describes return data (title, space, votes, end time). Covers all key aspects: purpose, parameters, output, and cost.

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?

Input schema covers 100% of parameters with full descriptions. The description adds no new information beyond the schema, 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?

Description clearly states it fetches on-chain governance proposals from Snapshot, ranked by voting power, with specific fields. This distinguishes it from sibling tools like catalysts_calendar and catalysts_unlocks.

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?

Description mentions 'Governance catalysts that can move token prices,' implying usage for price-impact analysis. It does not explicitly specify when not to use or name alternatives, but context is clear.

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

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

No annotations are provided, so the description carries the burden. It discloses that this is a paid tool ($0.005 per call) and the HTTP method (POST). It does not mention rate limits, idempotency, or read-only nature, which would be helpful. However, it is adequate for a straightforward search tool.

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 clear sentences plus a footer. It front-loads the purpose and uses bullet-like formatting for the API details. Every sentence serves a purpose without redundancy.

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

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

Given the tool's simplicity (no output schema, only 2 params), the description covers the main aspects: purpose, usage pattern, and cost. It could mention that the response includes a 'slug' and possibly other fields, but the hint to use the slug with catalysts/unlocks is sufficient context for an agent.

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 'query' and 'limit' already described in the schema. The description adds that 'query' is a name substring and 'limit' has a max of 100, but these are also in the schema. Therefore, the description adds minimal additional 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's purpose: to find protocols with tracked token-unlock schedules by name substring. It also specifies the output (slug) and its subsequent use. This distinguishes it from sibling tools like catalysts_calendar, catalysts_governance, and catalysts_unlocks.

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

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

The description provides a clear context for use: send a query and use the returned slug with catalysts/unlocks. It also notes it's a paid tool with a price and endpoint. However, it does not explicitly state when not to use this tool or mention alternatives among the many sibling tools.

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

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

No annotations are provided, so the description carries the full burden. It discloses the tool is paid ('x402 paid tool — price $0.005'), the endpoint ('POST /api/catalysts/unlocks'), and that it returns upcoming events. It does not detail error handling or rate limits, but the core behavior (read-only, returning unlock data) is adequately 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?

The description is three sentences long, with no unnecessary words. The first sentence states the tool's purpose, the second gives usage instructions, and the third adds context on value and pricing. It is front-loaded and every sentence earns its place.

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

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

Given no output schema, the description explains the return value structure: 'next unlock date, token amount, USD value, category and type, plus upcoming events.' It also covers pricing and endpoint. It is reasonably complete, though it could mention that 'limit' parameter controls the number of events (already in 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 coverage is 100% with 2 parameters. The description repeats the protocol slug requirement and mentions 'Max upcoming events, default 5 (max 20)' directly from the schema. It adds no additional meaning beyond what the schema provides, 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 clearly states the tool provides 'Token unlock / vesting schedule for a protocol' with specific data points: next unlock date, token amount, USD value, category/type, and upcoming events. It distinguishes itself from sibling tools like 'catalysts_calendar' and 'catalysts_search' by focusing on unlock events and requiring a protocol slug.

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

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

The description gives explicit usage instruction: 'Send { protocol } (slug, e.g. 'aptos', 'arbitrum')'. It also provides context on when this tool is useful: 'Large unlocks are the most reliable supply-shock catalysts — front-run sell pressure.' While it doesn't explicitly state when not to use, the context is clear and includes pricing info.

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?

Despite no annotations, the description reveals it is a paid tool (x402, $0.05) and includes the API endpoint. This adds behavioral context, though it does not explicitly state if it's read-only or other side effects. Cost transparency is a strong positive.

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 covering purpose, input, output, and pricing. It is front-loaded with the primary function. Could be slightly more concise by omitting the endpoint, 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?

With one required parameter and no output schema, the description adequately lists output categories (EOA, contract, protocol, scam) and tags. Pricing and endpoint context are included. Complete enough 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% (address with '0x EVM address' description). The tool description merely restates 'Send { address }', adding no new meaning. Baseline score of 3 is appropriate since schema already 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's function: labeling an address as EOA, contract, known protocol, or scam, with name and public tags. It distinguishes from sibling compliance tools like compliance_risk or compliance_screen by focusing on entity categorization.

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 tool versus alternatives (e.g., compliance_risk, compliance_screen). The pricing and endpoint are given, but criteria for choosing labels over risk scores 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?

With no annotations, the description carries full burden and discloses it is a paid tool (x402, $0.05), the HTTP method, and endpoint. It lacks details on side effects, but it is implied to be a read operation. Adequate transparency beyond minimal disclosure.

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

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

Three sentences, front-loaded with key functionality, includes pricing and endpoint. No filler; 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 one parameter, no output schema, and no annotations, the description explains the tool's output (risk level and flags) and input. Missing details on flags or score format, but sufficient for a simple 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% (address described as '0x EVM address'). The description repeats 'Send { address }' without adding meaning beyond schema. Baseline 3 is appropriate with no extra value.

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 addresses risk score (0-100) for an EVM address, including OFAC status, interaction with sanctioned addresses, contract verification, and activity. It differentiates from sibling compliance tools by focusing on a single risk score with flags.

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 implies usage for comprehensive risk assessment ('Chainalysis-lite risk in one call') but does not explicitly state when to use this tool versus alternatives like compliance_screen or compliance_taint. No when-not-to-use guidance.

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

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

No annotations are provided, so the description carries full burden. It mentions the tool is paid ($0.05) and uses a POST endpoint, but does not disclose whether it modifies state, required authorization, rate limits, or what happens if an address is found on the list. Basic behavioral traits are missing.

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, with two sentences plus a billing note. The first sentence immediately conveys the core purpose. Every sentence serves a clear function without unnecessary detail.

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 one parameter and no output schema, the description provides basic purpose and cost. However, it lacks details on return format (e.g., boolean, list), error handling, or any results behavior. For a simple screening tool, it is minimally adequate but could be more 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 a clear description of the 'address' parameter. The description adds 'Send { address }' which merely reinforces the schema. No additional semantic value beyond the schema is provided.

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 screens addresses against the US OFAC sanctioned-address list, using the verb 'screen' and specifying the resource 'address'. It is specific and informative, but does not differentiate from sibling compliance tools like compliance_label, compliance_risk, or compliance_taint.

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 before moving money legally ('Every agent moving money legally needs this pre-transaction check'), providing contextual guidance. However, it does not explicitly state when not to use it or mention alternative tools for different compliance checks.

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?

No annotations, so description carries full burden. Discloses paid x402 nature, price, endpoint, and base chain. Does not detail response format or error behavior, but describes intended boolean-like outcome ('does trace back?').

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?

Concise one-sentence description with practical tip and payment/endpoint note. Front-loaded with key question, 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?

Good contextual completeness given no output schema; describes expected outcome. Lacks explicit return format but inferable. Complexity handled adequately.

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% with parameter descriptions. Description repeats parameter info but adds no extra meaning beyond schema. Baseline 3.

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?

Explicitly states 'tainted-funds tracing' with clear verb 'trace' and resource 'incoming money' to sanctioned addresses. Distinguishes from siblings like compliance_screen by specifying multi-hop trace on Base.

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

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

Provides context 'Screen incoming payments before accepting them', indicating when to use. Does not explicitly exclude alternatives but implies use case. Could mention when not to use.

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

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

With no annotations, the description carries the full burden. It discloses atomicity, collision-freeness, cost ($0.003), and endpoint, but does not mention error handling or idempotency.

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 states purpose, second gives usage pattern and metadata. Every sentence is essential and front-loaded.

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

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

The tool has no output schema, and the description does not specify the return format (e.g., the new counter value). For a counter tool, the return value is critical, so this is a significant gap.

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

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

Schema coverage is 100%, so the schema already documents all parameters. The description adds only a shorthand listing without extra meaning beyond what the schema 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 clearly states the action ('increment-and-return') and the resource ('named counter'), and the phrase 'collision-free running totals & IDs across agent runs' uniquely identifies the tool's purpose, distinguishing it from siblings like idempotency or locks.

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 atomic counting and provides a parameter pattern, but lacks explicit guidance on when to use vs. alternatives, or prerequisites for token claims.

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?

No annotations provided. Description mentions paid nature and endpoint but does not explicitly state it is read-only or safe. Adequate but not thorough.

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?

Very concise, front-loaded with purpose, includes cost and endpoint. Every word contributes.

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

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

For a simple tool with no output schema, description sufficiently explains what the tool returns (next run times). Missing format details but 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?

100% schema coverage. Description adds context by showing expected JSON structure and noting optional parameters (count?, timezone?). Adds value beyond 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?

Clearly states the tool explains a cron expression by showing next N run times in a timezone. Distinguishes from siblings like schedule_cron which is for scheduling.

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?

Implied usage: when needing to understand a cron expression's future runs. No explicit when-not or alternatives, leaving some ambiguity.

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?

No annotations are provided, so the description carries full burden. It discloses the tool is paid (x402, $0.003) and the endpoint, but does not mention read-only nature, rate limits, or error handling. The cost disclosure is a positive, but otherwise the description lacks behavioral context.

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

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

Description is concise in three sentences, front-loading the core function. The sentence 'Agents profile what a wallet does' is somewhat redundant and could be removed, but overall it is efficient 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 no output schema and no annotations, the description is fairly complete by listing output components (transactions, methods, counterparties, actions). However, it does not specify the return format, depth of data, or error behavior, leaving some gaps for an agent.

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% for the single parameter 'address', which already describes it as a 0x EVM address on Base. The description adds minimal extra meaning, only restating 'send { address }' and 'for an address on Base'. No examples or format details are provided 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?

Description explicitly states it provides a wallet activity summary including recent transactions, top methods, distinct counterparties, and latest actions on Base. This clearly defines the tool's purpose and distinguishes it from sibling tools like crypto_tx or wallet_reputation.

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 over alternatives (e.g., rhchain_activity for other chains, crypto_tx for transaction listing). The description simply instructs to 'Send { address }' without providing context or exclusion criteria.

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?

No annotations provided, so description carries burden. It discloses cost ($0.003), endpoint, and that it reads any wallet holdings. Could add details on error handling or auth requirements, but overall good.

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, front-loaded with the core purpose. Every sentence adds value, from scope to usage to cost. 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?

For a simple tool with no output schema, it covers purpose, scope, cost, endpoint, and parameter. Could be more explicit about return format but 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%, so baseline is 3. Description mentions 'address' and 'Send { address }' but adds no meaning beyond schema's '0x EVM wallet address on Base'.

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 specifies the verb 'get balances' and resource 'wallet portfolio for an address on Base' with scope 'native ETH + all ERC-20'. It clearly distinguishes from siblings like crypto_token (single token) and crypto_price (price only).

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 states 'Let agents read any wallet's holdings' which clearly indicates a read operation. While it doesn't explicitly contrast with alternatives, the purpose is clear enough for usage context.

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?

No annotations are provided, so the description carries full burden. It discloses the paid nature, endpoint, and input formats, but does not detail error handling, verification requirements, or side effects. This is adequate but not highly transparent.

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: two sentences plus metadata. Every word is informative, no fluff, well-structured with function first, then context.

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 without output schema, the description covers the main use cases and cost. It lacks details on output format and error behavior, but is sufficiently complete for an agent.

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 redundantly explains the input types (address vs selector). It adds minimal value beyond the schema description, warranting the baseline score.

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

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

The description clearly states the tool decodes contract ABIs or selectors. It uses a specific verb ('decode') and resource ('contract'), distinguishing it from sibling tools like crypto_token or crypto_tx.

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 an agent needs to understand a contract before calling it, and specifies two input modes. However, it does not explicitly exclude other tools or provide when-not-to-use guidance.

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

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

No annotations provided, so description must carry full burden. It mentions 'live rates' and 'Instant FX' but doesn't disclose whether it's a read operation, potential errors, or rate limits. It implies a POST request but doesn't confirm no side effects. Adequate but not thorough.

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?

Extremely concise: two sentences plus a line with price and endpoint. Purpose is front-loaded, no wasted words. Every sentence adds value.

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

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

Simple tool with 3 required parameters and no output schema. Description covers the core behavior, use case, and pricing. Could mention return format or error handling, but for a conversion tool this is sufficient. Not complete enough for a complex tool but good here.

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 descriptions, so baseline is 3. Description adds value by providing an example ('e.g. convert 1.5 ETH to USDC') and explicitly listing the structure '{ amount, from, to }', reinforcing schema meaning.

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 it converts between crypto/fiat assets at live rates, with a specific example (1.5 ETH to USDC). The verb 'convert' and resources are explicit, and it distinguishes from siblings like crypto_price by focusing on conversions.

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

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

Provides a clear use case ('Instant FX for agents pricing on-chain actions') and notes it's a paid tool with price. Lacks explicit when-not-to-use or alternatives, but the example and context make usage clear.

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

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

With no annotations, the description discloses pricing ($0.003) and the HTTP method, but lacks details on idempotency, rate limits, or error handling. It adds value beyond schema but could be more transparent.

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 with the primary function. It includes pricing in brackets, which adds context without excess verbosity.

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 mentions possible outputs (address or name+avatar). For a simple tool with one parameter, it provides adequate context for an agent to use it correctly.

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

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

Schema coverage is 100% with a clear description of the 'input' parameter. The description repeats the usage (e.g., vitalik.eth or 0x address) but doesn't add new semantics 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 resolves ENS/Basenames to addresses and reverse-resolves addresses to names+avatars. It uses specific verbs and distinguishes from sibling crypto 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 human-readable identity resolution with 'Human-readable identity for agents.' However, no explicit when-to-use or when-not-to-use guidance is provided.

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?

No annotations are provided, so the description carries the full burden. It mentions it's a paid tool ($0.003) and the endpoint, but does not disclose rate limits, caching behavior, or how frequently the data is updated. The behavioral traits are minimal.

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

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

Three sentences, each with a distinct purpose: stating functionality, clarifying no input, and suggesting usage. The inclusion of pricing and endpoint info is slightly extraneous but still valuable. Concise 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?

Describes output as 'current gas price plus estimated cost (ETH & USD) for a transfer, swap, or mint', but does not specify the exact structure, units, or whether it includes base or priority fees. Without an output schema, more detail would be beneficial.

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

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

With zero parameters and 100% schema coverage, the description confirms 'Send {} — no input needed', adding value beyond the schema by explicitly stating no input is required. This is helpful for an agent.

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 is a 'Live Base gas oracle' providing current gas price and estimated costs for transfers, swaps, or mints. It specifies 'no input needed', which distinguishes it from potentially similar tools like crypto_price or exec_quote.

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

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

Explicitly says 'Agents budget transactions before acting', indicating when to use this tool. However, it lacks explicit when-not-to-use guidance or mentions of alternatives, though the use case is clear from context.

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

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

With no annotations, the description carries the full burden. It declares the tool is live, real-time, and paid (with price $0.003). But it omits details like rate limits, error handling for invalid symbols, and data freshness guarantees. The behavioral context is adequate but incomplete.

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

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

The description is a single sentence that front-loads the core purpose and includes an example. It also adds payment and endpoint info, which could be placed in annotations. Still, it is reasonably concise without waste.

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 is simple (1 param, no output schema). The description covers input format and purpose but fails to describe the output structure or behavior for invalid inputs. Given the lack of output schema, the description should include return value details.

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% for the sole required parameter. The description rephrases the schema's description and adds an example, but does not provide new semantics beyond what the schema already contains. 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 crypto and token prices in USD. It specifies the input format (tickers or coingecko IDs) and gives a concrete example. This distinguishes it from sibling tools that serve other functions like balances or transactions.

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

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

The description provides a clear usage example and notes the tool is for real-time on-chain pricing for finance/trading agents. However, it does not explicitly state when to avoid this tool or mention alternatives for similar tasks (e.g., crypto_convert for conversions).

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?

No annotations are provided, so the description carries full burden. It discloses that the tool is paid ('x402 paid tool — price $0.003; POST /api/crypto/token') and the HTTP method. It implies read-only operation. This adds value beyond the schema, though it does not mention rate limits or error conditions. A score of 4 reflects good transparency for a paid tool without 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 two sentences plus a concise payment note. It is front-loaded with the key outputs (name, symbol, etc.) and efficient. Every sentence earns its place; no waste.

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 having no output schema, the description explicitly lists the returned data (name, symbol, supply, holder count, source-verification, safety signals). For a single-parameter tool, this is complete enough for an agent to understand what it gets. No gaps.

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

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

Schema coverage is 100% with the address parameter described as '0x ERC-20 token contract address.' The description simply echoes 'Send { address }' without adding new semantics. Baseline is 3 since the schema already documents the parameter well.

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

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

The description clearly specifies the tool provides token intelligence: name, symbol, supply, holder count, source-verification, and safety signals. It states the use case 'vet a token before touching it,' distinguishing it from sibling tools like crypto_contract or safety tools. This is a specific verb+resource with clear differentiation.

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

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

The description states the primary use case ('vet a token before touching it') and how to use it ('Send { address }'). However, it does not explicitly exclude when not to use it or mention alternatives, though the context is clear. Scoring 4 for clear context but no exclusions.

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

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

No annotations are provided, so the description carries full burden. It discloses that the tool is paid ($0.003) and the endpoint (POST /api/crypto/tx). It does not mention rate limits or idempotency, but for a simple read-like query, this is adequate. No contradiction.

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

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

The description is extremely concise: one sentence listing fields, one sentence on usage, one sentence on cost and endpoint. No wasted words, front-loaded with the most important 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?

Given the tool's simplicity (1 parameter, no output schema, no annotations), the description is sufficient. It explains the tool's purpose, input requirement, and business context (paid tool). It does not detail return format but lists the fields, which 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 one parameter 'hash' already described in the schema. The description adds 'Send { hash }' which is redundant and adds no further meaning. 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 it provides transaction status and receipt on Base, listing specific fields like confirmations, success/fail, from/to, value, fee, method. It distinguishes itself from sibling tools like rhchain_tx by specifying the chain, and the purpose is 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 implies usage by saying 'Send { hash }' and indicates a use case for agents to confirm their on-chain actions. However, it does not explicitly state when to use alternatives or when not to use this tool, though mentioning 'on Base' provides some context.

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?

No annotations exist. Description adds cost ($0.003), HTTP method (POST), and endpoint, which is helpful. However, it doesn't explicitly state read-only nature or idempotency.

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 efficient sentences: first explains purpose, second shows usage. No fluff, all information earns its place.

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

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

Given no output schema, the description adequately explains source, filtering, ranking, and payment. Could mention output format but overall complete for a simple data retrieval tool.

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

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

Schema coverage is 100%, and the description adds default values (limit default 10, minTvl default 1,000,000) not in the schema. Also shows compact optionality syntax.

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?

Clearly states it fetches top DeFi yield opportunities from DeFiLlama, filterable by chain/project/min-TVL, ranked by APY. This distinguishes it from siblings like rh_yields and other crypto 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?

No explicit guidance on when to use this tool vs alternatives like rh_yields. The description only hints at usage with 'Yield discovery for finance agents', but lacks when-not or alternative names.

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?

Discloses pricing ($0.003) and endpoint (POST /api/datetime), indicating a paid tool; no annotations provided, so description adequately covers cost and method, though could mention error handling or response format.

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

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

Three short sentences front-load purpose and operations; every sentence adds value with no redundancy.

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

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

No output schema exists, and description omits any mention of return values or format; for a tool with 6 parameters, this is a significant 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 all parameters described; description summarizes the JSON structure and operation types, but adds no additional meaning 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?

Description clearly states 'Date/time math + timezones' and lists four specific operations (now, convert, add, diff), making the purpose unambiguous and distinguishing it from sibling tools like calc or business_days.

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?

Implies usage through operations list and parameter structure; lacks explicit when-not-to-use or alternatives, but context is clear for date/time manipulation tasks.

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

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

The description discloses the pricing ($0.003) and HTTP method (POST), but does not cover error conditions, rate limits, or what happens if the switch fires. With no annotations, this leaves gaps.

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 efficient sentence plus a bracketed note, front-loading the purpose 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?

For a simple heartbeat ping with 2 required params and no output schema, the description covers the core behavior. However, it lacks guidance on the required ping interval to prevent firing.

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 descriptions for both parameters ('Switch id' and 'Your secret token'). The description adds no meaning 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 clearly states it sends a heartbeat to keep a deadman's switch from firing, with a specific verb and resource. It distinguishes itself from the sibling 'deadman_register' which likely handles registration.

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 after registration but provides no explicit guidance on when to use or when not to use this tool versus alternatives. No exclusion criteria 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?

With no annotations, the description covers key behavioral traits: it's a paid tool ($0.003), triggers a POST to a webhook on missed pings, and requires specific fields. It provides enough context for safe usage.

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, with two clear sentences and a structured list of required fields. 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?

For a registration tool with no output schema, the description covers the trigger mechanism, price, and endpoint. It provides sufficient context for proper 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%, and parameter descriptions in the schema already explain each field. The description only repeats this info without adding new semantic meaning.

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

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

The description clearly states the tool's purpose as a deadman switch that posts a webhook if not pinged. It distinguishes from the sibling 'deadman_ping' by indicating the registration action.

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 it (to detect crashed agents) and implicitly distinguishes from the 'deadman_ping' tool. However, it does not explicitly list alternatives or when not to use.

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

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

With no annotations, the description carries the burden. It explains the diff output (added/removed/changed by path) and includes pricing. However, it does not explicitly state read-only behavior or other constraints.

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 covering purpose, input format, payment, and endpoint. No unnecessary words.

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

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

Given the absence of an output schema, the description provides a good idea of the return format (diff by path). It may lack details on pagination or error modes, but is sufficient for a simple diff 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% and parameters are described in the schema as 'First JSON value' and 'Second JSON value'. The description adds minimal extra meaning beyond reinforcing the structure.

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 specifies a 'structured deep diff' of two JSON values, showing changes by path, and requires input in the form { a, b }. This clearly distinguishes it from other tools like 'extract' or 'jsonschema'.

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 the input format explicitly ('Send { a, b }') and mentions the tool is paid, but does not provide when-to-use or when-not-to-use guidance or alternatives.

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?

No annotations are provided, so the description carries the full burden. It discloses that it returns an id, mentions pricing and endpoint, and notes it's not fund custody. However, it does not indicate whether the operation is persistent, idempotent, or if there are side effects such as creating a database record. Missing behavioral details like error handling or concurrency implications.

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 key parameters, then adds pricing and endpoint details. At about 150 characters, it's moderately concise. The pricing and endpoint could be separated but do not detract significantly. Every sentence adds value, though the x402 note could be moved to annotations.

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

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

The tool has 6 parameters (5 required) and no output schema. The description explains the purpose and return value (id) but does not elaborate on the response structure (e.g., format of id) or how to use the id with other tools. Given the sibling tools for status and resolving, it is functionally complete but lacks some context on the full workflow.

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 baseline is 3. The description adds value by specifying that 'token' is a secret (>=8 chars) authorizing resolution, 'deadline' is an ISO date, and 'condition' is plain-English, which clarifies the format beyond the schema's brief descriptions. This helps the agent understand 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 the tool creates an agent-to-agent conditional payment agreement, listing key parameters (payer, payee, amount, condition, deadline) and the return value (id). It differentiates from sibling tools like escrow_list, escrow_resolve, escrow_status by focusing on the creation action.

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 specifies the use case (A2A conditional payments, coordination layer) and provides context that it's a registry, not fund custody. While it doesn't explicitly state when not to use it or name alternatives, the sibling tools imply related operations. Could be improved with explicit when-not conditions.

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?

No annotations exist, so the description must disclose behavior. It reveals the tool is a paid (x402) operation with a specific endpoint and cost, but does not clarify if the tool is read-only, what happens when both token and party are sent, or any rate limits. The payment information is valuable but incomplete without safety traits.

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 convey the tool's purpose and a key usage constraint, with no wasted words. The endpoint and cost are appended cleanly.

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 tells what the tool does and which parameters to use. However, it omits return format, pagination details for limit, error handling, and behavior when both token and party are sent. It is adequate but not exhaustive.

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 descriptions for all three parameters. The description adds nuance by suggesting you send either token or party, but this is already implied by the schema's optionality. It does not reduce ambiguity for limit usage or pagination.

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 name 'escrow_list' clearly indicates listing escrows. The description specifies listing conditional-payment agreements for a token or party, distinguishing it from sibling tools like escrow_status, escrow_resolve, and escrow_create.

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 token or party parameters, but does not explicitly contrast with escrow_status (which checks a specific escrow) or specify scenarios where not to use this tool. The 'or' phrasing implies mutual exclusivity, but this could be clearer.

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?

Discloses payment info ($0.05 fee) and HTTP method/endpoint. No annotations provided; description lacks detail on irreversibility or effect on escrow state. Adequate but not rich.

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

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

Two efficient sentences: first explains purpose, second lists input and metadata. No redundant words; 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?

Covers purpose, input, and cost. No output schema; lacks explanation of settlement instruction or result of resolution. Adequate for a simple tool but could be more comprehensive.

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 parameters are already documented. Description adds value by listing them and clarifying 'outcome' values ('release or refund'). 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?

Clearly states the action: 'Resolve a conditional-payment agreement' with two specific outcomes ('release' and 'refund'). Distinguishes from siblings like escrow_create and escrow_status.

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

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

Explicitly says 'the creator marks' and lists the required input fields. Does not explicitly state when not to use or alternatives, but context makes it clear.

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

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

No annotations are provided, so the description must cover behavioral traits. It discloses that the tool is paid ($0.005) and the endpoint, which is useful. However, it does not mention idempotency, error handling, or other behavioral nuances.

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 (one sentence plus a pricing/endpoint note) with no wasted words. It is well-structured and front-loaded.

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

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

Given the tool's simplicity (one parameter, no output schema), the description fully covers what an agent needs: input format, possible states, and pricing. It is contextually 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 a clear description for the 'id' parameter. The description adds 'Send { id }' but does not provide additional 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 clearly states the tool checks the state of a conditional-payment agreement and lists the possible states (pending/released/refunded/expired). This distinguishes it from sibling tools like escrow_create or escrow_list which handle creation or listing.

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

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

The description implies usage by saying 'Send { id }' but does not explicitly provide when-to-use or when-not-to-use guidance, nor does it mention alternatives among the many sibling tools.

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

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

Since no annotations are provided, the description carries full burden. It discloses that the tool is a paid x402 tool with a price of $0.005 and the API endpoint. This is valuable behavioral context beyond just functionality. 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?

Description is succinct with three sentences, front-loading the main purpose and including practical details (cost, endpoint) at the end. No 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?

For a simple tool with one optional parameter and no output schema, the description covers main behavior, supported chains, cost, and usage hint. Could be more complete by mentioning return format, but not essential.

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 one parameter (chains) described. The description adds 'Send { chains? }.' which essentially repeats the schema info. Minimal added 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?

Description clearly states 'Live gas prices across major chains' and lists specific chains (Base, Ethereum, Arbitrum, etc.), including 'estimated USD cost of a swap.' This distinguishes from siblings like crypto_gas or exec_quote which may not focus on cost or multi-chain comparison.

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

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

Description implies usage context: 'Time and route transactions for the cheapest execution.' It also mentions the optional chains parameter. However, it does not explicitly state when not to use or provide alternatives 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?

No annotations provided, so description carries full burden. Discloses it's non-executing, uses KyberSwap, lists return fields. 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 sentences covering purpose, usage, and key constraint. No fluff. Pricing/endpoint info appended neatly.

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, description adequately explains return fields. Covers required parameters and chain options. Could explicitly list all return fields, but current is sufficient.

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 all 4 parameters with descriptions. The description reinforces amountIn in smallest units, but does not add substantial new meaning beyond 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?

Clearly states it provides best-route swap quotes across DEXes via KyberSwap aggregator, listing return fields. It distinguishes from execution tools by explicitly saying 'Quote only — never executes.'

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?

Tells what to send (chain, tokenIn, tokenOut, amountIn) and that it's for pre-trade routing. Implicitly when not to execute, but no explicit alternatives.

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

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

With no annotations, the description must fully disclose behavior. It states the tool provides a risk score and mitigations, and notes it is a paid tool costing $0.05. However, it does not explicitly state that it is read-only and does not execute trades, nor does it discuss authentication or rate limits.

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 with the key purpose. It includes usage instructions, the output type, and cost. The inclusion of 'Trade without getting sandwiched' is slightly redundant but not harmful.

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 (4 parameters, no output schema), the description covers the basic inputs and output concept. However, it lacks details on the exact format of the risk score or mitigations, which would be helpful for an agent to parse the result.

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

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

Schema coverage is 100%, so the description's parameter information adds little beyond the schema. It lists the parameters in a shorthand format but does not provide additional context or examples beyond what the schema already documents.

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 evaluates sandwich/MEV risk for a planned swap and provides concrete mitigations. It distinguishes itself from sibling tools like exec_quote, exec_gas, and exec_slippage by focusing on risk scoring rather than execution or quoting.

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 specifies the required inputs (chain, tokenIn, tokenOut, amountIn) and implies the tool is used to assess sandwich risk before swapping. However, it does not explicitly mention when not to use this tool or compare it to alternatives like exec_quote for quoting or exec_slippage for slippage estimates.

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?

No annotations exist, so description carries full burden. It discloses cost ($0.005) and API endpoint, and describes it as a paid tool. This adds valuable behavioral context beyond typical tool descriptions.

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 plus one metadata line, all front-loaded with essential information. No unnecessary 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?

Missing output schema; description mentions a 'rating' but does not explain output format or fields. Adequate for a simple input tool but leaves uncertainty about return value structure.

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 descriptions for all 4 parameters. The description reiterates the parameter list but adds no additional meaning beyond the schema, meeting 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 clearly states the tool recommends max slippage based on live price impact and buffer. It specifies the input format and resource, though does not differentiate from sibling tools like exec_quote or exec_gas.

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 advises to 'avoid failed txns and overpaying', giving an implied use case. However, it lacks explicit when-to-use vs alternatives or when-not-to-use guidance.

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

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

No annotations are provided, so the description carries the full burden. It only adds pricing and endpoint info, but fails to disclose error handling, rate limits, input size limits, or what happens with malformed HTML. The behavioral context is minimal.

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, clear sentence with essential information (action, output format, pricing, endpoint). No redundant words; every phrase earns its place.

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

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

Given the tool has one parameter with full schema coverage and no output schema, the description provides the core extraction fields. However, it lacks details on error responses, maximum HTML size, or whether the output always includes all listed fields. Adequate but with gaps.

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 one parameter (html) with 100% coverage. The description adds value by listing the extracted fields (title, links, meta, headings, text), giving the agent a better understanding of what the tool does with the input, beyond the schema's 'Raw HTML'.

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 extracts structured data (title, links, meta, headings, text) from HTML as JSON. It specifies the output format and includes pricing info, which helps differentiate it from sibling tools like regex or markdown, though it doesn't explicitly contrast with them.

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

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

No explicit guidance on when to use this tool versus alternatives. The description mentions it's a paid tool with a price, implying it's for cases where structured extraction is needed, but lacks when-not-to-use notes or alternative suggestions.

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

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

The description discloses the core behavior: firstTime:true only once per key within TTL. It also mentions it is a paid tool with a price. However, it lacks details such as what happens after TTL expires, potential error conditions, or rate limiting. Without annotations, the description carries the full burden and could be more transparent.

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: a single sentence plus key metadata (price, endpoint). No wasted words, and the core functionality is front-loaded. Every sentence earns its place.

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

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

For a simple tool with three parameters and no output schema, the description provides enough context to understand the behavior and usage. It covers the key feature and pricing. Minor gaps: does not explicitly state the response format beyond 'firstTime:true', but that is implied.

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 each parameter. The description adds little beyond restating the payload format. It confirms ttlSec is optional and notes the default is implicit from schema. Given high schema coverage, a baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose: it provides idempotency keys with a firstTime flag for deduplicating retries or double-sends. The verb 'returns' and resource 'idempotency key' are specific and 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 indicates when to use the tool (for deduplication) and provides the required payload format. However, it does not explicitly mention when not to use it or compare to alternatives. Since no sibling tools overlap, this is acceptable but leaves room for improvement.

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

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

With no annotations, the description provides some behavioral context: it's a paid tool, creates a disposable URL, captures POSTs. However, it omits details like expiration time, response format, or side effects. 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 very concise (two sentences) and front-loads the core purpose. The inclusion of pricing and endpoint info is extra but not excessive, keeping it 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 no output schema, the description should explain what the tool returns (the URL), which it hints at but does not explicitly confirm. The mention of 'disposable URL' is helpful but not fully complete. For a simple tool this is adequate but not thorough.

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 schema already describes the token parameter. The description merely restates 'Send { token }' without adding new meaning. Baseline 3 applies.

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

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

The description clearly states the tool creates a disposable webhook inbox URL that captures inbound POSTs for polling. It uses a specific verb (get) and resource (disposable URL), and distinguishes from sibling inbox_poll which retrieves messages.

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 a workflow (create inbox then poll) but does not explicitly state when to use this tool versus alternatives like inbox_poll. No guidance on prerequisites or when not to use it.

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

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

No annotations are provided, so the description must fully disclose behavior. It mentions the tool is paid and uses POST, but omits key details like idempotency, error handling, or what happens when no new messages exist. This is insufficient for safe and effective use.

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—one clear sentence plus a parenthetical with endpoint and pricing. It front-loads the purpose and includes essential operational details without waste. Every part earns its place.

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

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

For a simple polling tool with 3 parameters and no output schema, the description is adequate but incomplete. It doesn't describe the response format, pagination, or potential errors. The pricing and endpoint info help, but the agent lacks full context for reliable integration.

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 repeats the schema structure ('id', 'token', 'since?') without adding new meaning or clarifying the format of 'since' beyond what the schema already says. It meets the minimum but adds no extra value.

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 fetches captured messages from a webhook inbox newer than a timestamp. It specifies the request format and distinguishes itself from sibling 'inbox_create' by focusing on polling. The purpose is unambiguous and well-defined.

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?

While the description indicates when to use the tool (fetching messages), it provides no guidance on when not to use it or how it compares to alternatives like 'pubsub_poll' or 'queue_pop'. The agent is left without context for tool selection.

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

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

No annotations are provided, so the description carries the full burden. It mentions 'strict' validation and returns detailed errors, but does not explicitly confirm read-only behavior or disclose side effects, rate limits, or other traits. However, validation is inherently read-only, so the description is adequate but not rich.

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

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

The description is extremely concise with two meaningful sentences and metadata. Every sentence adds value, and the primary action 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 validation tool with 2 parameters, no nested objects, and no output schema, the description covers purpose, input format, and pricing. It is complete and sufficient 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 description coverage is 100%, so the baseline is 3. The description only repeats the parameter names ('Send { schema, data }') without adding additional meaning beyond what the schema 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 clearly states the verb 'validate' and the resource 'data against a JSON Schema', with a specific result 'Returns valid + detailed errors'. It effectively distinguishes the tool's purpose from sibling tools, which are mostly unrelated.

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?

While not explicitly stating when to use or alternatives, the description provides context such as 'strict' validation and pricing ($0.003). The paid nature implies it should be used when validation is needed, but no exclusions are given.

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?

No annotations provided, so description carries full burden. Describes tool as paid ($0.05, x402) and read-only (position health check). Adds context about endpoint and pricing beyond schema. Could be more explicit about idempotence, but nature implies safety.

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?

Extremely concise: two sentences plus a pricing line. No fluff; key information is front-loaded (protocol, output fields, input format, pricing).

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 2 parameters, no output schema, and no annotations, description covers essential aspects: what it returns (health factor, etc.), input format, pricing, endpoint. Missing return structure details, but sufficient for a simple read 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% (both parameters described in schema: address as 0x wallet, chain with default/base). Description repeats 'Send { address, chain? }' without adding new meaning or constraints beyond schema. Baseline 3 applies as 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?

Description clearly states it provides health factor, collateral, debt, liquidation buffer, and risk verdict for an Aave v3 wallet. It distinguishes from siblings like lending_liquidations and lending_rates.

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?

Indicates when to use: to know liquidation risk before it hits. Provides input format (address, optional chain). Does not explicitly state when not to use, but context implies alternatives (e.g., lending_liquidations for actual liquidations).

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?

No annotations provided, so description carries full burden. It discloses pricing but lacks details on result format (e.g., empty results, real-time vs cached), though basic behavior is conveyed.

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?

Description is concise and includes essential info (purpose, parameters, pricing), though slightly fragmented. Every sentence serves a purpose.

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

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

With no annotations or output schema, the description covers purpose, output elements, optional parameters, and cost. Missing return format details but adequate for 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%, so baseline is 3. The description repeats parameter names with defaults but adds no new semantic depth beyond the schema's 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 it's a liquidation-opportunity scanner for Morpho Blue borrower positions with health factor < 1, listing returned data (borrower, market, debt, collateral in USD). It distinguishes from siblings like lending_health and lending_rates by focusing specifically on liquidatable positions.

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?

Targets searcher/liquidator agents and mentions pricing. While it doesn't explicitly state when not to use or name alternatives, the context is clear enough for its niche use case.

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?

No annotations are provided, so the description bears full responsibility. It states the tool returns APYs and TVL ranked by yield, which implies a read-only operation. However, it does not explicitly disclose safety or non-destructive behavior, leaving some ambiguity.

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

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

A single, compact sentence that front-loads the core purpose and includes pricing and endpoint info. Every sentence contributes value with no redundancy.

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

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

Given no output schema and no annotations, the description adequately explains the output (APYs, TVL, ranking) and the primary input. It could mention the return format or pagination, but it is mostly complete for the tool's complexity.

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

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

All three parameters have schema descriptions (asset, chain, limit). The description adds minimal extra meaning beyond the schema, such as showing the expected structure '{ asset, chain? }'. With 100% schema coverage, a baseline of 3 is appropriate.

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

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

Description clearly states the tool provides the best supply/lending APYs for an asset across multiple protocols (Aave, Compound, etc.) ranked by yield with TVL. This distinguishes it from sibling tools like crypto_yields, rh_yields, lending_health, etc.

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?

Description says 'Rate-shop where to lend' and 'Send { asset, chain? }', implying the tool is used to find best lending rates. It does not explicitly state when not to use or alternatives, but the context from sibling names and the clear use case provides sufficient 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?

No annotations are provided, so the description carries full burden. It discloses pricing and endpoint, but fails to detail key behaviors such as how results are returned (e.g., per-URL status), what happens on non-200 responses, or any rate limits/auth requirements. This is insufficient for a tool with zero annotation coverage.

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

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

The description is extremely concise: one sentence with a bracketed note. It front-loads the purpose and includes essential operation details without any fluff.

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

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

With one parameter and no output schema, the description covers input format and pricing, but omits important details about the return value (e.g., format, per-URL results). This is a notable gap for a simple 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% (one parameter with description). The description reinforces the array format and the 'up to 50' constraint but adds no new semantic depth beyond the schema. Baseline score of 3 is appropriate.

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

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

The description clearly states the tool checks up to 50 URLs for HTTP 200 status, specifically for dead-link detection. It uniquely identifies a batch link-liveness action, distinguishing it from any other sibling tools (none similar).

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 basic usage guidance by specifying the input format (Send { urls: [..] }) and mentions it's a paid tool with price. However, it does not offer explicit when-to-use or when-not-to-use guidance, nor does it reference alternatives, though no similar sibling tools 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?

With no annotations, the description must carry full burden. It discloses pricing, endpoint, and the 'acquired:false' case, but does not specify the exact success response (e.g., acquires:true) or behavior details like idempotency or concurrency guarantees.

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 with the core action. It packs purpose, input format, pricing, and endpoint in two sentences. Minor redundancy ('Send { name, token, ttlSec? }' could be omitted given schema, but it aids quick scanning.)

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

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

The description covers the basic essentials: what it does, input, and failure case. However, it omits the success response format and details about the 'token' parameter's role in payment. For a simple tool, this is 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%, so baseline is 3. The description adds context: ttlSec is optional with default (60) and max (3600), and hints that 'token' is the secret token for payment. This goes slightly beyond the schema but not extensively.

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

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

The description clearly states the tool's action ('acquire a named lock') and its effect ('so only one agent proceeds'). It distinguishes from sibling 'lock_release' by implication, providing a specific verb and 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 gives clear context: it's a distributed lock for exclusive access. It mentions the input format and a paid price. However, it lacks explicit 'when-not-to-use' or direct comparison to alternatives beyond 'lock_release'.

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?

No annotations provided, so description must disclose behavioral traits. It mentions cost ($0.003) and HTTP method/endpoint, but does not describe error behavior (e.g., invalid token, lock not held), idempotency, or side effects.

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 plus a concise metadata line. Every sentence is informative with no redundancy.

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

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

No output schema, and description omits return values or confirmation behavior. For a release action, it would benefit from mentioning success indication or idempotency.

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 adds little beyond the schema: it lists parameters inline and marks 'holder' as optional (already indicated by schema). No new semantic details.

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?

Clearly states the action ('release') and resource ('distributed lock you hold'). The phrase 'you hold' ensures the agent understands it operates on locks already acquired, distinguishing from the sibling 'lock_acquire'.

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?

Implies usage when holding a lock, but does not explicitly state when to use versus alternatives (e.g., lock_acquire). Provides no guidance on prerequisites or failure conditions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states that it strips nav/script/style noise, which is a key behavioral trait. It also notes it's a paid tool with price and endpoint. However, it does not mention any other side effects or limitations.

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 at two sentences, with no redundant information. It front-loads the core purpose. However, it could be slightly more structured by separating the pricing/endpoint info into a secondary mention.

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

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

Given the tool's simplicity (one parameter, no output schema), the description covers key aspects: purpose, noise stripping, pricing, and endpoint. It provides enough context for an agent to invoke the tool correctly without needing additional clarification.

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

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

There is only one parameter ('html') with schema description 'Raw HTML'. The tool description does not add any further meaning or constraints beyond what the schema already provides. Since schema coverage is 100%, a baseline of 3 is appropriate.

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

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

Description clearly states the action ('Convert'), the input ('raw HTML'), and the output ('clean, LLM-ready markdown'). This is a specific verb-resource combination that distinguishes it from siblings, none of which perform HTML-to-markdown conversion.

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 specify when to use this tool vs alternatives or when not to use it. It provides no exclusions or context about suitability, leaving the agent to infer usage solely from the purpose.

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?

Discloses it's a read-only, paid tool with price and endpoint. No annotations, so description compensates well. Lacks details on idempotency or rate limits, but sufficient for a simple read.

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 concise sentences, front-loaded with purpose. Zero waste, includes payment info efficiently.

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

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

For a low-complexity read tool, description is complete. No output schema, but output is simple. Missing namespace explanation but schema covers required fields.

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 all params (100%). Description adds value by explaining key's special behavior (omit to list keys), going beyond schema definitions.

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?

Clearly states the tool reads a stored value by key or lists all keys, with explicit verb and resource. Distinguishes from memory_set (write counterpart) via sibling list and context.

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?

Implicitly guides usage: use to read a value or list keys. No explicit when-not or alternatives, but the sibling memory_set provides clear context for differentiation.

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?

Since no annotations are provided, the description carries the full burden. It discloses key behaviors: size limit (16KB max), namespace ownership on first write, required token, and pricing. However, it does not mention overwrite behavior or error conditions, which slightly reduces transparency.

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

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

The description is very concise, consisting of two clear sentences plus a pricing line. It front-loads the core purpose and includes essential details without any redundant information. Every sentence contributes 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 no output schema, the description does not mention return values or error handling. It covers namespace ownership, key/value specifics, and cost, but misses overwrite behavior and success response. This leaves the agent with some uncertainty for a write operation.

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 adds minimal extra meaning, such as the token being set on first write. The schema descriptions already cover the parameters adequately, so the description provides limited additional semantic value.

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

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

The description clearly states the tool's purpose: 'durable key-value storage that survives between agent runs' and 'Write a JSON value under a key'. It distinguishes itself from the sibling 'memory_get' by being a write operation, and provides context about namespace ownership and token usage.

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

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

The description implies usage for persisting data across runs but lacks explicit guidance on when to use this tool versus alternatives like 'memory_get' or other storage tools. There is no when-to-use or when-not-to-use statement, leaving the agent to infer context.

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?

No annotations provided. Description discloses it is a paid tool ($0.005) and uses POST method, but does not discuss rate limits, authorization needs, failure modes, or any other behavioral traits.

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 with no wasted words. Front-loaded with core purpose and data returned. Additional details (payment, endpoint) are in brackets, keeping the main description clean.

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 data retrieval tool with 3 params and no output schema, the description covers the returned data fields, pricing, and supported currencies. Missing response format details (e.g., JSON array) but acceptable for this complexity.

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

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

Schema coverage is 100% (all three parameters have descriptions). Description adds minimal value by summarizing 'Send { currency, expiry? }' and noting expiry defaults to nearest. This is adequate but does not provide additional 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?

Clearly states tool returns full options chain for a currency and optional expiry, listing specific data fields (mark price, IV, open interest). Distinguishes from siblings like options_greeks or options_price by specifying 'per-strike calls & puts' and 'complete options board'.

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 when-to-use or alternatives are given. The description implies use when needing full options chain data, but does not compare with other options tools or provide guidance on tool selection.

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

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

No annotations are provided, so the description carries the full burden. It discloses pricing ($0.05) and endpoint, but does not mention other behavioral traits such as idempotency, rate limits, or whether it mutates state. As a calculation tool, the read-only nature is implied but not stated.

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 three sentences, front-loaded with purpose, and includes essential details (input format, flexibility, pricing) without fluff. Every sentence adds value, making it highly scannable for an agent.

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

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

Given the tool's complexity (greeks) and lack of an output schema, the description provides a reasonable overview of outputs ('fair value + full greeks'). However, it could be improved by specifying the return structure or noting that greeks are standard names. Still, it is mostly adequate for an agent to understand 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 description coverage is 100%, so the baseline is 3. The description restates the required parameters in a shorthand format but adds no additional semantic detail beyond the schema. The note about 'iv in %' is already in the schema.

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

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

The description clearly specifies that it performs Black-Scholes option pricing with full greeks, using a specific verb ('Price') and resource ('option'). It distinguishes from sibling tools by stating 'for ANY option, listed or not', implying broader applicability than exchange-specific 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 the required input format and notes the tool is paid, but does not explicitly state when to use this tool versus alternatives (e.g., options_price for just price) or when not to use it. The context of 'full greeks' implies use case, but lacks explicit 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?

No annotations provided, so description carries full burden. It discloses the paid cost ($0.005) and endpoint (POST), but does not state if the tool is read-only, has destructive side effects, or data freshness guarantees. Adequate but incomplete.

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?

Extremely concise: two sentences define purpose and input, plus a compact note on cost and endpoint. No wasted words; 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 paid financial tool with no output schema, the description covers the output (max-pain strike + ratio), input, cost, and endpoint. Missing explicit output structure details, but remains adequate 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 covers both parameters with descriptions (e.g., 'BTC, ETH, or SOL' for currency). The description merely restates input format without adding new meaning beyond the schema. Baseline score of 3 applies due to high schema coverage.

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 'Max-pain strike + put/call open-interest ratio' and defines max-pain as the price level where option holders lose most. This distinguishes it from sibling tools like options_chain or options_greeks, 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?

Description specifies input format ('Send { currency, expiry? }') but does not provide guidance on when to use this tool versus alternatives, nor any exclusions. The paid nature is noted, but no explicit context for optimal use.

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

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

With no annotations provided, the description carries full burden. It discloses the tool is paid ($0.05), live from Deribit, supports BTC/ETH/SOL, and returns specific fields. However, it lacks details on error handling, data freshness, or rate limits.

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 covering purpose, input formats, output fields, and pricing. Every sentence adds essential information with no redundancy.

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

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

Given the tool has 5 optional parameters and no output schema, the description is highly complete. It explains both input alternatives, the origin (Deribit), supported assets, and the specific fields returned (mark price, IV, etc.), compensating for the missing 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 input schema has 100% description coverage, and the description adds significant value by showing two parameter groups (instrument vs. currency+strike+type+expiry) with an example (BTC-28AUG26-70000-C). This clarifies usage 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 a live crypto option quote from Deribit, listing specific data fields (mark price, IV, open interest, greeks, underlying). It distinguishes from sibling tools like options_chain or options_greeks by focusing on a single option quote.

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 getting a single option quote via two input formats (instrument or currency+strike+type+expiry) but does not explicitly guide when to use this tool versus alternatives like options_chain or options_greeks. No exclusions or comparisons are provided.

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

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

With no annotations, the description provides interpretive context ('Rising IV = rising expected volatility') and cost/endpoint info, but does not disclose rate limits, destructive potential, or other behavioral traits beyond the paid 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 brief (two sentences plus a note) and front-loaded with key information. The bracket note about cost and endpoint is useful but could be integrated more smoothly.

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 one parameter and no output schema, the description explains what is returned (term structure, front-month IV) and interpretation. However, it does not specify output format or data structure, leaving 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% with a clear enum-like description for currency. The description merely repeats 'Send { currency }' without adding new meaning or format details beyond the schema.

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