x402 Trading & On-Chain Intelligence

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

With no annotations, the description fully discloses behavioral traits: it explains the score is based on activity, holdings, counterparty diversity, and sanctions, and reveals tier categories. It also mentions the pricing and endpoint, leaving no hidden behaviors.

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, dense sentence that efficiently conveys purpose, input, output dimensions, and usage context. It front-loads the core function and includes all critical details without 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?

The description covers the essential aspects (input, output concept, use case) but does not specify the exact format of the response (e.g., JSON structure). Since there is no output schema, a bit more detail on return format would improve 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% and the parameter 'address' is described in both schema and description as the 0x wallet address. The description adds no additional semantic 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?

Description clearly states the tool computes a reputation score (0-100) for an agent/wallet address. It explicitly sets the context of the agent economy and differentiates from sibling 'wallet_reputation' by focusing on agent interactions.

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 provides clear usage instruction: send an address to decide whether to transact. It notes the tool is paid and includes endpoint details, but does not explicitly state when not to use it or mention 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?

The description discloses it is a paid tool ($0.02) and the HTTP endpoint, which is useful beyond the missing annotations. However, it omits details like data freshness, caching, error behavior for invalid coins, or payment failure consequences.

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 concise sentence with a parenthetical adding cost and endpoint info. No redundant words; front-loaded with the tool's 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 output schema, the description should explain the return format but does not. It does not address error handling or data availability. However, the parameter details are adequate given schema coverage.

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 adds no new parameter info beyond restating 'coin' and 'days?' with no additional context. The default for days (90) is in schema, not description.

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 generates bullish/bearish signals. It specifies input format { coin, days? }, which is specific and distinct from sibling tools like analytics_price or analytics_ohlcv.

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. It does not mention contexts where other analytics tools would be more appropriate, nor does it provide exclusions or prerequisites.

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 requirement and cost ($0.02) and endpoint, which are critical for agent decision-making. However, lacks details on return format, error handling, or idempotency. No annotations provided, so description bears full burden.

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, parameters, and cost. Front-loaded with main action. Efficient but could optionally omit the endpoint line for brevity.

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, parameters, and cost but does not describe return value or error responses. No output schema provided, so additional context on output would be helpful for a 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 covers all 4 parameters with descriptions. Description briefly lists parameters but adds no new semantics beyond what schema already provides. Baseline 3 per 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?

Explicitly states it provides OHLCV candles for DEX pools at multiple resolutions, with specific verb 'OHLCV candles' and resource 'DEX pool'. Clearly distinguishes from sibling tools like analytics_indicators and analytics_price_at.

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 (e.g., analytics_indicators for derived indicators). Does not mention when not to use or any prerequisites.

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 is a paid tool (x402, $0.02) and uses POST endpoint. However, it does not mention rate limits, response format, or potential errors. The cost information adds value but behavioral details are 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 extremely concise: two sentences plus a tag. Every part earns its place—the first sentence defines purpose, the second adds usage context, and the tag provides pricing and endpoint. No fluff.

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

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

Given the tool's complexity (simple query with 2 params, no output schema), the description is adequate but lacks mention of response structure or edge cases (e.g., invalid coin, missing when). It does not describe what the agent will receive back, which is important for a complete picture.

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

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

Schema coverage is 100% with both parameters described sufficiently. The description just repeats 'Send { coin, when }' without adding new semantic depth. Baseline score of 3 applies as the description does not significantly enhance understanding beyond the schema.

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

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

The description clearly states it provides 'point-in-time historical price' for a token, with specific verb ('cost') and resource ('token price'). It distinguishes itself from siblings like 'crypto_price' (current price) and 'analytics_ohlcv' (OHLCV) by focusing on a single price at a past date. Mentioning use cases (backtesting, accounting, audits) adds specificity.

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 tells when to use (historical price queries for backtesting/accounting) and implies a cost ($0.02) which may discourage frivolous use. However, it does not explicitly state when not to use or provide alternatives, such as 'crypto_price' for current prices or 'analytics_ohlcv' for range data. This is a minor gap.

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

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

With no annotations, the description discloses it is a paid tool and the HTTP endpoint. It implies it is read-only but does not explicitly state side-effects, auth requirements beyond token, or rate limits. 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?

The description is extremely concise, consisting of one sentence plus pricing info. Every part is useful and front-loaded. No wasted words.

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

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

With no output schema, the description should explain the return value (e.g., list of keys or value). It fails to do so, and also omits error conditions. Incomplete for a tool with no annotations.

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

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

Schema coverage is 100% with descriptions for all parameters. The description adds no new parameter detail beyond what is in the schema, so baseline score of 3 applies.

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

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

The description clearly states 'read one key or list all keys+entries' from a shared blackboard, using specific verb and resource. It distinguishes from 'board_set' by name but does not explicitly mention sibling 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 provides the required input format but offers no guidance on when to use this tool versus alternatives, nor any exclusions. Usage is implied by the 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 must disclose behavioral traits. It mentions versioning, multi-writer, and pricing ($0.003) but does not explain the implications of versioning, authentication requirements, or potential side effects like overwriting.

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

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

The description is a single sentence plus a pricing note. It is front-loaded with the core purpose and provides essential information without extraneous text.

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 4 required parameters and no output schema, the description lacks information about the return value or response format. The concept of 'versioned key' is not fully explained, which may leave the agent uncertain about expected behavior.

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 describes all parameters adequately. The description only repeats parameter names without adding additional meaning or context.

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

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

The description clearly states the action ('set a versioned key'), the resource ('Shared blackboard'), and the required fields. It effectively distinguishes from the sibling 'board_get' tool by implying a write operation.

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 setting keys on a multi-writer board but does not explicitly state when not to use it or mention alternatives like board_get for reading. No exclusion criteria 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 carries full burden. It discloses the core behavioral trait (skipping weekends and holidays) and pricing, but does not mention error handling or limitations (e.g., what happens if start is invalid or timezone is omitted).

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 concise sentence with essential information (what it does, input shape, pricing), followed by endpoint metadata. 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 calculation tool, the description covers purpose, input structure, and pricing. However, it omits the return value format (likely a date string), which could be inferred but is not explicit. Overall nearly 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%, and the description reiterates the parameter names and types without adding significant meaning beyond the schema's own descriptions (e.g., 'ISO start date, default now' mirrors schema). The 'default now' for start is the only incremental 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 verb 'Add/subtract' and the resource 'business days', with the behavioral detail of skipping weekends and holidays. It is distinct from sibling tools like 'datetime' and 'calc'.

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 business day arithmetic but does not explicitly specify when to use vs alternatives, nor does it mention prerequisites or exclusions. The pricing note adds context but not usage 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?

With no annotations, the description carries the full burden. It discloses arbitrary precision, unit conversion, pricing ($0.003), and the POST endpoint, providing useful behavioral context beyond a simple calculator description.

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

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

The description is a single sentence with examples and a parenthetical note, front-loading the core purpose. Every part earns its place 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?

The tool is simple, but with no output schema, the description should explain the return value. It only hints at the input format, leaving the output format (e.g., numeric result or object) unspecified.

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 both parameters. The description adds example usage but no additional semantic meaning beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool is an exact calculator with unit conversion and arbitrary precision, using specific examples like '3 inch to cm' and 'sqrt(2)^10'. It distinguishes itself from sibling tools, none of which are calculator alternatives.

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 example expressions and parameter hints, but does not explicitly state when to use this tool versus alternatives. It lacks guidance on when not to use it or prerequisites.

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 it's a paid tool ($0.02) and uses POST method, but does not explicitly state read-only nature, rate limits, or other behavioral traits. The description implies it's safe by showing calendar data, but more clarity would be beneficial.

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 with three sentences: purpose, instruction, and meta-info (price/endpoint). It is front-loaded and avoids unnecessary fluff, but the instruction 'Send { protocols?, days? }' could be clearer.

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 provides a reasonable overview of what the tool returns (biggest unlocks, ranked, within N days). However, it lacks details on return format, pagination, or error handling, leaving some gaps for a complete understanding.

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 parameters are well-documented in the schema. The description adds no extra meaning beyond repeating the parameter names in curl-like syntax. Baseline 3 is appropriate as per guidelines.

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 an upcoming token-unlock calendar showing the biggest unlocks within N days ranked by USD value. It distinguishes from sibling tools like catalysts_governance and catalysts_search by focusing on token unlocks and supply shocks.

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 (e.g., catalysts_unlocks). The description only gives input example 'Send { protocols?, days? }' but does not specify use cases 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 the burden. It discloses the tool is paid ($0.02), uses POST, and ranks by voting power. However, it does not mention rate limits, authentication, data freshness, or any side effects. For a read-only tool, this is adequate but could be more 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?

The description is concise with two efficient sentences and a note about pricing/endpoint. It front-loads the core purpose and parameters, with 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?

For a simple tool with three optional parameters and no output schema, the description explains the return fields (title, space, votes, end time) and sorting. It also notes the paid nature and endpoint. It is sufficiently complete for an agent to use correctly, though it lacks details on pagination beyond limit.

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 descriptions (limit max 30, space example, state options). The description only lists the parameters without adding meaning beyond what the schema provides, so it meets the baseline 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 provides on-chain governance activity via Snapshot, including active/recent proposals ranked by voting power with specific fields (title, space, votes, end time). It distinguishes itself from sibling tools like catalysts_calendar, catalysts_search, and catalysts_unlocks by focusing on governance proposals.

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

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

The description explains the parameters to send (space?, state?, limit?) and implies usage for governance catalysts that move token prices. However, it does not explicitly state when to use this tool versus alternatives or provide exclusions, though the sibling context makes the purpose 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 carries full burden. It mentions paid cost ($0.02) and HTTP method (POST), but does not disclose read-only nature, rate limits, auth requirements, or any side effects. Limited behavioral disclosure.

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

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

Very concise: two sentences plus a bracketed note. Front-loaded with the essential 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?

Given no output schema, the description explains what to do with returned data (use slug with unlocks) and notes the paid nature. Missing details on response format or pagination, but adequate for a simple search tool.

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

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

Schema coverage is 100%, so baseline is 3. The description reinforces the query parameter ('Send { query }') but adds no new meaning beyond the schema descriptions. Does not compensate further.

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 'Find', the resource 'protocols that have tracked token-unlock schedules', and the method 'by name substring'. Distinguishes from siblings like catalysts_unlocks by specifying that the returned slug is for use with that tool.

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

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

Provides clear context: send a query substring, then use the slug with catalysts/unlocks. Does not explicitly mention when not to use, but the instructions imply a specific workflow.

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, but the description discloses that it's a paid tool ($0.02, POST endpoint) and describes the returned data (unlock details, events). It doesn't cover rate limits or authentication, but for a read-only data tool, this is adequate.

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 deliver the purpose, usage, and a practical tip. The paid note and endpoint are appended concisely. 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 tool with 2 parameters and no output schema, the description covers input, data fields returned, and a usage tip. It lacks output format details, but the listed fields compensate somewhat.

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

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

Schema description coverage is 100% for both parameters (protocol and limit). The description repeats protocol usage with examples but adds no new meaning 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 clearly states it provides 'token unlock / vesting schedule for a protocol' with specific data fields (next unlock date, amount, USD value, category, type, upcoming events). It distinguishes from sibling tools like catalysts_calendar, catalysts_governance, and catalysts_search by focusing on unlocks/vesting.

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 input as protocol slug (e.g., 'aptos'), and advises that 'Large unlocks are the most reliable supply-shock catalysts — front-run sell pressure,' which guides when to use. It lacks explicit when-not-to-use or comparisons to alternatives, but the 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 exist, so description carries full burden. It discloses paid nature, price, and API endpoint, but omits chain support, error cases, or rate limits. Adequate for a one-parameter 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?

Single clear sentence plus concise price/endpoint note. 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 simple tool with one parameter, description covers purpose, input, cost, endpoint, and output categories. Lacks response format and chain specificity, but sufficient for basic usage.

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

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

Schema coverage is 100% with parameter description '0x EVM address'. Tool description repeats that the input is an address without adding new semantic details, earning 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?

Description clearly identifies the tool's function: labeling an EVM address as EOA, contract, protocol, or scam with name and tags. It effectively distinguishes from sibling compliance tools (e.g., compliance_risk, compliance_screen) which focus on risk or screening.

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 states the input (address) and purpose (labeling), implying when to use. However, it does not explicitly contrast with alternatives 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 the description carries full burden. It discloses the tool is paid ($0.05), uses a POST endpoint, and returns a risk score (0-100) with level and flags. However, it does not mention data freshness, rate limits, or whether the call is read-only or has 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?

The description is concise (two sentences plus pricing/endpoint note) and front-loaded with the main purpose. Every sentence adds value: risk score components, input placeholder, and cost/method.

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 param, no output schema), the description adequately covers purpose, inputs, and cost. It mentions the output includes risk level and flags, though the structure of flags is not detailed. Operations like 'OFAC status' and 'contract verification' give sufficient context for the 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?

The only parameter 'address' has a schema description '0x EVM address'. The description adds 'Send { address }' which minimally reinforces the parameter usage. With 100% schema coverage, baseline is 3, and the description provides no extra format or example.

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

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

The description clearly states it addresses risk score with components like OFAC status, sanctioned addresses, contract verification, and activity, and provides a risk level and flags. The verb 'address' and resource 'risk score' are specific, but it lacks differentiation from sibling tools like compliance_screen 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 provides a brief context ('Chainalysis-lite risk in one call') and pricing info, but does not explicitly state when to use this tool versus alternatives (e.g., compliance_screen for broader screening, compliance_label for labeling). No exclusions or prerequisites 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?

No annotations are provided, so the description carries full burden. It discloses that it is a paid tool ($0.05, POST /api/compliance/screen), adding cost and HTTP method transparency. It doesn't mention latency, rate limits, or return behavior, but for a simple screening check, it is adequate.

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 concise sentences. The first sentence front-loads the purpose, the second provides usage guidance, and the third adds cost and method details. No redundant words.

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

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

Given no output schema, the description omits what the tool returns (e.g., boolean or risk score). However, for a simple screening check with one parameter, the purpose and usage are clear. The agent can infer a yes/no confirmation.

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 only one parameter 'address'. The description adds context by stating 'Send { address }' and specifying 'US OFAC sanctioned-address list', which goes beyond the schema's description of '0x EVM address to screen'.

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 'OFAC sanctions screening: is this address on the US OFAC sanctioned-address list?' which specifies the verb (screen) and resource (address against OFAC list). It clearly distinguishes from sibling tools like compliance_label, compliance_risk, and 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 says 'Every agent moving money legally needs this pre-transaction check,' providing clear context for when to use it (before money movement). However, it does not explicitly mention when not to use it or list alternatives, though siblings 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?

No annotations are provided, so the description carries the full burden. It discloses that the tool is paid ($0.05) and uses a POST endpoint, but does not mention whether it is read-only, error behavior, or rate limits. The core behavior (multi-hop trace) is clear, but other 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 (3 sentences) and front-loaded with the main function. It includes necessary details (price, endpoint) without extraneous information. Every sentence is useful.

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

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

Given no output schema, the description should explain the return value. It implies a boolean or report result ('does... trace back...') but does not specify the format or structure. Error handling and edge cases are not addressed. For a simple tool with 2 parameters, it is mostly complete but lacks return 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% with descriptions for both parameters. The description reiterates the 'hops' parameter and its range (1-3, default 2), adding marginal value over the schema. It does not introduce new information 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 the tool's purpose: tracing tainted funds from a wallet address to sanctioned addresses within N hops on Base. It uses specific verbs ('trace', 'screen') and specifies the resource (incoming payments, sanctioned addresses). The purpose is distinct from sibling compliance tools (label, risk, screen).

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 ('Screen incoming payments before accepting them') and mentions it's a paid tool. While it doesn't explicitly state when not to use it or list alternatives, the context of sibling tools implies differentiation. The guidance is adequate for an agent.

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?

Without annotations, the description must provide behavioral details. It mentions 'atomic' and 'collision-free,' indicating thread-safety, and notes it is a paid tool with a price. However, it does not disclose potential side effects, rate limits, or error conditions (e.g., invalid token).

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 only two sentences, front-loading the core purpose and then providing essential details (price, endpoint). Every piece of information is relevant and efficiently stated.

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 low complexity (3 parameters, no output schema), the description is fairly complete. It explains the return behavior ('increment-and-return') and covers the key aspects. Minor gaps exist (e.g., no mention of what happens on duplicate counter names), but overall 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?

The input schema has 100% coverage for parameters, but the description adds valuable context: it summarizes the required parameter structure ('{ name, token, by? }') and clarifies that the token 'claims' the counter, providing semantic 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 defines the tool as an atomic counter for increment-and-return operations on named counters, specifying collision-free behavior for running totals and IDs across agent runs. It distinguishes itself from other tools in the sibling list, which focus on analytics, crypto, compliance, 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?

The description implies usage for generating IDs or running totals but does not explicitly state when to use this tool versus alternatives. No direct comparisons or exclusions are provided, leaving the agent to infer appropriate contexts.

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 fully discloses the tool's behavior: it explains cron expressions and has a cost ($0.003 via POST). It does not mention error handling or limitations, but for a simple calculation tool, this is acceptable.

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

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

The description is a single sentence followed by a bracketed pricing note. It is extremely concise and front-loaded with the most critical 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 no output schema and fully described parameters in the schema, the description adds necessary context: the input format and pricing. It does not describe return values, but the output (list of times) is obvious from the 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 coverage is 100%, so the baseline is 3. The description only repeats parameter names without adding extra 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's verb ('Explain'), resource ('cron expression'), and its specific output ('next N run times in a timezone'). This sufficiently distinguishes it from siblings like 'cron_schedule'.

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

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

The description provides explicit input format ('Send { expression, count?, timezone? }'), which guides the agent on how to invoke the tool. It lacks explicit 'when not to use' or alternatives, but the purpose is niche enough that this is not critical.

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. It discloses the tool is an x402 paid tool with price $0.003 and specifies the HTTP method (POST) and endpoint. It does not cover error behavior or authentication, but for a simple query tool this is adequate.

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

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

Three sentences with no wasted words. Front-loaded with the tool's purpose, followed by the payment info and endpoint. 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 the simplicity of a single parameter and no output schema, the description adequately covers what the tool returns (recent transactions, top methods, counterparties, latest actions). It does not specify output structure, but that is acceptable without an 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 covers the address parameter at 100% with a description. The description adds context by showing the placeholder '{address}', reinforcing the parameter's purpose, and specifying it is for a '0x EVM wallet address on Base', which goes beyond the schema's minimal description.

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 'wallet activity summary' including 'recent transactions, top methods called, distinct counterparties, and latest actions' for an address on Base. It distinguishes from sibling tools like crypto_tx and crypto_balances by focusing on aggregated profiling.

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 'Agents profile what a wallet does' but does not explicitly state when to use this tool versus alternatives like crypto_tx or crypto_balances. No exclusions 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 must cover behavioral traits. It discloses the tool is paid ($0.003) and the endpoint, and states it reads balances. However, it does not mention failure behavior (e.g., invalid address), rate limits, or whether balances are cached. The disclosure is basic but not comprehensive.

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 with no wasted words: it states the output, gives an instruction, and mentions pricing/endpoint. It is front-loaded with the core 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?

Given that the tool has only one parameter, no output schema, and no nested objects, the description adequately explains what it does and what input is needed. It lacks details on return format, but for a simple read operation, it is satisfactory.

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

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

The schema has 100% coverage on the single parameter 'address' with a description. The tool description adds context by specifying the chain (Base) and stating the parameter is a wallet address, reinforcing the schema. It does not provide additional syntax details but adds meaningful context.

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

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

The description clearly states the tool retrieves native ETH and all ERC-20 token balances for an address on Base, using the verb 'read' and specifying the resource (wallet holdings). It distinguishes itself from siblings like crypto_activity and crypto_tx by focusing on balance retrieval.

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 { address }' and 'Let agents read any wallet's holdings,' but provides no explicit guidance on when not to use it or alternatives among the many sibling crypto tools. Usage is implied but lacks 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 must carry the burden. It discloses that the tool is paid (price $0.003) and gives the endpoint. It also implies a read-only safe operation (decoding). However, it does not specify authentication needs 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?

The description is relatively short and front-loaded with the main purpose. The inclusion of price and endpoint info is relevant. However, the 'Send { input }' fragment is somewhat out of 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 one parameter and no output schema, the description adequately covers the input and purpose. Adding output format would improve completeness, but the tool's behavior is straightforward.

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 100% schema coverage, the description adds meaning by explaining the two input formats and the purpose of each (get ABI vs decode selector). This goes beyond the basic schema description.

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 when given a 0x address or selector. It uses specific verbs ('pass', 'get', 'decode') and distinguishes itself from other crypto siblings by focusing on contract decoding.

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 the tool (before calling contract functions) and the input format, but does not provide exclusions or compare with alternative tools among siblings. It implies use context 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 must carry full burden. Mentions 'live rates' and notes it is a paid tool ($0.003), but does not disclose behavior like rounding, asset support, or error handling. Adequate but minimal extra info.

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 plus a concise bracketed note. Every sentence adds value: purpose, example, context, and cost/endpoint. 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?

Description covers core functionality and example, but lacks explicit mention of return format or output structure. Since no output schema exists, this omission reduces 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 already describes all three parameters with clear descriptions (source ticker, target ticker, amount). Description adds an example but does not provide additional meaning beyond schema. Baseline 3 due to 100% 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?

Description states specific verb+resource: 'Convert an amount between any two crypto/fiat assets at live rates.' Clearly distinguishes from sibling tools like crypto_price, which gives price quotes, while this converts an amount.

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 example input and context 'Instant FX for agents pricing on-chain actions,' but does not explicitly state when not to use this tool versus alternatives like crypto_price or other conversion 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 full weight. It discloses that the tool is paid ($0.003 per use) and uses POST /api/crypto/ens, which is important for cost-conscious agents. It does not mention side effects, but as a resolution tool, it is likely read-only.

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 succinct cost and endpoint note. Every part is relevant and non-redundant, with no wasted words.

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

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

Given the tool's simplicity (one parameter, no output schema), the description adequately covers purpose and input. It does not describe output format, but that is not required, and the tool's behavior is straightforward.

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

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

The schema covers the single parameter completely, and the description adds examples (e.g., vitalik.eth) and clarifies it accepts both ENS names and addresses, providing additional context 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 names or Basenames to addresses and reverse-resolves addresses to names and avatars. It is distinct from sibling tools, none of which handle ENS resolution.

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 input as an ENS/Basename or 0x address, making usage clear. However, it does not explicitly state when to use this tool over alternatives, though no direct alternatives exist 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?

Without annotations, the description carries full burden. It discloses the tool is paid ($0.003), requires no input, and provides the endpoint (POST /api/crypto/gas). It adequately sets expectations for a simple zero-parameter 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 a single concise sentence plus a brief pricing/endpoint note. Every word serves a purpose, with no redundancy. Ideally structured for quick parsing.

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

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

Given zero parameters, no output schema, and no annotations, the description provides sufficient context: purpose, input requirements, cost, and endpoint. It could optionally detail the output format, but mentions 'estimated cost (ETH & USD)' 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?

With zero parameters and 100% schema coverage, the description adds value by explaining what the tool returns (gas price, estimated cost in ETH & USD) beyond the empty schema. Baseline 4 applies due to no parameters needing clarification.

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

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

The description clearly identifies the tool as a 'Live Base gas oracle' providing current gas price and estimated cost for transfer, swap, or mint. This specific verb-resource combination immediately distinguishes it from sibling tools like crypto_price or crypto_convert.

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

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

The description explicitly states that no input is needed and that agents should use it to budget transactions before acting. While it doesn't explicitly mention when not to use or list alternatives, the guidance is clear and actionable for the intended 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 provided; description discloses paid nature ($0.003) and HTTP method (POST). Lacks details on rate limits, caching, or error handling.

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 compact sentences: first states purpose and input, second adds context (real-time, paid, endpoint). No unnecessary content.

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 output schema and description does not specify return format or structure. Adequate for a simple tool but incomplete without output 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% with parameter description. Description adds explicit example 'symbols: ["ETH","USDC","BTC"]' and clarifies accepted formats (tickers/coingecko ids).

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 'Live crypto & token prices in USD' with specific verb (get/prices) and resource (crypto/tokens). Distinguishes from sibling tools like crypto_balances by focusing on price fetching.

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 context 'Real-time on-chain pricing for finance and trading agents' but does not explicitly state when not to use or compare to alternatives like analytics_price_at.

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 tool is paid and lists outputs, but lacks details on authentication, rate limits, side effects, or whether it is read-only. Safety signals are mentioned but not elaborated.

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 are highly concise, covering purpose and cost upfront 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 one-parameter tool lacking output schema, the description lists expected outputs and mentions safety signals and cost. Could include return format or error handling, but is mostly 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% for the single parameter 'address' with description. The description adds minimal context ('Send { address }') 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 provides token intelligence (name, symbol, supply, holder count, source-verification, safety signals) and is used for vetting tokens. However, it does not explicitly differentiate from sibling tools like crypto_contract or crypto_price.

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

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

Implies usage for token due diligence ('Agents vet a token before touching it.'), but provides no explicit guidance on when to use this tool versus alternatives 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?

With no annotations, the description compensates by disclosing that the tool is paid with a specific price and endpoint, and implies it is a read-only query for transaction data. It does not mention destructive actions.

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 pricing note), front-loads key deliverables, and every sentence adds value.

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

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

For a simple one-parameter tool with no output schema, the description covers the returned fields, usage context, and cost. It is sufficient for an agent to understand and 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%, so baseline is 3. The description adds 'Send { hash }' which reiterates the parameter usage but does not provide additional validation or format details 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 transaction status and receipt on the Base chain, listing specific fields like confirmations, success/fail, from/to, value, fee, method. This distinguishes it from sibling tools like crypto_price or crypto_balances.

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

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

The description implies usage after performing on-chain actions ('Agents confirm their on-chain actions settled'), but does not provide explicit when-to-use or comparisons to alternatives like crypto_activity or wallet_reputation.

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 description carries full burden. It discloses the source (DeFiLlama), paid nature ($0.003), and POST endpoint. However, it does not mention rate limits, data freshness, or any limitations beyond basic filtering.

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 two sentences plus a brief metadata line. It front-loads the purpose and key features. The paid tool and endpoint info is useful but slightly clutters the core description. Overall 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?

For a simple query tool with no output schema, the description adequately explains input parameters and source. However, it lacks information about return format, example usage, or pagination, which would improve completeness. Acceptable but not 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 description coverage is 100% with clear descriptions for each parameter. The description only restates parameter names in a shorthand format, adding no extra semantic context beyond what the schema already provides. Baseline 3 is appropriate.

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

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

Description clearly states it retrieves top DeFi yield opportunities from DeFiLlama with filtering by chain, project, minTVL, and ranking by APY. It specifies the resource and verb, distinguishing it from sibling yield tools like rh_yields.

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 lists parameters and their optionality but provides no guidance on when to use this tool versus alternatives like rh_yields or lending_rates. No explicit when-not-to-use or context for selection.

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

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

No annotations are provided, so the description must disclose behavior. It reveals that it is a paid tool ($0.003) and the HTTP method/endpoint, but does not describe error handling, output format, or rate limits. 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 cover purpose, operations, payload format, and pricing. Every sentence earns its place 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's complexity (6 parameters, no output schema, no annotations), the description is adequate but lacks details on return values, error scenarios, and how parameters combine per 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 each parameter is described in the schema. The description only lists parameter names with optional markers, adding no extra meaning. 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?

The description clearly states it performs date/time math and timezone conversions, lists the four operations (now, convert, add, diff), and provides the input format. This is specific and distinguishes it from other tools like cron_explain or schedule.

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. Among siblings, there are tools like diff (possibly for date diff) and schedule, but the description does not differentiate or provide selection 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?

Discloses pricing ($0.003), HTTP method, and the purpose (heartbeat prevents firing). No annotations present, so description effectively communicates the tool's behavior.

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 with essential info; front-loaded with purpose and includes key details (price, endpoint) in concise format.

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, required parameters, and pricing. Lacks response format or behavior on failure, but adequate for a simple heartbeat 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%, but description only restates parameter names without adding new meaning. Does not explain token source or validation.

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's a heartbeat to keep a deadman's switch from firing, which is specific and distinguishes from sibling 'deadman_register' that likely creates the switch.

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 vs alternatives; only implies periodic sending. The price and endpoint are mentioned but not contextual usage 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?

Discloses paid nature, cost, HTTP method, and trigger condition (no ping within intervalSec). Lacks details on success response or errors, but sufficient for core behavior.

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: one sentence for purpose, one for required data, one for pricing. 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?

Covers purpose, inputs, cost, and trigger event. Missing output/return expectations, but simple registration tool likely returns a status.

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 describes all 4 parameters fully; description only lists them without adding new meaning, so baseline 3 applies.

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

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

Clearly describes registering a deadman's switch that triggers a webhook on missed ping, distinguishing it from the sibling deadman_ping tool.

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

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

States purpose (detect crashed agents) and implies need for periodic pings, but does not explicitly list when not to use 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 should disclose behavioral traits. It mentions pricing and endpoint, and implies a structured output ('added/removed/changed by path'). However, it does not discuss authentication, rate limits, or edge cases (e.g., handling of non-JSON inputs or circular references). 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?

The description is extremely concise: a single sentence containing the core functionality, usage hint, and pricing information. Every part contributes value, and there is no redundant text.

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 low complexity (two parameters, straightforward diff operation), the description is fully complete. It explains what the tool does, what input to provide, and hints at the output structure. No missing information is needed for correct usage.

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 minimal descriptions ('First JSON value', 'Second JSON value'). The description adds semantic value by clarifying that the tool expects an object '{ a, b }' and that these are JSON values to be diffed. This additional context helps the agent understand the parameter roles 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 uses a specific verb ('diff') and resource ('JSON values'), clearly stating what the tool does: 'Structured deep diff of two JSON values (added/removed/changed by path).' It also specifies the input format as '{ a, b }', distinguishing it from sibling tools.

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

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

The description provides basic usage guidance ('Send { a, b }') but lacks explicit when-to-use or when-not-to-use instructions, nor does it mention alternatives. Given that no sibling tool performs a similar function, the lack of alternatives is acceptable, but the guidance is minimal.

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 bears full responsibility for behavioral transparency. It mentions returning an id and being a registry, but lacks details on idempotency, authentication requirements, rate limits, or what happens if conditions are unmet. For a financial tool, this is a significant gap.

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

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

The description is three sentences, front-loaded with the core purpose and key fields. It includes pricing and endpoint info efficiently. Only minor wordiness (e.g., 'Coordination + resolution layer for A2A commerce') could be tighter, but overall 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 no output schema, the description adequately explains the return value (an id). It covers purpose, parameters, and pricing. However, missing behavioral details (e.g., error conditions, side effects) make it less complete for a financial transaction 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%, so baseline is 3. The description adds little beyond schema: it repeats token as 'Secret (>=8 chars) authorizing later resolution' which is in the schema, and does not clarify the ISO deadline format or enumeration constraints. The description provides marginal 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?

The description clearly states the verb (create), resource (agent-to-agent conditional-payment agreement), and key fields (payer, payee, amount, condition, deadline). It distinguishes from sibling tools like escrow_list, escrow_resolve, and escrow_status by specifying creation and returning an id.

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 context for when to use this tool (creating escrow for A2A commerce) and mentions it is a registry not fund custody. However, it does not explicitly state when not to use it or name alternatives from the sibling list, leaving some interpretation to the agent.

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.02) and provides the HTTP method and endpoint (POST /api/escrow/list). This adds transparency beyond typical descriptions. For a list operation, no destructive behavior is implied. No contradiction with annotations.

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

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

Two sentences efficiently convey purpose, usage guidance, and pricing/endpoint. Information is front-loaded with no redundant text. 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?

No output schema is provided, but the tool's purpose is simple (list agreements). The description includes pricing and endpoint details. It could mention the returned fields, but for a list operation of this nature, the description is sufficiently complete for an agent to understand when to invoke it.

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

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

Schema coverage is 100% with descriptions for all three parameters. The description adds value by clarifying that 'token' and 'party' are alternative inputs ('Send { token } or { party }') which implies mutual exclusivity, a constraint not explicit in the schema. This enhances understanding of parameter usage.

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 ('list') and the resource ('conditional-payment agreements'). It specifies two modes (own token or party address) which distinguishes it from sibling tools like escrow_create, escrow_resolve, escrow_status that perform other operations.

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

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

The description explicitly says 'Send { token } or { party }' providing guidance on when to use each parameter. It implies mutual exclusivity and includes pricing. However, it does not explicitly state when not to use the tool or mention alternatives beyond the sibling list.

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

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

With no annotations provided, the description carries full burden. It discloses that the tool is paid ($0.05) and provides the HTTP endpoint. However, it does not mention whether the resolution is reversible, what happens on failure, or any prerequisites like ownership verification beyond the secret token.

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 concise sentences. The first sentence states the core purpose and outcomes, the second lists parameters, and the third adds metadata (price, endpoint). No filler or redundancy. Front-loaded effectively.

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, but the description mentions the return type ('settlement instruction to execute over x402'). It covers cost, endpoint, and required fields. However, it omits error scenarios, success/failure signals, and whether the tool can be called multiple times on the same escrow.

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 baseline is 3. The description adds no new parameter meanings beyond listing them in the send format, but it does clarify that 'outcome' can be 'release' or 'refund', which is already in the schema. Minimal 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?

The description clearly states the action ('resolve'), the resource ('conditional-payment agreement'), and the two possible outcomes ('release' or 'refund'). It distinguishes from sibling tools like 'escrow_create' and 'escrow_list' by specifying the resolution 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 implies usage by explaining the outcome options and noting it returns a settlement instruction, but it does not explicitly state when to use this tool versus alternatives like 'escrow_create' or 'escrow_status'. No when-not or alternative 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 burden. It discloses that the tool is a paid x402 tool costing $0.02 and uses POST /api/escrow/status. The action is inherently a read (checking status), so no destructive behavior is implied. It does not explicitly state it is read-only, but the description is transparent enough for an agent.

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, concise sentence that includes the core purpose, possible states, and usage hint, followed by a brief note on pricing and endpoint. Every part is informative and there is no wasted text.

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 lists the possible return states (pending/released/refunded/expired), which gives the agent an idea of what to expect. It also includes pricing and HTTP method. However, it does not describe the exact response structure, but for a simple status check, this is adequate.

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

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

Schema coverage is 100% and the description for the 'id' parameter is already clear in the schema ('Escrow id from escrow/create'). The description only adds 'Send { id }', which is redundant. No additional meaning is provided beyond what the schema already offers, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool checks the state of a conditional-payment agreement and lists the possible states (pending/released/refunded/expired). The verb 'Check' and resource 'state of escrow' distinguish it from sibling tools like escrow_create, escrow_list, and escrow_resolve.

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 usage by saying 'Send { id }', implying the user must provide an escrow ID. While it does not explicitly state when to use it vs alternatives, the context from sibling tools suggests it is used after creating an escrow to query its status. No exclusions or alternatives are mentioned, but the guidance is clear enough.

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

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

No annotations provided. Description discloses paid nature and endpoint but lacks details on read-only nature, caching, rate limits, or failure modes. Provides basic behavioral context but not comprehensive.

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 covering purpose, usage hint, and payment info. No wasted words, information is front-loaded and efficiently 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?

Adequate for a simple query tool with one optional param and no output schema. Missing output format details but overall covers key aspects of usage 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?

Schema coverage 100% with one parameter 'chains'. Description adds list of supported chains, which is helpful but not essential; baseline of 3 is appropriate as schema already defines 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?

Description clearly states tool provides live gas prices across multiple chains and estimated USD cost of a swap, with ability to time and route transactions. Distinguishes from sibling tools like crypto_gas by covering multiple chains and execution optimization.

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 suggests usage for timing and routing swaps for cheapest execution, but does not explicitly contrast with alternatives like exec_quote 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?

In the absence of annotations, the description fully carries the burden. It discloses that the tool only returns a quote without executing, specifies output fields (expected output, USD, price impact, gas cost, DEXes), and notes the pricing. Does not cover error handling or rate limits, which is acceptable for a simple quote 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?

Two tightly written sentences plus a note on pricing. No fluff; every sentence adds essential information. Highly efficient.

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

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

Given moderate complexity, no output schema, and full param schema, the description adequately covers input format, output summary, and non-execution guarantee. Does not detail return structure but lists fields, which suffices 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 descriptions, so baseline is 3. The description adds value by clarifying that 'amountIn' is in smallest units (wei) and that 'chain' defaults to 'base'. This extra context aids correct invocation.

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

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

The description clearly states the tool provides 'Best-route swap quote across DEXes' and lists specific output fields. It distinguishes itself from sibling tools like exec_gas and exec_sandwich by focusing on quoting vs. execution or analysis.

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

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

Explicitly states 'Quote only — never executes' and 'Pre-trade routing for trading agents,' providing clear context for when to use. Mentions it's a paid tool ($0.05) but does not explicitly contrast with 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 burden. It discloses that the tool is paid ($0.05), which is key behavioral transparency. It also mentions risk score and mitigations, though it doesn't detail return 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 sentences, front-loaded with purpose and mitigations, followed by input specification and cost info. No wasted words.

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

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

Given the tool's complexity (risk score with mitigations, paid), the description covers inputs, purpose, and cost. Missing details on risk score scale or return format, but acceptable without 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. The description restates the required parameters but adds no new semantic detail 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 it provides a Sandwich/MEV risk score with mitigations, using a specific verb ('risk score') and resource (planned swap). It distinguishes from sibling tools like exec_quote and exec_slippage by focusing on sandwich risk.

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

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

Usage is implied via the input specification ('Send { chain, tokenIn, tokenOut, amountIn }'), and the tool's purpose is clear. No explicit exclusions or alternatives are mentioned, but the context suggests when 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 discloses that the tool is paid ($0.02) and uses a POST endpoint, but does not state whether it is read-only or destructive. The behavioral traits beyond pricing are not fully 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?

Three sentences covering purpose, input, and cost/endpoint. Each sentence adds value, but the cost and endpoint info could be integrated more tightly. Still, it is efficient with 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?

The tool is simple, but the description does not specify the output structure (e.g., format of the rating or slippage value). Given no output schema, this is a gap. However, the core use case is conveyed 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 coverage is 100%, so the baseline is 3. The description merely lists the parameters in a sentence without adding any additional meaning beyond the 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?

The description clearly states the tool provides a recommended max slippage based on live price impact and a buffer, with a rating. It distinguishes from execution siblings like exec_quote by focusing on slippage recommendation, but does not 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?

The description specifies the required input format ({ chain, tokenIn, tokenOut, amountIn }) and states the tool helps avoid failed transactions and overpaying. However, it does not provide when-not-to-use guidance or compare with alternative tools like exec_quote.

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 disclose behavioral traits. It states it is a paid tool ($0.003) and the HTTP method (POST /api/extract), but does not mention error handling, idempotency, or side effects. This is 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?

The description is a single sentence plus a concise pricing note. No redundant information; every word adds value. Fits well in the available space.

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

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

With no output schema, the description partially explains return format ('as JSON' with listed fields) but lacks details on structure, optional fields, or error states. Adequate for a simple tool but could be more informative.

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 description 'Raw HTML', and schema coverage is 100%. The description adds examples of extracted fields but no additional parameter semantics beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool extracts structured data from HTML as JSON, listing specific fields (title, links, meta, headings, text). This is a specific verb+resource combination that distinguishes it from sibling tools.

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

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

The description mentions it's a paid tool with a price and endpoint, but does not provide explicit guidance on when to use it versus alternatives. The use case is implied but no exclusions or alternative tool references 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?

Without annotations, the description carries the full burden. It discloses the core behavior: returns firstTime:true only once per key within TTL, the HTTP method (POST), endpoint, and pricing. It does not cover error handling or authentication, but the main behavioral traits are communicated.

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 brief note on pricing and endpoint. Every sentence adds value, and the key behavior is front-loaded. No fluff.

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

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

Given no output schema, the description partially explains the return value (firstTime:true) but does not specify the full response structure or error cases. With three parameters, the description is adequate but lacks details on authentication and return 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?

Schema coverage is 100% (all parameters have descriptions in the schema). The description adds minimal value beyond the schema: it lists the parameters in a short form ('Send { key, token, ttlSec? }') but does not explain them further. Baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: an idempotency key that returns firstTime:true only once per key within TTL, deduplicating retries/double-sends. This is a specific verb+resource and distinguishes it from siblings like 'ratelimit' or 'counter'.

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 the tool: for deduplication of retries or double-sends. It also notes it's a paid tool with price $0.003. However, it does not explicitly state when not to use it or mention 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?

Discloses disposability, POST capture, token requirement, and cost. However, lacks details on expiration, data retention, or rate limits. Without annotations, description carries burden but is not fully 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?

Two sentences, front-loaded with purpose and price. Brief but could be more concise by removing bracket delimiters. Score 4.

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?

Does not specify return value (e.g., the URL or ID). For a tool that creates a resource, the response format is important but omitted. Output schema absent, so description should compensate.

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 token fully (100%). Description repeats the token usage but adds no new semantic information 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 the tool creates a disposable webhook inbox that captures POSTs for polling. Uses specific verb 'get' and resource 'disposable URL'. Distinguishes from sibling 'inbox_poll' which polls the created inbox.

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 by mentioning token and cost, and includes content identifier. Sibling 'inbox_poll' indicates use after creation, but no explicit when/when-not or alternative 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 adds transparency by noting 'x402 paid tool — price $0.003; POST /api/inbox/poll' (cost and HTTP method) and implying a read-only operation. However, it does not disclose potential error conditions, rate limits, or non-destructive behavior explicitly.

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

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

The description is a single sentence plus a code block and payment info, all front-loaded. No unnecessary words; every part adds value. It is efficiently 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?

The tool has 3 parameters and no output schema. The description explains input structure and purpose but does not describe the response format, pagination (if any), or error handling. Given the tool's complexity (simple fetch), it is minimally complete but lacks output 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% – all parameters have descriptions. The description echoes the schema with 'Send { id, token, since? }' and rephrases the 'since' parameter as 'Epoch ms; return newer messages', adding no new meaning 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 clearly states 'fetch captured messages newer than a timestamp', specifying the verb ('fetch') and resource ('captured messages' from 'webhook inbox'). The name 'inbox_poll' distinguishes it from siblings like 'inbox_create' and 'pubsub_poll'.

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 polling an inbox for recent messages, but does not explicitly guide when to use this tool versus alternatives (e.g., 'pubsub_poll' for pubsub messages) or mention 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 exist, so the description carries the full burden. It discloses that validation is 'strict', returns valid + detailed errors, and mentions it is a paid tool with price and endpoint. While not exhaustive, it gives key behavioral traits about cost and output 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?

The description is very concise, with only two short sentences. It front-loads the core purpose and includes additional details (cost, endpoint) in a bracketed note. It could be slightly more structured, but it communicates 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 simple validation tool with no output schema and no annotations, the description covers purpose, input format, output summary, cost, and endpoint. This provides sufficient context for an agent to decide and use 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?

Both parameters have descriptions in the input schema (100% coverage). The description only reiterates the input format, adding no further semantic detail beyond what the schema already provides. 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 validates data against a JSON Schema, specifying the verb 'validate' and resource. It explicitly tells to send { schema, data }, making the purpose unambiguous. However, it does not distinguish from sibling tools, and the schema types (array for both) may cause confusion, but that's outside the description.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or typical use cases. The sibling list includes many other tools, but no comparative context is 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?

The description mentions it is a paid tool (x402, price $0.05) and gives the endpoint, but with no annotations, it should disclose more behavioral traits like read-only nature or side effects. The cost is transparent, but other 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 very concise: two sentences plus a tag. It front-loads the purpose and includes critical info (cost, endpoint). Every sentence adds value with zero 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?

For a simple tool with 2 parameters and no output schema, the description is fairly complete. It explains inputs, outputs, and cost. The only gap is the lack of return format details, but the output is implied by the tool name.

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

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

Schema coverage is 100% and both parameters have descriptions. The description adds minimal extra meaning ('address, chain?') beyond the schema, so 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 is for Aave v3 position health, listing specific outputs (health factor, collateral, debt, liquidation buffer, risk verdict) for a wallet. It distinguishes from sibling tools like lending_liquidations and lending_rates by focusing on a single wallet's health.

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 hints ('Send { address, chain? }' and 'Know your liquidation risk before it hits'), but no explicit guidance on when to use this versus alternatives 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 disclose behavior. It indicates the tool is a live scanner (no destructive effects), mentions it is a paid tool with price and endpoint, adding useful behavioral context.

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

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

The description packs much information but is a single paragraph. It could be more front-loaded and structured, but it remains readable and 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?

No output schema exists, but description only vaguely mentions output fields ('borrower, market, debt and collateral in USD'). The structure of the response is not described, which may leave ambiguity 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 descriptions for all three parameters. The description repeats the parameters parenthetically without adding new semantic detail, so baseline score 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?

Description clearly identifies the tool as a liquidation-opportunity scanner for Morpho Blue, specifying the condition (health factor < 1) and output fields (borrower, market, debt, collateral in USD). It is distinct from sibling tools like lending_health 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?

Explicitly states it is for 'searcher/liquidator agents' and suggests parameters to send. While it doesn't list when not to use or alternatives, the 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?

With no annotations, the description carries full burden. It discloses that the tool is paid ($0.02) and uses POST, but does not state whether it is read-only or destructive, nor covers auth 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?

Three concise sentences with front-loaded purpose and no wasted words. Includes endpoint and pricing 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 tool with no output schema, the description hints at return structure ('ranked by yield with TVL') but does not fully specify the format. It is adequate but could be more explicit about the response shape.

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 all three parameters (asset, chain, limit) are described in the schema. The description adds minimal extra meaning beyond schema, only mentioning asset and optional chain.

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 it provides the best supply/lending APYs for a given asset across multiple protocols (Aave, Compound, etc.), ranked by yield with TVL. This clearly distinguishes it from sibling tools like lending_health and lending_liquidations.

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 instructs to 'Send { asset, chain? }' and suggests using it to 'rate-shop where to lend,' which guides usage. However, it does not mention when not to use this tool or explicitly compare to 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 provided, so description must bear burden. Discloses it's a paid tool with cost and endpoint, but does not mention rate limits, idempotency, or error behavior beyond 200 check.

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

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

Two sentences with no filler. Includes purpose, constraints, cost, and endpoint. Every sentence provides value.

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

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

For a one-param tool with no output schema, description covers purpose, input format, limit, and cost. Could mention output format, but overall 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% for the single 'urls' parameter. Description adds constraint of 1-50 URLs and shows example format, going beyond schema to clarify usage limits.

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 batch link-liveness checking of up to 50 URLs for 200 status. Distinct from all sibling tools which cover analytics, crypto, scheduling, 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?

Explicitly defines scope (check up to 50 URLs for 200) and gives example input format. No explicit when-not-to-use, but sibling tools offer no overlapping functionality.

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 partially reveals behavior: non-blocking acquisition, TTL-based expiry, and cost. However, it does not disclose error handling, token validation, or whether the same token can re-acquire (idempotency), 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?

The description is extremely concise: two sentences plus a cost/endpoint note. It front-loads the core purpose and adds only essential details, 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?

Despite lacking an output schema, the description covers the main return state ('acquired:false'). It also includes cost, endpoint, and parameter guidance, making it fairly complete for a simple lock tool. Minor gaps like error responses are omitted.

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 are fully documented in the input schema (100% coverage). The description adds no additional semantic meaning 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?

The description clearly specifies the action ('acquire'), the resource ('named lock'), and the outcome ('so only one agent proceeds', 'returns acquired:false if held'). It effectively distinguishes from the sibling tool 'lock_release' by focusing on acquisition.

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

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

The description provides clear context: it is for distributed locking with a TTL and returns a boolean. However, it lacks explicit guidance on when not to use the tool (e.g., if no lock is needed) or comparisons to other tools beyond the implicit sibling distinction.

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 partially covers behavior by listing required fields and noting the tool is paid ($0.003) and uses POST /api/lock/release. However, it does not disclose failure modes, idempotency, or whether the operation is reversible.

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 with no fluff. It front-loads the purpose and includes all critical operational details without excess.

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

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

Given the tool's simplicity (3 parameters, no output schema), the description covers the core purpose and parameters. However, it lacks details about return values, success indicators, and error responses, 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%, so parameters are already documented. The description adds little beyond listing the fields to send ('name, token, holder?') and hinting that holder is optional, which is already indicated 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 states the verb 'release' and the resource 'distributed lock you hold', distinguishing it from the sibling tool '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?

The description implies use after acquiring a lock but provides no explicit when-to-use or alternatives guidance. The context of a sibling 'lock_acquire' helps, but no direct exclusions or scenarios 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?

No annotations are provided, so the description carries full weight. It discloses that the tool is a paid x402 tool with a price of $0.003 and the POST /api/markdown endpoint. It also specifies that it strips nav, script, and style noise. However, it does not mention rate limits, authentication requirements, or behavior on invalid HTML.

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, consisting of two clear sentences. Every word adds value: the first sentence states the core purpose, and the second adds details about noise removal, pricing, and endpoint. There is no extraneous 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 (single parameter, no output schema), the description covers all essential aspects: input (raw HTML), output (LLM-ready markdown), behavioral traits (noise stripping), and commercial details (pricing, endpoint). It adequately informs an agent about invocation 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?

The input schema covers 100% of parameters with a description for the single parameter ('Raw HTML'). The description does not add meaningful semantics beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool converts raw HTML to LLM-ready markdown and strips unwanted elements (nav, script, style). It distinguishes the tool's specific output format (markdown) from generic text extraction, but it does not explicitly differentiate from similar sibling tools like 'extract' or 'read_structured'.

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 generating LLM-friendly markdown but provides no explicit guidance on when to use this tool versus alternatives. It lacks when-not-to-use scenarios or mentions of fallback tools among the many 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; description adds cost and endpoint details. Discloses read-only nature implicitly, but lacks explicit safety or rate-limit info.

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

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

Two tight sentences: purpose first, then invocation format and pricing. Every word carries 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?

Covers key behaviors (list vs get, required inputs, cost). Missing return format detail, but for a simple tool this is adequate.

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

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

Schema covers 100% of parameters with descriptions. Description restates structure in a shorthand form and clarifies key optionality, adding marginal value above 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?

Clear verb-resource pairing: 'read a stored value by key, or omit key to list all keys'. Distinguishes from sibling memory_set (write).

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?

Specifies required inputs: 'Send { ns, token, key? }' and includes pricing info. No explicit when-not, but context is clear for a simple read tool.

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

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

With no annotations, the description provides good behavioral disclosure: durability across runs, size limit, claim mechanism, price, and endpoint. It does not mention overwrite behavior but that is inherent. 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 front-load purpose and constraints. Includes pricing and endpoint info, which is extra but useful. No wasted words, though slightly dense. Good structure.

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 set tool with 4 required params and no output schema, the description covers the storage mechanism, size limit, claim pattern, and pricing. It is complete enough for correct usage. Could mention return value implications but not necessary.

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 detailed parameter descriptions. The description adds minimal extra meaning beyond listing the parameter object (e.g., 'Send { ns, token, key, value }') and the claim context for the token. 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 writes a JSON value under a key to durable storage, distinguishing it from sibling tools like memory_get. It specifies the verb, resource, and constraints (16KB max, namespace/token mechanism).

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 agent runs and explains the first-write claim pattern, but it does not explicitly state when to use versus alternatives (e.g., memory_get) or when not to use. Usage context is 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 provided, but description discloses it's a paid tool with cost and HTTP method/endpoint. This adds critical behavioral context beyond what annotations would typically provide. Implicitly read-only data retrieval.

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 terse sentences plus a bracket note with price and endpoint. Every piece of information is valuable and front-loaded. 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?

No output schema, but description lists the data fields returned (calls/puts, mark, IV, OI). Also includes pricing and endpoint. Missing pagination or limit behavior, but overall sufficient for a 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 description adds meaning: expiry defaults to nearest, currency limited to BTC/ETH/SOL. This goes beyond the schema's description for expiry (e.g., '28AUG26'; defaults to nearest).

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 the full options chain with per-strike calls and puts, and includes specific data fields (mark price, implied volatility, open interest). It distinguishes from siblings like options_greeks or options_price by specifying it's the full 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?

Provides explicit required parameter (currency) and optional expiry with default behavior. Also mentions it's a paid tool with price and endpoint. No explicit comparison to alternatives, but context is clear enough for an agent to decide when 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 provided. Description mentions payment ($0.05) and endpoint, but no details on rate limits, auth, or non-obvious behaviors. Adequate for a pure computation 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?

Two sentences plus a tagline. First sentence states core purpose, second gives parameter format and capability extension, third adds cost/endpoint. 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, so description should clarify return format. It says 'fair value + full greeks' but doesn't specify field names or schema of response. Nearly complete for usage but lacks output detail.

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%. Description reinforces iv as percentage and rate as optional with default 0, but adds minimal new meaning beyond 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?

Description states 'Black-Scholes option pricing: fair value + full greeks' with specific greek names. Distinguishes from sibling tools like options_price (price only) by explicitly including greeks.

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?

Specifies input parameters in 'Send { ... }' format and notes applicability to any crypto option, not just exchange-listed. Does not explicitly exclude alternatives but implies use for greeks computation.

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 ($0.02) and uses POST /api/options/maxpain, but does not explicitly state whether it is read-only or has side effects. The cost and endpoint add some transparency, but behavioral traits beyond that 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 a single sentence followed by a concise note in brackets. It is front-loaded with the core purpose and includes essential context (pricing, endpoint) without 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 two-parameter tool with no output schema, the description explains the returned data (max-pain strike + open-interest ratio), the required parameters, and includes pricing and endpoint info. This is sufficient for an agent to understand what the tool does and what to expect.

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

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

Schema coverage is 100% with both parameters already described in the input schema. The description merely restates 'currency, expiry?' without adding new detail or examples beyond what the schema provides. 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 computes 'max-pain strike + put/call open-interest ratio' and explains it as 'the price level where option holders lose most; a positioning/magnet signal.' The purpose is specific and distinct from sibling tools like options_chain, options_greeks, 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?

The description instructs to 'Send { currency, expiry? }' but does not explicitly guide when to use this tool versus alternatives like options_chain or options_greeks. The context of sibling names implies specialization, but no usage exclusions or conditional advice is 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 are provided, so the description carries the full burden. It discloses the tool is a paid tool costing $0.05 and uses a POST endpoint, but lacks details on authentication, rate limits, error handling, or parameter conflict resolution.

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-loading the purpose and immediately followed by usage instructions and pricing. Every sentence is essential, no fluff, and structured for 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?

Given the 5 parameters and no output schema, the description provides a good overview of inputs, output fields (mark, IV, OI, greeks, underlying), and source. However, it could be more complete by explaining behavior if both parameter groups are provided or if input is invalid.

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

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

Schema coverage is 100%, providing a baseline of 3. The description adds value by grouping parameters into two usage patterns (instrument vs. currency+strike+type+expiry), clarifying how to specify the option beyond the schema's individual 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 provides a live crypto option quote from Deribit, listing specific data fields (mark price, IV, open interest, greeks, underlying). It specifies the asset classes (BTC/ETH/SOL) and provides an example instrument name, making the purpose highly 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 implies usage when a single option quote is needed but does not explicitly contrast with siblings like options_chain or options_greeks. No when-not or alternative guidance is given; the context is inferred from the sibling list.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool is paid ($0.02), provides the endpoint, and explains that rising IV indicates rising expected volatility. This adds useful behavioral context beyond a simple read operation.

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, front-loading the core purpose ('Implied-volatility term structure'), and includes necessary details (interpretation, cost, endpoint) in a compact format 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 tool with one parameter and no output schema, the description adequately explains what it does, what to provide, and what to expect (ATM IV per expiry and front-month IV). It is complete for an AI agent to decide on 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% with a clear description for the currency parameter. The description only reiterates to send a currency, adding no new semantic information 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 it provides the implied volatility term structure, specifically ATM IV per expiry and front-month IV for a given currency. This distinguishes it from sibling tools like options_price (price) and options_greeks (greeks).

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 instructs to send a currency but does not explicitly provide when-to-use or when-not-to-use guidance relative to alternatives. Usage is implied by the tool's specific function.

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

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

No annotations are present, so the description carries full weight. It discloses that the tool is paid ($0.02) and the REST endpoint, but lacks details on authentication, rate limits, error handling, or data freshness. The payment info adds value but other behavioral aspects 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 (two sentences plus a note) and front-loaded with the main purpose. The payment and endpoint info adds slightly to length but is useful context. 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 simple one-parameter tool with no output schema, the description adequately covers the inputs and outputs (basis %, annualized carry, signal). It does not specify the exact response structure or format, but for a simple tool this 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 description coverage is 100% for the single 'coin' parameter. The description only repeats 'Send { coin }' without adding new meaning or constraints 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 clearly states the tool computes perpetual vs spot basis for a given coin, specifying outputs like basis %, annualized carry, and contango/backwardation signal. It also mentions the required input 'coin' and differentiates from sibling tools like funding rate 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 basis trade and cash-and-carry signals, but does not explicitly state when to use this tool versus alternatives like perps_funding or perps_funding_arb. No exclusionary 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 does not explicitly state read-only behavior, error handling, or authentication needs. However, it does disclose it is a paid tool ($0.02) and the HTTP method, adding some transparency. The retrieved data implies a non-destructive read operation.

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 dense sentence followed by a bracketed note with pricing and endpoint. It is concise and front-loaded with the purpose and key data points, but could potentially be split for readability.

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 a comprehensive list of returned fields and the tool's purpose. It also includes pricing and endpoint. However, it does not describe the return structure or error behavior, which would be helpful 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 'coin' parameter, which already describes it as a perp symbol with examples. The description redundantly says 'Send { coin }' but does not add new semantic meaning beyond the schema. 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 explicitly states it retrieves the perpetual funding rate for a given coin on Hyperliquid, lists the specific data points (hourly rate, APR, prices, OI, volume, premium, cross-venue funding), and clearly identifies its use case for perp traders and funding-rate strategies. This distinguishes it from sibling tools like perps_funding_arb or perps_basis by covering cross-venue funding.

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 instructs to send a coin parameter and notes it is a core signal for perp trading strategies, but it does not provide explicit when-to-use or when-not-to-use guidance relative to sibling tools. No alternatives are mentioned.

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

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

There are no annotations, so the description carries the burden. It discloses that the tool is paid, the endpoint, and price. It mentions expected outputs (annualized funding, spread, delta-neutral leg). However, it does not detail rate limits, authentication, idempotency, or any side effects. For a read-only query tool, this is adequate but not comprehensive.

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: three sentences plus a bracketed pricing note. The first sentence states purpose and outputs, the second gives a command, the third summarizes. It is front-loaded with essential information and contains no fluff.

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

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

Given the tool has one simple parameter, no output schema, and no annotations, the description covers the main inputs, outputs (annualized funding, spread, delta-neutral leg), and pricing. It does not detail the return format, but for a signal tool this is acceptable and leaves little ambiguity about what the tool does.

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 'coin', which the description simply says 'Send { coin }' and the schema already describes it as 'Perp symbol, e.g. BTC.' The description adds no extra semantic meaning 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?

The description clearly identifies the tool as 'Cross-venue funding-rate arbitrage for a coin' and lists specific outputs: annualized funding on Hyperliquid vs Binance vs Bybit, the spread, and the delta-neutral leg. This distinguishes it from sibling tools like perps_funding (single venue) or perps_basis (basis).

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 direct usage instruction ('Send { coin }') and states the tool's purpose as a 'Delta-neutral yield signal for funding-arb agents.' It implies when to use—for cross-venue funding arbitrage—but does not explicitly mention when not to use or alternatives. Still, it provides clear context given the sibling tool set.

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