GhOsT77 crypto data jobs

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

Annotations only say read-only and open-world; the description adds latency ('under a minute'), data provenance ('public data; inferences labelled'), full pricing mechanics (1.1 USDC on Base via x402 at a specific POST endpoint), and payee wallet verification. That is exactly the context an agent needs before spending money on a call, and nothing contradicts the read-only hint.

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?

Front-loading is excellent: the problem statement, output shape, and input format come first. However, a sizeable tail of the text is promotional/identity material (10% fee set aside for the GHOST77 token, two verification URLs, full payout wallet) that does not help an agent decide or invoke; only the x402 pricing sentence earns its place.

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

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

With no output schema, the description correctly compensates by describing the return value (health score plus ranked issues with causes and fixes). Inputs, output, latency, cost, and data trust level are all covered, so nothing material is missing for a 2-parameter read-only 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 would be 3, but the description adds a concrete invocation example and enumerates symptom categories ('no jobs, not in search, jobs expire, setBudget fails') and the diagnostic areas checked, which helps the caller phrase the optional symptom parameter well.

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

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

Names a specific diagnostic verb and resource: a health check for a Virtuals ACP agent that returns a 0-100 score plus ranked issues, causes, and exact CLI fixes. None of the sibling tools (token research, funding scans, wallet checks) overlap, so the agent can route here unambiguously.

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 opening question 'Why is a Virtuals ACP agent not getting jobs?' plus the worked example with symptom 'no jobs' establishes the trigger condition clearly. There are no exclusions or named alternatives, but no sibling competes for the same usage, so the missing 'when-not' clause is low cost.

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?

Goes well beyond the readOnly/openWorld annotations: discloses it reads public RPC data, is not an official status page, returns a plain-English summary, runs in seconds, performs a public-RPC latency check, and is paid at 0.55 USDC per call via x402 with a specific POST URL. The 10% fee/token/wallet identity paragraphs are largely promotional but do disclose cost and payout context an agent should know.

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 purpose and metric list are front-loaded and useful, but the closing ~60% is promotional filler (ERC-8004 agent number, Virtuals ACP link, payout wallet address, token contract, fee set-aside) that does not help an agent decide to call the tool. Only the per-call price and x402 endpoint earn their 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 2-parameter read-only analytics call with no output schema, the description covers what data comes back (metric list + plain-English summary), latency expectations, data source reliability caveat, and cost/payment mechanics. Only the exact response structure is left implicit.

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

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

Schema description coverage is 100% and already documents the 'base' enum and the 10-500 block range with the 100 ≈ 200 seconds mapping. The description's 'blocks 10-500' and the example payload only restate what the schema already encodes, 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?

The opening question plus the enumerated metric list ('TPS, Mgas/s, block fullness vs gas target, base-fee trend, sequencer liveness, L1 data cost, typical user fee, RPC latency') states a specific resource and scope. It is clearly a Base-chain health snapshot, though it never names or contrasts with close siblings like gas_fee_timing or protocol_stats_snapshot.

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 by 'Is Base congested or expensive right now?' and by the chain-only/base-only constraint, plus 'Seconds' signalling a fast call. There is no explicit when-to-use vs when-to-use-something-else guidance despite siblings covering gas timing and protocol stats.

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 only cover readOnlyHint and openWorldHint; the description adds materially important behavior beyond them — paid per call at 0.55 USDC on Base via x402, latency ('Seconds'), and the explicit reassurance that nothing is executed. The 10% fee set-aside and identity/verification links are transparency-adjacent but more promotional than operationally useful.

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 value proposition is front-loaded, which is good, but a substantial share of the text is promotional: token contract address, ERC-8004 agent ID, Virtuals ACP link, and payout wallet. Those sentences serve trust verification for a paid endpoint but crowd out parameter and output detail.

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

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

With no output schema, the description does carry the return-value burden and lists the five result categories an agent will receive. Missing only response shape/pagination detail and error behavior; payment terms and safety profile are fully covered.

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

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

With 50% schema description coverage, the description names all four parameters and marks bridge_amount optional, plus supplies a concrete example object showing chain/token casing. However, it adds no semantics for the two enum chain parameters beyond the example, and does not explain the default ~$1000 amount logic that lives 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?

States a specific verb and resource — pick a bridge route — and enumerates the concrete evidence it returns (LI.FI/Across quotes ranked by cost and ETA, TVL trends, incidents, canonical-bridge timing, L2BEAT risks). No sibling tool in the list covers bridging, so the scope is unambiguous without needing 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?

'Pick a cheaper, safer bridge route before moving funds' implies the usage context (pre-bridge planning) but never states when not to use it, what prerequisites exist, or how it relates to adjacent tools like gas_fee_timing or contract_security_scan. Guidance is implied rather than explicit.

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 cover only readOnly/openWorld, so the description adds real value: it discloses that missing evidence is explicitly marked 'unknown' (output convention), that latency is under a minute, and that the call costs 2.2 USDC on Base via x402 with a stated endpoint. That cost/payment disclosure is essential for a paid tool. Points are lost because a large share of the text is promotional identity/payout-wallet material rather than operational 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 purpose and input example are correctly front-loaded, but the second half is bloated with token-fee promotion, agent registry URLs, and payout-wallet addresses that do not help an agent decide or invoke. Roughly half the text could be removed without loss of operational 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?

With no output schema, the description must convey what comes back, and it does: the enumerated research facets plus the 'unknown' convention for missing evidence. Combined with the payment and latency notes, an agent has enough to call it correctly; only explicit sibling routing is absent.

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, including the address pattern and chain enum, so the schema carries the semantics. The description adds only a concrete example object ({"chain":"base","contractAddress":"0x9401...8631"}), which is mildly useful but not additive beyond the structured fields. 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?

Opens with a specific verb+resource: what is publicly known about a contract address, enumerating the returned facets (project overview, social/transaction signals, risk summary, source URLs, observation time). It implicitly distinguishes itself from audit-style siblings by stating it is 'not a source-code audit', though it never names contract_security_scan or token_due_diligence directly.

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 an implied scope boundary ('Public-source research only: not a source-code audit or a guarantee of safety') and an example invocation, but gives no explicit when-to-use-vs-alternative routing among the many research/scan siblings (contract_security_scan, project_research_report, token_due_diligence). The agent must infer 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?

Annotations declare readOnlyHint and openWorldHint, but the description adds genuinely new context: latency ('Seconds'), that the call is paid (0.55 USDC via x402 at a specific endpoint), and that a 10% fee is set aside. Payment and per-call cost requirements are exactly the kind of behavioral detail annotations cannot convey. The verification/agent-identity block is largely promotional rather than operationally useful.

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 first sentence is well front-loaded with the actual capability and the second gives the input shape. But roughly half the text is boilerplate about ERC-8004/Virtuals identity, payout wallet addresses, and the GHOST77 token, which is marketing filler rather than invocation guidance. The payment line is justified; the identity/verification block is not.

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 must convey what comes back, and it does — verdict and risk level plus enumerated flags. Combined with an explicit input example and 100% schema coverage, an agent has enough to call it correctly; only the return payload's shape remains slightly underspecified.

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

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

Schema description coverage is 100% and the network enum is present, so the schema already fully documents both parameters. The description's inline example ({"network":"base","contract_address":"0x..."}) adds a small concrete usage illustration but no semantics beyond the schema. Baseline 3 is appropriate.

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

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

Opens with a specific verb+resource framing ('Spot dangerous admin powers') and enumerates the concrete checks: verified-source status, proxy/implementation/admin, owner type, privileged functions, token risk flags, verdict and risk level. An agent can tell this is a contract-level security scan rather than a token DD or honeypot check, though it never names those siblings explicitly.

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 phrase 'Automated read-only scan, not a full audit' sets a useful scope boundary and implies when this is appropriate (quick safety check, not deep due diligence). However, it never routes the agent away from near-neighbors like rug_honeypot_quick_check, contract_research, or token_due_diligence, so the choice between them is left to inference.

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

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

Annotations already declare read-only and open-world behavior, and the description adds useful operational context: public news feeds only, limited coverage, source links, under-a-minute expectation, and paid-per-call pricing via x402. Some identity/payout and token-fee details are extraneous but not contradictory.

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 core purpose is front-loaded and easy to find, but the description is bloated by promotional identity verification, payout wallet, and token-support fee details. Payment endpoint and cost are relevant, while several other sentences do not earn their 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 news-digest tool with a fully described input schema and no output schema, the description covers what the tool returns at a high level, its filters, limitations, and payment requirements. It could be tighter, but it is complete enough to invoke 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 input schema already documents timeframe, topic, and tokens. The description reinforces these with an example JSON, but adds little semantic detail beyond what the schema provides.

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

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

The description states a specific verb and resource: a summarized digest of key crypto headlines for a chosen window, with optional topic/token filtering and source links. This is distinct from sibling tools like sentiment_alpha or market_scan_report.

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 clearly frames the tool for quickly catching up on crypto news and gives an example input, including the timeframe enum and optional filters. It does not explicitly name alternatives or when-not-to-use cases, but the intended 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?

Annotations already declare readOnlyHint and openWorldHint, and the description adds real context beyond them: a per-call price (0.55 USDC on Base via x402), a POST endpoint, a sub-minute latency expectation, a 3-coin cap, and what the report contains. The identity/token-fee paragraphs are commercial disclosures rather than behavioral traits, but the payment and timing details are genuinely useful and not derivable from structured fields.

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 purpose is front-loaded in the first sentence, but the remainder is bloated with promotional and verification material: a 30-day plan upsell, a token fee disclosure with a contract address, two identity URLs, and a payout wallet. These earn their place commercially, not for tool selection, and bury the two genuinely useful facts (price and endpoint).

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 carries the burden of describing returns, and it does list the report components (funding/OI landscape, funding watchlist, top markets, rate/APR/24h vs 7d trend/OI/volume/mark vs oracle). Payment, delivery format, and latency are all covered. Only the focus parameter's effect on output is left unexplained.

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 coins (max 3, default BTC/ETH/SOL) and focus (enum). The description adds a concrete example payload and repeats the 3-coin cap, but says nothing about the focus parameter or how it interacts with coins. 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 opening sentence names a concrete verb+resource: a bundled Hyperliquid market scan plus per-coin funding snapshots capped at 3 coins, rendered as a markdown report. It is distinguishable from siblings like hl_funding_snapshot and market_scan_report because it explicitly claims to combine both, though it never names those siblings to make the division of labor 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 phrase 'one-call daily research bundle' implies the recurring-daily-research use case, and 'Research only: no entries, sizes or return claims' sets scope. However, there is no explicit guidance on when to choose this over hl_funding_snapshot (for arbitrary coins) or market_scan_report, nor any exclusion criteria. Usage is implied rather than stated.

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

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

Goes well beyond the readOnly/openWorld annotations: discloses a per-call price of 0.33 USDC on Base via x402 with the exact endpoint, states the operation takes seconds, and names data caveats (fees, spreads, borrow and basis excluded; blocked venues skipped and named). The payment/auth requirement is exactly the kind of behavioral fact an agent must know before invoking.

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?

Purpose and limits are front-loaded and the operational content is efficient. But roughly half the text is promotional/identity material — token contract address, two verification URLs, payout wallet, agent IDs — which does not help an agent decide or invoke, and dilutes the signal.

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 carries the return-value burden and does so by naming ranked gaps, per-venue rates and skipped venues. Combined with the disclosed limits and payment path, an agent has what it needs to call this correctly; only the shape of an individual gap record remains vague.

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 all four optional parameters already carry descriptions and defaults in the schema. The description lists the parameter names and repeats an example payload, adding no interpretation (units, interaction between coins and top_n) beyond what the schema provides.

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

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

States a specific verb and resource: compares live perp funding across Hyperliquid, OKX, Bitget, Gate, Binance and Bybit, normalized to APR, and lists the widest cross-venue gaps. The cross-venue comparison framing distinguishes it from single-venue siblings like hl_funding_snapshot without needing to name 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 audience is named ("for funding-rate researchers") and an example invocation is given, which implies the intended use. However, there is no explicit when-to-use/when-not-to-use guidance and no routing to alternatives such as hl_funding_snapshot or trade_strategy_consult.

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 openWorldHint=true, but the description adds crucial behavior beyond them: public-RPC estimate limits, typical gas-unit assumptions, no future-fee guarantee, sub-second latency, output shape, and a pay-per-call model (0.06 USDC via x402). These are exactly the details an agent needs to decide whether and how 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 purpose and operational limits are front-loaded, but the description is padded with token-support disclosure, ERC-8004/ACP identity verification, payout-wallet addresses, and 'not financial advice' boilerplate that do not help an agent select or invoke the tool. Several sentences do not earn their 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?

With no output schema, the description carries the return-value burden and does so: ranking, per-chain gwei and USD, and a timing read. It also covers inputs, defaults, latency, cost, and estimation limits, leaving no material gap 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?

Schema description coverage is 100%, and both parameters are enum-documented with defaults. The description only restates that tx_type and chains are optional and repeats the example already present in the schema, so it adds little beyond structured data.

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 and resource: 'live fee estimate in USD for an ETH transfer, ERC-20 transfer or DEX swap' across four named chains, plus cheapest-chain ranking and 7-hour comparison. No sibling tool does gas-fee estimation, so the purpose is unmistakable from the first sentence.

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 a clear when-to-use context: 'For anyone about to send or swap.' There are no explicit exclusions or named alternatives, but because no sibling tool overlaps this function, the absence of alternatives is less costly.

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 cover read-only and open-world, but the description adds genuinely load-bearing behavior: sub-minute latency, paid-per-call at 0.02 USDC on Base via x402, and the payout wallet/identity attestations. That payment/auth prerequisite is exactly the kind of context annotations cannot express; the token-fee and agent-ID material is less behavioral but still useful for trust verification.

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 core capability, input example, and public-page restriction are front-loaded and efficient. The tail — token contract address, ERC-8004 agent ID, two verification URLs, truncated wallet, and duplicate payTo note — is heavy promotional/attestation filler that inflates the definition without helping tool selection.

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 compensates by describing the return shape (summary/extraction plus source URL, evidence, timestamp, limitations) and by disclosing cost and page restrictions. Missing only edge behavior such as failure modes, page-size limits, or timeout handling.

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 url, request and output_format are already fully documented; the description mainly restates them via an example object. The example adds a little guidance on how to phrase 'request', but no constraint details beyond the schema (e.g., https-only is already in the pattern).

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?

Opens with a concrete verb+resource ('Turn a public web page into a structured summary or extraction') and names the return payload (source URL, evidence, timestamp, limitations). It is distinguishable from research siblings like project_research_report or contract_research by being a generic single-page fetch/extract, though it never explicitly contrasts 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?

Gives a hard when-not boundary: 'Public pages only: no sign-in walls, blocked content, forms or account actions,' plus a worked input example. It stops short of naming an alternative tool for authenticated or non-page tasks, so routing against siblings is inferred rather than stated.

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

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

Annotations already declare readOnlyHint and openWorldHint, and the description adds genuinely load-bearing context beyond them: response latency ("Seconds"), data provenance (public HL API, sources and timestamp), a not-financial-advice disclaimer, and — most importantly — that the call is paid 1.1 USDC on Base via x402. The long tail of token fee, payout wallet, and ERC-8004/Virtuals identity metadata is verifiable boilerplate rather than invocation-relevant behavior, keeping it from a 5.

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 first sentence is dense, front-loaded, and does the real work. The remainder is a single run-on block where payment terms, identity proof, and token fee are interleaved; the identity/wallet attribution is promotional filler that does not help an agent decide or invoke.

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, read-only, single-parameter tool with no output schema, the description covers the input format, the metrics returned, freshness, sourcing, and cost — enough to call it correctly. Only the fee/identity boilerplate is surplus relative to that 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 schema already documents the symbol format and BTC default, so the baseline is 3. The description's "Input: market, e.g. {\"market\":\"ETH\"} (default BTC)" restates the schema with a concrete call example but adds no new semantics such as accepted casing or unsupported symbols.

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 opening clause names a specific resource and verb-like framing ("What holding a Hyperliquid perp costs now") and enumerates the exact outputs: hourly/annualized funding, who pays, 24h/7d averages, predicted funding, OI, volume, mark vs oracle premium. This clearly separates it from siblings like funding_arb_scan (cross-venue arb discovery) or hl_quick_trade_idea (trade suggestions).

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 by the framing ("what holding costs now") rather than stated, and no sibling is named as an alternative or excluded. An agent can infer this is a point-in-time funding lookup, but nothing tells it when to prefer this over funding_arb_scan or hl_quick_trade_idea.

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 readOnlyHint and openWorldHint, and the description adds meaningful operational context: latency under a minute, coverage limited to ~420 large accounts rather than all positions, and a 1.1 USDC per-call x402 payment requirement. It is transparent about cost and data limitations, though it does not describe output shape or failure 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 first sentence is well front-loaded and informative, but the description is bloated by promotional identity verification, token fee details, wallet addresses, and endpoint URLs that do not help an agent decide to invoke the tool. Much of the latter half does not earn its place in a tool definition.

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

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

There is no output schema, but the description explains the returned concept (estimated liquidation levels in % buckets, biggest clusters highlighted), the data source limitation, latency, and payment requirement. That is enough for correct invocation, with only return-field structure left vague.

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 asset, rangePct, and bucketPct including defaults and bounds. The description repeats the parameter names and gives one example, but adds no semantics beyond what the schema provides, making the baseline 3 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 states a specific resource and output: estimated long and short liquidation levels in % buckets around a Hyperliquid perp's mark price, with biggest clusters highlighted. It is clearly distinguishable in substance from siblings like hl_funding_snapshot or hl_smart_money, but it never names or routes against those alternatives, so it falls short of a 5.

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 through the input example and the note that results come from ~420 large accounts, but there is no explicit when-to-use guidance or comparison to alternative liquidation/smart-money tools. An agent can infer the use case, but selection guidance is thin.

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 only declare readOnly and openWorld; the description adds real operational context — advisory-only with no order placement, roughly seconds of latency, one coin per invocation, and per-call payment of 0.28 USDC via x402 at a named endpoint. That is meaningful disclosure beyond structured fields, though it omits failure modes (unsupported coins, stale data).

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 first sentence is excellent and front-loaded, but more than half the text is promotional: a 10% fee earmark to a token contract address, ERC-8004 agent ID, two verification URLs, and payout wallet address. Only the x402 payment line earns its place operationally; the rest crowds out the signal.

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 does the necessary work by enumerating the returned fields and caution/funding flags, and it covers inputs, latency, and cost. It is essentially complete for a one-parameter advisory tool, lacking only edge-case 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% and the single parameter is already documented with examples, so the bar is low. The description restates the input as {"coin":"BTC"} and clarifies "no discretionary or news input," confirming coin is the only lever — marginal but consistent 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 opening sentence names a specific verb and artifact — a rules-based Hyperliquid perp setup — and enumerates exactly what it returns (side, entry zone, stop-loss, TP1/TP2, R:R) plus the inputs it derives from (1h/4h trend, ATR, swing structure, funding). This clearly separates it from siblings such as hl_funding_snapshot or token_technical_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?

"One coin per job, no discretionary or news input; advisory only, no orders placed" sets the scope and rules out misuse, and "Seconds" signals it is the fast path. However, it never names an alternative or states when an agent should prefer trade_strategy_consult or token_technical_analysis instead, so sibling routing is left to inference.

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 readOnlyHint=true and openWorldHint=true, and the description adds real behavioral context: positions are read live, the trader list refreshes hourly from the public leaderboard, latency is seconds, and each call costs 1.1 USDC via x402 at a stated endpoint. The wallet/identity verification and token-fee prose is self-attestation rather than tool behavior, so it does not push this to a 5. No contradiction with the read-only annotation.

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 first sentence is well front-loaded and does the real work, but it is followed by payment details, a token contract address, ERC-8004 agent ID, a Virtuals ACP URL, truncated payout wallet, and a per-call price. That is roughly two-thirds of the text devoted to promotion and identity proof rather than helping an agent decide or invoke correctly.

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

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

There is no output schema, and the description compensates by naming what is returned (aggregate long/short totals plus per-coin bias) and how fresh it is. With a single required parameter and read-only annotations, an agent has what it needs; only the shape/format of the response remains underspecified.

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

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

Schema description coverage is 100% and the schema already explains that scope takes 'all' or a perp symbol like BTC. The description's 'Input: scope "all" or a coin, e.g. {"scope":"BTC"}' restates that without adding format, validation, or failure behavior (e.g. what happens for an unknown symbol). Baseline 3 is correct.

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 opening sentence names a specific verb+resource: live long/short totals and per-coin bias across the top 60 Hyperliquid traders ranked by 30-day PnL. That is concrete enough to distinguish it from generic siblings like hl_top_movers or market_scan_report. It never explicitly contrasts itself with close siblings such as hl_trader_copy_check, so it stops short of a 5.

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 only implied through the input example ({"scope":"BTC"} vs "all"), which tells the agent how to narrow but not when this tool beats hl_trader_copy_check or position_health_check. There is no when-not-to-use guidance or prerequisite statement; the reader must infer the framing from the purpose sentence.

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 cover read-only safety, but the description adds genuinely useful behavioral context: the data is live public HL API with a timestamp, responses return in seconds, results are constrained to $1M+ daily volume, and output is market data only. Most importantly it discloses that each call is paid (0.28 USDC on Base via x402) and pins the endpoint — a critical precondition an agent must know before invoking.

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 first sentence is an excellent, front-loaded summary. But the remainder is dominated by promotional and identity material — GHOST77 token address, ERC-8004 agent number, Virtuals ACP link, payout wallet, fee set-aside — that does not help an agent select or invoke the tool. Roughly two-thirds of the text does not earn its place in a tool definition.

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 carries the return-value burden, and it does reasonably well: it enumerates the sections returned (gainers, losers, volume leaders, funding extremes, breadth, BTC move) plus a timestamp. It does not describe response shape or field names, but for a read-only snapshot that is an acceptable gap.

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

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

Schema coverage is 100%, so both parameters (window enum, limit 3-25 with default 10) are already fully documented, establishing a baseline of 3. The description restates the window and limit range and gives a worked example payload, which helps but adds no semantics the schema lacks (e.g., what counts as a 'row' or whether limit applies per list independently).

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?

Opens with a concrete scope statement: 'top 24h gainers and losers, volume leaders and funding extremes across perps with $1M+ daily volume, plus breadth and the BTC move.' An agent can tell this is a Hyperliquid market-overview aggregator, distinct from siblings like hl_funding_snapshot or hl_smart_money. It stops short of naming those siblings as alternatives, so it lands at 4 rather than 5.

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 phrase 'at a glance' implies a survey/overview use case, and the $1M+ volume qualifier signals it is for liquid perps only. However, there is no explicit when-to-use vs when-not guidance and no routing to sibling tools such as hl_funding_snapshot for deeper funding detail. Usage is inferable but not stated.

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

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

Annotations already declare readOnlyHint and openWorldHint, and the description goes well beyond them: it discloses the 1.1 USDC x402 payment on Base, the public Hyperliquid data source capped at 10,000 recent fills, expected latency, and a non-advice disclaimer. It does not say what happens for addresses with no or sparse fills, so failure behavior is left uncovered.

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 metrics list and input example are front-loaded and efficient, but the tail is heavily padded with promotional material: a 10% fee diversion to the GHOST77 token contract, an ERC-8004 agent ID, Virtuals ACP links, and payout-wallet matching. None of that helps an agent decide or invoke the tool, and it roughly doubles the description length.

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 carries the full burden of describing return values, and it does so by enumerating every reported metric including a composite score. Combined with the disclosed data source, fill cap, cost, and latency, an agent has everything needed to call this correctly.

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

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

Schema coverage is 100% for the single required address parameter, so the baseline is already high; the inline example {"address":"0x..."} adds a concrete call shape and reinforces that exactly one address (not a list) is accepted. No further semantics (e.g., case sensitivity, chain scope) are added beyond the schema pattern.

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 opening question plus the enumerated output set (account value, PnL net of fees, win rate, drawdown, 0-100 copy-ability score) makes the verb and resource unmistakable: a per-trader copy-trading evaluation on Hyperliquid. It is implicitly distinct from hl_smart_money and hl_quick_trade_idea, but never names or contrasts with those siblings, so an agent must infer the boundary.

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 only implied by the framing question and the input example; there is no explicit statement of when to prefer this over hl_smart_money, position_health_check, or hl_quick_trade_idea, and no indication of when it is inappropriate (e.g., a fresh address with no fill history). The 'seconds' latency hint and the 10,000-fill cap are useful context but are not routing guidance.

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

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

Annotations already cover read-only/open-world, but the description adds real behavioral context beyond them: expected latency ('Seconds'), explicit scope limits (no historical OI, no liquidations, no orders), and crucially the payment/auth model (0.55 USDC on Base via x402, payTo wallet). Some of that surface is token/identity marketing rather than invocation-relevant, which keeps it below a 5.

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 first two sentences are well front-loaded with purpose and input. The remainder drifts into fee/token-address, agent-identity verification, and payout-wallet details, which bloat a single dense paragraph; only the x402 pricing line clearly earns its place.

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

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

For a one-optional-parameter tool with no output schema, the description does the necessary work by enumerating the returned fields (prices, funding, OI, volume, watchlist candidates, sources, timestamp, limits). Missing only how large the 'limits' are or how the watchlist is chosen.

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 single enum parameter is fully documented in the schema, so baseline is 3. The description repeats the enum values and adds a concrete example ({'focus':'major'}), but it never explains what 'funding-arb' actually changes in the output, so it adds only marginal meaning.

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

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

The description names a specific verb and resource ('a quick read of Hyperliquid's perp market') and enumerates exactly what is returned: mark prices, funding, open interest, 24h volume, plus up to three funding-watchlist candidates. It is clearly distinguishable from narrow siblings such as hl_funding_snapshot or hl_top_movers by its breadth, though it never names an alternative explicitly.

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 says 'A quick read' and 'Seconds', implying a fast snapshot use case, and it does give exclusions ('no historical OI or liquidations, no orders'). But it never tells the agent when to prefer it over funding_arb_scan, hl_funding_snapshot, or daily_bundle, leaving sibling routing to inference.

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 readOnlyHint/openWorldHint the description adds real operational context: sub-second-ish latency, scope exclusions (no PnL history, cannot guarantee stop coverage), that it changes nothing, and that it is a paid per-call endpoint at 0.28 USDC on Base via x402 at a specific URL. It stops short of 5 because "with sources, timestamp and limits" is vague about what limits means and the payment/identity block mixes promotional content into 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?

The purpose and scope are front-loaded, but the body then spends several sentences on token-fee economics (GHOST77 0xC434...), ERC-8004 agent #348263, Virtuals ACP IDs and payout wallet addresses. That identity/monetization material does not help an agent decide to call the tool and dilutes the actionable parts.

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 does the work of listing returned fields (positions, margin utilization, liquidation distance, trigger orders) plus sources and timestamp, and it discloses cost, latency and read-only behavior. An agent has enough to call it correctly; only the exact semantics of trigger-order coverage and "limits" remain fuzzy.

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 walletAddress and the optional tokens filter are already fully documented with patterns and a default-omitted behavior. The description only echoes the input names and adds a trivial example object, no new semantics. 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?

Opens with a specific framing ("How close a Hyperliquid account is to trouble") and enumerates the concrete outputs: open positions, margin utilization, liquidation distance, observed trigger orders. It is clearly a position-risk snapshot rather than a market scan or a trade idea, which separates it from most siblings. It doesn't name a nearest alternative (e.g. hl_liquidation_map or wallet_watch_alert), so it stops short of 5.

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?

"Read-only snapshot: no PnL history, cannot guarantee stop coverage" functions as a when-not signal, and "Seconds" implies a lightweight call. But there is no explicit statement of when to prefer this over hl_liquidation_map, base_protocol_health, or wallet_watch_alert. Usage is implied rather than directed.

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

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

Beyond the readOnly/openWorld annotations, it discloses runtime behavior and operational context: about one minute, automated public sources with flagged gaps, informational-only status, per-call pricing of 0.83 USDC via x402, the payment endpoint, and fee/identity provenance. These are meaningful execution and trust details with no contradiction of the annotations.

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

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

The purpose and input details are front-loaded and the payment line is useful. However, the description is lengthy and includes promotional/provenance details such as the 10% fee supporting GHOST77, identity verification links, and payout wallet information that are not necessary for selecting or invoking 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?

There is no output schema, but the description effectively defines the report contents the agent will receive. It also covers latency, data provenance, limitations, disclaimer, payment protocol, and endpoint, which is enough to decide whether and how to call the tool.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema. The description repeats the accepted input forms and adds a concrete example, but it does not add constraints or semantics 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?

It states a specific resource and deliverable: a crypto project research report covering what the project does, team/backers, tokenomics, on-chain and market data, news, risks, and a verdict. The agent can tell what it produces, but the description does not explicitly differentiate it from sibling research tools such as contract_research or token_due_diligence.

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

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

The description gives clear usage context with 'Understand a crypto project fast' and explains accepted inputs such as project name, ticker, token address, and optional chain. It does not state exclusions or explicitly route the agent away from overlapping siblings, but the intended use case 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?

Annotations declare readOnly and openWorld, but the description adds materially useful context beyond them: latency ('under a minute'), a paid-per-call model (0.28 USDC via x402 at a specific endpoint), and a tracked-protocols-only constraint. This goes well past what the annotations convey, though the identity/wallet boilerplate dilutes 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 metric enumeration is front-loaded and earns its place, but the tail end balloons with ERC-8004/Virtuals identity verification, two URLs, and a payout wallet address that add little to the invocation decision. Payment info is relevant; the verified-identity block is bloat.

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

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

For a paid, read-only, single-param tool with no output schema, the description covers the returned fields, coverage limits, latency, and payment mechanics. An agent has enough to decide and invoke correctly; only explicit sibling routing 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 100% and already documents 'DefiLlama protocol name or slug'. The description adds a concrete example ({"protocol":"aave"}) and reinforces the slug/name convention, which is marginal value over the schema. Baseline 3 is appropriate for full-coverage single-param tools.

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?

Specific verb+resource: returns a DeFi protocol health snapshot, and enumerates exactly what it contains (TVL with 1d/7d/30d change, fees/revenue, fees/TVL, revenue share, mcap/revenue, past hacks). This clearly delimits it from research-oriented siblings, though it never names base_protocol_health or another alternative to sharpen the distinction.

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 an input example and a coverage constraint ('Only protocols DefiLlama tracks'), which implies when it applies. But there is no explicit when-to-use/when-not guidance relative to siblings like base_protocol_health or token_due_diligence, so the agent must infer the 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 only declare readOnlyHint and openWorldHint, and the description adds substantial context beyond them: x402 payment of 0.11 USDC on Base with the POST endpoint, sub-minute runtime, a 10% fee set aside, and an explicit statement that results are not proof of safety or financial advice. That is exactly the kind of operational detail annotations cannot carry.

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 first two sentences are dense and front-loaded with purpose, inputs and outputs, which is good. But the tail is heavy promotional boilerplate — GHOST77 token address, ERC-8004 agent ID, Virtuals ACP link, payout wallet — that does not help an agent decide or invoke; only the payment line has operational 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 two-parameter read-only tool with no output schema, the description covers input format, expected output ('risk level, red flags, plain verdict'), cost and latency. It does not say what happens for an unsupported network or an unrecognized contract, which is the main remaining gap.

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

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

Schema description coverage is 100% and the network enum is enforced, so the schema already carries the parameter meaning. The description restates the two inputs and adds a concrete example payload, which is mild incremental value — the 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?

States a specific verb and resource: a fast rug/honeypot screen listing exactly what it checks (buy/sell simulation, taxes, owner powers, liquidity, LP lock, top-10 holders). The 'quick check / not an audit' framing implicitly separates it from heavier siblings like token_due_diligence or contract_security_scan, but no sibling is named outright.

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?

'For buyers checking a token before trading' gives a clear usage context, and 'Limits: automated, not an audit; a clean result is not proof of safety' sets an explicit boundary on how much to trust it. No alternative tool is named for deeper analysis, so the agent must infer that from sibling names.

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

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

Annotations declare readOnlyHint=true and openWorldHint=true, and the description is consistent with both. It adds real behavioral context that annotations cannot convey: latency under a minute, coverage limits, an explicit insufficient-evidence failure mode, and per-call cost (2.2 USDC via x402). The token-fee and identity paragraphs are promotional rather than behavioral, which keeps it from a 5.

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?

Operational content is front-loaded correctly, but roughly half the text is promotional and identity boilerplate (10% fee for the GHOST77 token, contract address, ERC-8004 agent number, Virtuals ACP link, payout wallet). None of that helps an agent decide to call or how to call, and it buries the one useful payment fact (2.2 USDC on Base).

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 correctly spells out what comes back — sentiment, observed catalysts, source URLs, timestamp, coverage limits, and the insufficient-evidence case — and discloses the x402 payment requirement, which an agent needs before invoking. Only sibling routing 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 100%, so both parameters are already documented, and the description adds only a JSON example plus 'includeX adds public X results when available' — which largely restates the schema's 'Include X/Twitter search (default true).' Baseline 3 applies since the schema carries 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?

Opening sentence states a specific verb and resource: check whether public evidence supports a bullish or bearish story. It also names the artifacts returned (qualified sentiment, catalysts, source URLs), which separates it from pure-news tools like crypto_news_digest. However, it never names a sibling tool to differentiate from project_research_report or token_due_diligence, so the reader must infer the boundary.

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 a concrete input example and a scope constraint ('public web/news search only; no private feeds'), which implies when it fits. But there is no explicit 'use this instead of X when Y' routing despite a crowded sibling set of research/analysis 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?

Beyond the readOnly/openWorld annotations, the description discloses genuinely operationally important facts: it is a paid call (3.3 USDC via x402 on Base at a specific POST endpoint), it finishes 'under a minute', and results are explicitly partial. That is strong added value, though a substantial share of the text is identity/fee-disclosure marketing rather than behavior the calling agent needs.

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 core screening sentence and the input example are correctly front-loaded, but the definition then runs on through fee set-aside, ERC-8004 registration number, Virtuals ACP link and payout wallet address. Those sentences serve operator credibility more than tool selection and dilute an otherwise tight definition.

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 compensates by listing the payload contents (flags, liquidity, social evidence, sources, timestamp, CAUTION/ALERT verdict) plus latency and cost. Caveats about partial coverage are present; only the exact structure/format of the verdict field is left implicit.

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

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

Schema coverage is 100% and the schema already documents both parameters including address formats and the chain enum. The description only restates the two field names and adds one example payload, which is marginally useful but not meaningfully 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 opens with a specific verb and resource ('Screen a token for red flags') and enumerates exactly what the screen returns: risk flags, DEX liquidity, social/web evidence, sources, timestamp and a verdict. It never names or differentiates itself from close siblings such as rug_honeypot_quick_check or contract_security_scan, so an agent must infer which screening tool to pick.

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 context is stated plainly ('before you touch it') and a clear limitation is given ('Partial automated screen; cannot certify safety or audit status'), which tells the agent this is a pre-trade triage step, not a certification. It gives no explicit when-not conditions or named alternatives among the many screening siblings.

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

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

Annotations already declare readOnlyHint and openWorldHint, yet the description adds genuinely non-obvious behavior: sub-minute latency, degraded results in thin markets, and a paid 0.55 USDC x402 invocation with a stated payee. That payment detail is essential for an agent to invoke it successfully. It loses a point because the fee-subsidy and identity-verification block is closer to promotion than 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?

It is well front-loaded: capability, input example, constraints, then commercial terms. But a sizeable share of the text is the 10% fee disclosure, token contract address, and dual-agent identity verification with two URLs and a payout wallet — none of which helps an agent select or call 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?

With no output schema, the description correctly carries the burden by enumerating the analytic outputs an agent will receive, and it discloses cost and the payment channel needed to execute. What is missing is any sense of response shape or handling of partial data beyond the thin-market warning.

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 three parameters, and the enum supplies the timeframe values. The description's contribution is a concrete invocation example — useful but marginal, and the listed timeframes merely repeat the enum. 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 names a concrete resource and enumerates exactly what is returned: trend, support/resistance, RSI, MACD, moving averages, volume and a bias summary. That is far more informative than the title. It does not, however, explicitly distinguish itself from close siblings like token_due_diligence or contract_research, so an agent must infer the boundary.

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 scopes usage by exclusion — 'Indicators only (no order-book or on-chain flow)' — which tells the agent when this tool is the wrong pick, plus a data-quality caveat for thin markets. It stops short of naming the sibling tool to use instead when those inputs are required.

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 only declare readOnlyHint and openWorldHint; the description adds substantial context beyond that: x402 paid-per-call pricing (0.22 USDC on Base), a stated latency ceiling, dataset coverage limits (unknown projects declined before payment, no invented data, schedules may change), a fee disclosure, and verifiable operator identity. Nothing contradicts the read-only annotation, since this is a paid query, not a mutation.

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 purpose and output scope are front-loaded effectively in the first clause, but the tail is dense: fee disclosure, two verification URLs, wallet addresses, and the raw x402 endpoint inflate length considerably. Much of that is defensible for a paid endpoint, yet it crowds out tighter phrasing and could be structured as clearly separated sections.

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

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

There is no output schema, and the description compensates fully by itemizing return contents (dated cliff and linear unlocks by recipient group, token and USD amounts, % of max supply, airdrop/claim unlocks, news links). Combined with stated input bounds, latency, and payment mechanics, an agent has everything needed 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?

Schema description coverage is 100%, so both parameters are already documented with constraints and examples. The description's 'Input: project, optional days_ahead' plus the JSON example merely restates schema content and adds no new syntax, slug-matching rules, or defaulting behavior beyond what the schema provides.

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

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

States a specific verb and resource — upcoming token unlocks for a single project over a 7-365 day window from DefiLlama's emissions dataset — and enumerates what the output covers (cliff/linear unlocks, recipient groups, USD value, % of max supply, airdrops). That is clearly distinct from siblings like token_due_diligence or token_technical_analysis, so an agent can pick it without opening the schema.

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?

Names the audience and selection context ('for holders and researchers sizing supply risk') and gives a concrete usage example with parameters. It also states an exclusion — projects not in the dataset are declined before payment — but never names a sibling alternative for adjacent questions, so it falls short of a full when/when-not/alternative treatment.

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

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

The description adds substantial behavioral context beyond the annotations: it discloses that the tool is advice-only, does not execute trades, takes about a minute, draws from live Hyperliquid candles/funding/OI, and is paid per call at 3.3 USDC on Base via x402. These details are critical for an agent deciding whether and how to invoke it, and the non-execution claim is consistent with readOnlyHint=true.

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 paragraph is front-loaded with the tool's core purpose and output list, followed by input names, duration, disclaimers, fee note, identity verification, and endpoint. Most content earns its place, though the token-fee and identity-verification details are somewhat promotional rather than essential to correct invocation.

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 carries the burden of explaining what comes back, and it does so thoroughly: decision state, entry zone, stop, TP1/TP2 with R:R, position size, leverage cap, liquidation estimate, and invalidation. It also covers data sources, duration, non-execution, and payment, making the definition complete 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?

Schema description coverage is 100%, so the input schema already documents all six parameters in detail, including enum meanings and risk-sizing mappings. The description lists the same inputs (marketThesis, capitalUsdc, riskTolerance, optional market, horizon, direction) but adds little beyond what the schema provides, so 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 gives a specific verb and resource: 'Turn your market view into a risk-sized perp plan,' and enumerates the outputs (ENTER/WAIT/NO_TRADE, entry zone, stop, TP1/TP2, size, leverage cap, liquidation estimate, invalidation). This clearly distinguishes it from generic trade-idea or market-scan siblings, though it does not explicitly name any alternative 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?

Usage context is implied by the description: it is for converting a market thesis into a risk-sized perp plan, takes about a minute, and is advice-only with no execution. However, it does not state when to choose it over closely related siblings such as hl_quick_trade_idea or position_health_check.

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 only declare readOnly and openWorld; the description adds substantial undisclosed traits: pay-per-call pricing (0.11 USDC via x402 at a named endpoint), latency ('under a minute'), coverage limits (15-18 major tokens on Base/Ethereum, native ETH only on Ethereum), one-shot rather than streaming, and output shape. That is rich context beyond the annotations.

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

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

Purpose, limits and output are front-loaded and earn their space, but the trailing block on ERC-8004 agent identity, Virtuals ACP, payout wallet and token fee is promotional noise relative to invoking the tool. The definition is usable but over-long.

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 steps in to describe the return (priced events in USD, per-chain coverage, HL positions). Combined with cost, latency, coverage limits and an example call, an agent has everything needed to invoke correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description reinforces semantics with a concrete invocation example and restates the chains/lookback/min_usd dimensions. It doesn't add per-parameter defaults beyond the schema, so it stays short of a 5.

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 a specific verb+resource: large buys, sells, bridges and transfers by one address on three named chains over a bounded lookback, plus Hyperliquid positions and fills. An agent can distinguish what this returns versus a general market scan or smart-money feed without opening the schema.

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 opening 'For traders and agents tracking a wallet' and the 'one-shot check, not a live feed' caveat give usage context and an exclusion. However, no sibling is named and the closely related hl_smart_money and hl_trader_copy_check are not contrasted, so the agent must infer which wallet-tracking tool to pick.

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