hostdefi-x402

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

Beyond the annotations (readOnlyHint=false, openWorldHint=true), the description discloses critical behavior: payment cost, that the key arrives in the paid response, no account/signup required, and that the user is only charged when a result actually comes back. This adds significant context not present in structured metadata.

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 dense sentences deliver purpose, cost, exact usage steps, and payment terms with zero waste. The most critical facts (paid, key, no signup) are front-loaded, and the step-by-step guidance is structured logically.

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 1-parameter tool with no output schema, the description covers the full call flow, the return value (key arrives in the paid response), payment mechanics, and caveats about charging. An agent has everything needed to invoke the tool correctly across both phases.

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

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

The schema only says 'base64 X-PAYMENT payload' for x402_payment, but the description explains its role in the two-step payment flow: omit it first to receive an accepts array, then set it to the payment payload on the second call. This adds essential 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 states the tool's action: 'Mint a 30-day HostDeFi Agent-plan API key' with specific attributes (5,000 calls, batch enabled, $5, one payment). This distinguishes it from informational siblings like get_x402_pricing and has no ambiguity about what is being bought.

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

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

It provides an explicit two-call procedure: first call without x402_payment to receive payment requirements, then call with the x402_payment payload. While it doesn't compare to alternatives (no other buy tool exists), the usage flow is clearly specified and actionable.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, covering safety and idempotency. The description adds 'FREE' (cost to call) and clarifies the return content (prices and settlement rails), which annotations do not cover. It does not contradict annotations, and the added context is useful for an agent deciding whether to invoke it.

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

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

The description is a single, efficient sentence that front-loads the key benefit ('FREE') and states the exact content of the catalog. Every word adds value, with no redundancy or filler. The structure is ideal for quick agent scanning.

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

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

The tool is simple (zero parameters, no output schema), and the description sufficiently conveys what the caller will receive: a catalog of all paid resources with USD prices and settlement rails. While it does not specify the exact response format (e.g., JSON array), the description is adequate for an agent to know what to expect and how to use the data. No critical information is missing for a tool of this complexity.

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

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

There are zero parameters, so the schema is trivially documented at 100% coverage. The description correctly adds no parameter-specific detail because none exists. Per rubric, a baseline of 4 applies for zero-parameter tools, and the description does not need to compensate for any schema gaps.

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

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

The description clearly states a specific resource ('every paid resource'), its attributes (USD price and settlement rails), and positions it as a catalog. This distinguishes it from sibling tools like swap_evm_price or token_report, which serve different purposes. The 'FREE' prefix immediately signals the tool is safe to call.

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—consult this catalog to learn costs before calling paid tools—but it does not explicitly state when to use it versus alternatives or provide any exclusion criteria. There is no mention of when not to use it, but the zero-parameter design makes it self-evident for pricing lookups. A score of 3 reflects the lack of explicit guidance while acknowledging the implied 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: the paid nature ($0.02/call), the sampling rate (~1/min), the normalized series, the 404 for untracked markets, and the exact payment handshake. It doesn't contradict annotations. It could mention rate limits or data retention, but the payment and 404 behavior are well disclosed.

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

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

The description is dense but every sentence earns its place: payment cost, data shape, sampling, the two-step payment flow, and the 404 behavior. It is front-loaded with the most critical fact (paid) and the resource scope. No fluff or repetition of the title.

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 explains the return format ([ts, yesUsd, noUsd]) and the payment handshake, which is the main complexity. It doesn't specify pagination or time range details beyond '24h', but the sampling and series normalization are covered. The payment flow is fully described, making it complete enough for an agent to call correctly.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds meaning by explaining that marketId comes from predict_markets (a sibling tool) and that x402_payment is the base64 X-PAYMENT payload from the first call. This goes beyond the schema's bare descriptions, though it doesn't detail the format of the payment requirements array.

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

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

The description states a specific verb ('predict_history' implies retrieving history), a clear resource ('24h odds history for one tracked Polymarket market'), and the exact data shape ('[ts, yesUsd, noUsd] points sampled ~1/min'). It distinguishes itself from siblings by specifying it is for a single tracked market and mentions the payment model, which is unique among the listed 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 explicitly explains the two-step usage: first call without x402_payment to get payment requirements, then pay and call again with x402_payment. It also states the condition for an untracked market (uncharged 404) and clarifies that charges only occur when a result is returned. This is clear when-to-use guidance, though it doesn't name alternative tools for similar data, but the payment flow is the key usage context.

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

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

Annotations already establish readOnly, idempotent, non-destructive behavior. The description adds crucial information beyond those annotations: the paid nature ($0.005/call), the required two-step x402 payment exchange, and the charging only when a result returns. This goes well beyond what structured annotations provide and directly affects agent decision-making.

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

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

The description is dense and every sentence earns its place, including the payment flow which is essential operational detail. It is not laid out in the cleanest structured form, and 'You are only charged when a result actually comes back' is a useful but slight restatement of the paid nature. Still, there is no fluff.

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

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

For a paid, two-step x402 tool with no output schema, the description is remarkably complete: it explains scope, fields returned, how to pay, the exact call sequence, and billing semantics. An agent has everything needed to invoke this tool correctly without guessing. The only omitted details are response formatting and default limit behavior, which are minor here.

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

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

Schema coverage is only 50%: x402_payment has a schema description, while limit does not. The description compensates substantially for x402_payment by explaining the two-call flow and what payload to supply. Limit is not addressed in the description, but its name plus the min/max constraints make its role self-evident. The added payment workflow context lifts this above a baseline score.

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

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

The description clearly names the resource: Polymarket prediction markets tracked by HostDeFi (top ~100 by 24h volume), and lists the returned data points: market ids, questions, latest yes/no odds, and sampling stats. It lacks an explicit verb like 'get' or 'list', but the intended action is unmistakable. It also differentiates from siblings by emphasizing the live odds board and HostDeFi's own recorded series.

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

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

The description gives explicit invocation steps: call once without x402_payment to receive the accepts array, then call again with x402_payment set to the base64 X-PAYMENT payload. This is strong operational guidance. It does not explicitly contrast this with alternatives like predict_history, but the scope and payment flow make when to use it clear enough.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds crucial behavioral context about the payment requirement and the two-call flow, which is not in the annotations. It also clarifies the charging condition. While it doesn't describe the output structure, the annotations plus description give a solid behavioral picture.

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 efficient, with four sentences each carrying distinct information: purpose, payment requirement, two-step call process, and billing behavior. It front-loads the core purpose and payment note before the procedural details. No fluff, but it is slightly dense for a single paragraph.

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 (paid, two-step flow) and lack of output schema, the description adequately covers the payment mechanism, the need for a second call, and the types of signals returned. It doesn't specify the exact output format or error handling, but the signal list gives a reasonable expectation. The tool is specialized, and the description provides enough to use it correctly.

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

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

The input schema already describes both parameters (mint as a Solana mint address, x402_payment as a base64 X-PAYMENT payload), so schema coverage is 100%. The description reinforces the role of x402_payment in the payment flow, but doesn't add new semantic meaning beyond what the schema provides. The baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose: it provides pre-graduation on-chain signals for a Solana mint, listing specific signal types (bundled-launch detection, holder concentration, Token-2022 traps, authority state). This distinguishes it from sibling tools like token_risk_deep or scan_token, which likely focus on post-graduation or general analysis. The verb is implicit but the resource and scope are explicit.

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 an explicit two-step usage flow: first call without x402_payment to get an `accepts` array, then pay and call again with the X-PAYMENT payload. It also states that charging only occurs when a result is returned, which clarifies the cost model. This is direct, actionable guidance that removes ambiguity 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: the two-phase payment flow, the fact that the first call returns an accepts array, and that charges only occur when a result is returned. It does not describe pagination or the exact JSON structure, but the description's added context is substantial. No contradiction with annotations.

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

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

The description is compact and front-loaded: it states the cost and resource first, then the payment flow. Every sentence earns its place, and the two-phase call sequence is explained in a clear, linear manner without redundancy. It is appropriately sized for the complexity of the tool.

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 (paid, two-phase x402 flow) and the absence of an output schema, the description covers the essential workflow, cost, and charge condition. It does not describe the exact JSON response structure or the limit parameter's effect, but the core calling contract is fully specified. The sibling list shows many other tools, and this description clearly distinguishes this one's payment mechanism.

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 50%: the x402_payment parameter is documented in the schema, but limit is not described in the schema. The description explains the x402_payment parameter's role in the two-phase flow, adding meaning beyond the schema's bare 'base64 X-PAYMENT payload'. It does not explain the limit parameter's semantics, but the name and schema constraints (1-100) make it reasonably inferable. The description compensates for the schema gap on the payment parameter, which is the more complex one.

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

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

The description states a specific verb ('Call'), a resource ('HostDeFi trend-radar alerts'), and the key content ('big dated movers with real market cap, structured JSON'). It also clearly distinguishes this from sibling tools by naming the x402 payment flow, which is unique among the listed siblings. The title 'Trend radar alerts' is reinforced, not merely restated.

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

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

The description gives explicit step-by-step usage: call once without x402_payment to receive the accepts array, pay one of them, then call again with x402_payment set to the base64 payload. It also states the cost ($0.01/call) and the condition for being charged. This is far beyond typical usage guidance and leaves no ambiguity about the required sequence.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds valuable behavioral context: it's free, rate-limited to 100 checks/day per IP, and returns a structured risk read with specific signal categories (authority state, liquidity, holder concentration, contract flags). This adds beyond the annotations without contradicting them.

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

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

The description is slightly verbose but front-loaded with 'FREE' and the core purpose. Each sentence contributes useful information: input formats, output type, rate limit, and the reference URL. No redundant fluff, though it could be trimmed slightly without losing meaning.

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

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

For a read-only, single-parameter tool with no output schema, the description is quite complete. It specifies valid inputs, what the response contains, and operational constraints (free, rate limit). It does not describe the exact response format, but that is not critical for a scan tool. The coverage is sufficient for an agent to call it correctly.

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

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

The schema description for the single parameter 'token' already says 'token contract address / Solana mint, or an exact token name/ticker', with 100% coverage. The tool description adds minor clarity by specifying 'any token contract address (Solana mint or EVM address)' and 'exact token name/ticker', but this is marginal. The baseline of 3 is appropriate since the schema carries most of the semantic load.

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

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

The description clearly states it is a 'token-safety scan' with a specific verb and resource, and details the exact inputs (contract address or name/ticker) and output (structured risk read with on-chain signals). It distinguishes itself from generic tools, but does not explicitly differentiate from sibling risk tools like token_risk_deep or token_risk_verdict, so it falls short of a perfect score.

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 a free, quick scan ('FREE', 'no payment, no signup', 'fair use 100 checks/day'), giving contextual cues about when it might be appropriate. However, it does not explicitly state when to use this tool instead of siblings like token_risk_deep or token_risk_verdict, nor does it mention any exclusions or alternatives.

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

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

Annotations declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, which already establish the safety profile. The description adds substantial behavioral context: the two-step payment flow, the cost per call ($0.002/call), the fact that payment is only charged when a result comes back, and the nature of the response (an `accepts` array). This goes well beyond annotations and fully discloses the transactional 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?

The description is a single dense paragraph but every sentence carries necessary information: pricing, purpose, the two-step process, and payment mechanics. It is front-loaded with the price preview concept and payment cost. It could be slightly more structured (e.g., bullet points), but it remains efficient and free of filler. The length is justified by the complexity of the payment flow.

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 and a non-trivial payment workflow, the description covers all essential aspects: what it returns (expected and minimum output), how to initiate payment, how to complete the call, and the charging model. It explains the `accepts` array and the need to pass the base64 payload. No critical information is missing for an agent to correctly use this tool.

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

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

Schema coverage is 100%, so each parameter already has a description. The tool description adds value by explaining the role of `x402_payment` in the overall flow (base64 X-PAYMENT payload) and the sequencing of calls. It clarifies that `sellToken` and `buyToken` accept 'native' or addresses, and that `sellAmount` is in base units, but these are already in the schema. The added context about payment flow elevates it above the baseline of 3.

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

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

The description clearly states the tool's purpose: 'EVM swap price preview: expected and minimum output for a pair/amount before committing to a firm quote.' It explicitly contrasts with a firm quote, differentiating from the sibling 'swap_evm_quote' without naming it directly but implying the distinction. The verb 'preview' and resource 'swap price' are specific and unambiguous.

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

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

The description provides explicit step-by-step usage: 'Call once WITHOUT x402_payment to receive the x402 payment requirements (an `accepts` array); pay one of them... then call again with `x402_payment` set...' It also explains when to use this tool ('the cheap look-before-you-swap call') and notes that it is paid per call only when a result is returned. This is explicit and actionable.

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

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

Annotations already signal read-only/idempotent/non-destructive behavior, and the description adds meaningful context beyond them: the $0.01 cost and only-on-result billing, the 1% native-coin platform fee, and the custody-free behavior. The 'ready-to-sign' wording confirms the tool itself does not broadcast, matching readOnlyHint; no contradiction.

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

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

Every sentence carries decision-relevant operational detail, including cost, fee composition, custody model, and the two-call payment flow. Cost and firmness are front-loaded, and there is no fluff or redundancy with the schema.

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 states the main return concepts: a firm quote, a ready-to-sign transaction, the accepts-array payment requirements, and the fee inclusion. It does not enumerate response fields, but for a two-call quote tool this is sufficient for an agent to follow the workflow.

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

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

Schema description coverage is 100%, so the schema already documents chainId, token parameters, taker, sellAmount, and x402_payment. The tool-level description repeats the two-call x402_payment workflow rather than adding new parameter-level semantics, which warrants the 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?

The description names the exact deliverable — 'a firm KyberSwap-routed quote plus a ready-to-sign transaction' — and clarifies the non-custodial execution model ('no key, no account'). The 'ready to sign' framing clearly distinguishes it from the price-only sibling swap_evm_price without ambiguity.

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

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

It gives an explicit two-stage invocation protocol: 'Call once WITHOUT x402_payment to receive the x402 payment requirements... then call again with x402_payment set.' It also warns that the tool is paid and charged only when a result returns. It does not explicitly name swap_evm_price as the alternative, so it stops short of a full when-not-to-use statement.

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

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

Annotations already mark this as read-only and idempotent, but the description adds substantial behavioral context: it is paid at $0.02/call, the user is charged only when a result returns, and the clean flag is fail-closed. The two-call payment handshake is also disclosed, which is critical for an agent to invoke the tool correctly.

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

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

The description is compact and front-loads the paid nature before explaining the payment flow. The em-dash list and semicolon-heavy second sentence require a bit of parsing, but every sentence carries necessary information 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?

Even without an output schema, the description tells the agent what results contain, how to obtain them via the payment handshake, and when charges apply. The invocation path is fully specified and no critical step is missing.

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

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

Schema coverage is 67%, and the description adds real operational meaning for x402_payment by explaining that it is the base64 X-PAYMENT payload from the initial requirements call. However, the description adds nothing beyond the schema for chain or limit, so the added parameter-level value is only partial.

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 returning fresh token launches with HostDeFi safety pre-reads, listing concrete fields such as authority state, bundled-launch flag, holder concentration, and market depth. It is unambiguous about the resource and scope, but it never uses an explicit retrieval verb and does not contrast itself with sibling scan/report tools, so it stops short of full 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 gives explicit operational guidance for the two-step payment flow: call once without x402_payment to receive an accepts array, pay, then call again with the base64 X-PAYMENT payload. It clearly explains the required invocation sequence, though it does not state when to prefer this tool over siblings like scan_token or radar_alerts.

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

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

Beyond the annotations, the description discloses the paid nature, the exact two-call x402 payment sequence, and the guarantee that the caller is only charged when a result actually comes back. This is significant behavioral context that annotations do not capture.

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

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

The description is dense but purposeful, covering cost, report contents, and the two-step payment flow without fluff. It could be improved with structural formatting, but every sentence contributes useful information.

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

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

For a paid, multi-step x402 tool with no output schema, the description explains prerequisites, call sequence, payment mechanics, and what the returned report will include. It is not missing essential call-time information, although an explicit note about possible errors or non-payment responses would make it fully complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description reinforces that x402_payment should be omitted on the first call scrape, matching the schema, but it does not materially extend parameter understanding beyond what the schema already states.

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

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

The description states a specific resource ('HostDeFi full due-diligence report') and enumerates the report's contents (verdict, on-chain signals, verdict history, trend-radar, rug-ledger). It is clear and detailed, though it does not explicitly name or contrast sibling tools like token_risk_verdict or token_risk_deep.

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

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

The description gives explicit calling workflow: first call without x402_payment to receive requirements, pay one of the accepts array, then call again with x402_payment set. It also clarifies charging behavior. Missing an explicit statement of when to prefer this over other token tools, but the workflow itself is strong.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: the paid nature, the two-call payment flow, the fact that figures are computed from recorded rows with no projections, and the history depth accrual date. It doesn't describe pagination or error behavior, but the annotations carry the safety burden and the description adds meaningful operational context.

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

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

The description is a single dense paragraph that front-loads the most important facts (paid, deep report, verdict/history/trend) and then explains the payment flow. It's longer than ideal but every sentence earns its place: cost, report contents, data source, history start date, and the two-call payment mechanism. The structure could be improved with line breaks, but it's not bloated.

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

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

For a paid tool with a two-step payment flow, the description covers the critical operational context: cost, payment requirements, and the need to call twice. The output schema is absent, but the description enumerates the report's components (verdict, history, trend block) so an agent knows what to expect. Minor gaps: no mention of rate limits or what happens on payment failure, but the core calling contract is fully specified.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds context for x402_payment (the two-call flow) and mentions limit's default (365) implicitly through the schema. It doesn't add much beyond the schema, but the baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: a paid deep HostDeFi report that returns a current A+-F verdict, full dated safety history, and a derived trend block. It distinguishes itself from siblings by naming the specific report type and the unique history/trend components, so an agent can tell it apart from token_report and token_risk_verdict.

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

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

The description provides explicit usage guidance: call once without x402_payment to get payment requirements, then pay and call again with x402_payment set. It also states the cost ($0.25/call) and the condition that you are only charged when a result comes back. This is clear when-to-use and how-to-use guidance, including the two-step payment flow.

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?

Even with readOnlyHint/idempotentHint present, the description adds significant non-obvious behavior: the tool is paid at $0.02/call, requires a two-step x402 payment exchange, and only charges when a result is returned. 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?

Three dense sentences, with the cost and purpose front-loaded before the payment walkthrough. No filler or repetition of schema details.

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

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

Given no output schema, the description names the expected result fields (grade, score, verdict prose, signals), and covers the only nontrivial call protocol (x402 payment). An agent has enough to invoke it correctly.

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

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

The schema already documents all three parameters at 100% coverage, so the baseline is 3. The description goes beyond the schema by explaining the payment workflow: first call without x402_payment yields an accepts array, and the second call must include the base64 X-PAYMENT payload. This materially helps an agent use the optional parameter correctly.

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

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

States the tool's specific job: produce HostDeFi A+–F verdicts for a chain+address, and lists the delivered fields (grade, score, verdict prose, liquidity/holders/authority signals). The resource and output are clear, though it never explicitly contrasts token_risk_deep or scan_token, so it doesn't fully differentiate among siblings.

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

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

Provides explicit call sequencing: omit x402_payment on the first call to receive an accepts array, then pay and retry with the base64 X-PAYMENT payload. This is strong operational guidance, but it never states when to prefer this tool over a sibling like token_risk_deep, so it lacks a when-not/alternative statement.

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

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

Annotations already declare readOnly/openWorld/idempotent hints, and the description adds critical behavioral context beyond them: the tool is PAID ($0.10/call), requires an x402 payment flow, and only charges when a result returns. It also discloses the heuristic nature ('Holdings exposure heuristics') and its exclusions, which materially shapes how an agent should invoke and trust it.

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

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

The description is dense and front-loaded, leading with the most critical fact (PAID), then the purpose, then exclusions and the payment workflow. Each sentence earns its place; there is no fluff or repetition of schema details that are already visible.

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

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

For a paid two-step tool with no output schema, the description covers everything an agent needs to call it correctly: what it does, what it returns, the payment prerequisites, the exact payload setting, and the charge policy. The 'NOT AML' disclaimer prevents misuse. No obvious gaps remain.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds meaning by explaining the role of x402_payment in the two-step call flow and clarifying that wallet refers to a Solana wallet, which helps an agent sequence calls correctly. This goes beyond the schema but is not exhaustive about parameter formats beyond what schema provides.

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

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

The description uses a specific verb ('read') and resource ('Wallet risk-exposure read for a Solana wallet') and details the outputs: largest holdings graded through the verdict path, exposure counts by risk tier, and a rug-ledger cross-check. It also distinguishes itself from related tools by explicitly stating it is NOT AML attribution or sanctions screening, removing ambiguity about its scope.

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 an explicit two-step usage protocol: call once without x402_payment to get payment requirements, then call again with the payment payload. It also clearly states a when-not (not AML/sanctions screening) and the charging condition. However, it does not name sibling tools or specify when to use them instead, so it stops short of full alternative routing.

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

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

Annotations already carry readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable context beyond that: the $0.02/call cost, the charging condition ('only charged when a result actually comes back'), and that the result is a 'dated crawl snapshot' implying data may be stale. No contradiction with annotations — readOnlyHint is consistent with a pre-payment vetting 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 dense but every sentence earns its place: cost, purpose, signals, two-step workflow, and charging behavior. The most critical info (PAID, vet BEFORE paying) is front-loaded. It's longer than average but packed with necessary operational detail for a paid two-call workflow.

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

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

For a paid two-step workflow with no output schema, the description covers the key operational aspects: the call sequence, the return value (A–F grade and the `accepts` array), and cost behavior. It doesn't detail error cases or the exact return structure of the grade result, but given there's no output schema, the essentials are addressed.

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 documented, so the baseline is 3. The description adds meaningful workflow context explaining how the two parameters interact: the first call omits x402_payment to get the `accepts` array, then the second call includes it as a base64 X-PAYLOAD payload. This explains parameter 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 uses a specific verb+resource combination ('Vet an x402 seller') and a concrete output (A–F grade from observable signals: 402-spec fidelity, price sanity, payTo presence, TLS, latency). It clearly distinguishes this tool from its siblings, which are swap/predict/scan tools, by focusing on risk assessment of x402 providers before payment.

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

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

The description gives explicit workflow guidance: call once WITHOUT x402_payment to receive requirements, pay, then call again with the payment payload. It also states when to use it ('BEFORE paying'). It doesn't explicitly name alternatives or when-not-to-use exclusions, but the workflow and context are clear enough to route an agent.

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