1gateway

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

With no annotations, the description carries the full behavioral burden. It discloses rich output details (current/next base fee, priority tiers, cost per action in ETH and USD), the data source for tiers ('last 20 blocks'), and the access cost ('$0.002 USDC via x402'). It does not explicitly state read-only safety or rate limits, though these are strongly implied by 'Input: none' and the estimation nature.

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

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

The description is front-loaded with the usage condition, then input, output, and a concrete example. Every sentence adds necessary information; the output list is dense but justified because no output schema is provided.

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

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

Given the absence of an output schema and annotations, the description fully explains return values, input expectations, data freshness, and pricing. An agent has everything needed to call and interpret 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?

The tool takes zero parameters, so the baseline is 4. The description confirms 'Input: none', which is sufficient given the empty input schema.

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

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

The description states a specific verb and resource: 'price or time a Base transaction', and then enumerates the exact output fields (base fee, priority tiers, cost per action). It is clearly distinct from all sibling tools, none of which perform gas/fee estimation.

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 usage condition: 'Use when an agent must price or time a Base transaction.' No alternatives are needed because no sibling tool covers this purpose, but the description lacks explicit when-not guidance (e.g., for non-Base chains).

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

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

With no annotations, the description carries the full burden and does so: it discloses that the call is paid ($0.05 USDC on Base or Solana via x402), that limits are checked before payment, that failures (4xx/503) are not charged, that the tx is confirmed before settling, and that daily caps are 5 ETH/address and 20 overall. That is unusually complete disclosure of cost, failure, and rate-limit 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?

Front-loaded with "Use when..." and compact at roughly four sentences. It is dense — price, limits, output fields, and example are all packed in — but nearly every clause carries decision-relevant information, so it escapes being verbose.

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

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

Despite having no output schema, it enumerates the return fields (txHash, explorerUrl, amountEth, from, to) and notes confirmation-before-settlement. Combined with the disclosed pricing, caps, and failure semantics, an agent has everything needed to invoke and interpret the result.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds value by restating the recipient semantics and giving a concrete query example (?to=0x...dEaD), which conveys the checksum-style formatting and the call shape beyond the schema text.

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 (sends 0.1 ETH of Base Sepolia test ETH) plus the primary use case (agent, x402 test, CI job needing gas). It also distinguishes itself from the 1 ETH sibling by naming the alternate path /v1/testnet/base-sepolia-eth/1, so an agent can pick the right one without opening a 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?

"Use when an agent, x402 test or CI job needs Base Sepolia gas now" gives a clear triggering condition, and "no faucet login or mainnet history" positions it against the obvious alternative. It doesn't explicitly say when NOT to use it (e.g., versus sepolia_eth on a different chain), which keeps it just under a 5.

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

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

With no annotations, the description carries the full burden and does so: it discloses the x402 payment model and price ($0.50 USDC on Base or Solana), that the tx is confirmed before settling, the daily limits (5 ETH per address, 20 overall, UTC) checked before payment, and that test ETH has no monetary value. The schema adds that failed preconditions return 4xx/503 without charging. That is unusually complete for a payment-bearing mutation tool.

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

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

Dense and front-loaded — the usage trigger leads, followed by input, output, limits, and price in a logical order with zero filler sentences. It is a run-on chain of clauses rather than cleanly structured prose, and the parenthetical '(bulk)' in the title is never explained in the body.

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 enumerates the return payload (txHash, explorerUrl, amountEth, from, to) and covers cost, limits, and settlement behavior. What remains unaddressed is what happens if payment succeeds but delivery later fails, and whether repeated calls are idempotent — a meaningful gap for a paid tool, but not one that blocks correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds value by framing the single parameter as 'Input: to (recipient address)' and supplying a concrete example (?to=0x...dEaD). It does not restate the EIP-55 checksum requirement or the uncharged-failure behavior, but those are already in the schema.

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

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

States a specific action (sends 1 Base Sepolia test ETH to a recipient) and the exact denomination, which distinguishes it from the generic sibling names base_sepolia_eth / sepolia_eth. It hints at sizing ('both sizes', 'bulk') but never explicitly names the sibling that covers a different amount, so differentiation is inferential rather than stated.

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?

Opens with a concrete trigger list (contract deploys, x402 tests, CI jobs needing more gas than a faucet gives) and contrasts with the faucet alternative ('no faucet login or mainnet history'). It gives clear when-to-use context but stops short of naming which sibling tool to pick when 1 ETH is too little or too much.

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

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

With no annotations, the description still discloses the pricing/payment requirement ($0.004 USDC via x402), the truncation behavior ('busy tokens get a shorter window'), and the output contents. Error semantics (400/422) live in the schema rather than the description, which is a minor gap for a paid call.

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-loaded with the use case, then input/output contract, then an example — every block earns its place. The trailing price/example line is slightly noisy but not wasteful.

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

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

No output schema exists, yet the description enumerates the return fields well enough to set expectations. The only soft spots are the payment mechanics and truncation details, which are stated but thinly explained.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds range constraints absent from the schema (minutes 1-60, limit 1-25) and repeats the default window. It omits the limit default of 10 that the schema states, a small inconsistency.

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 concrete verb and resource: seeing who is accumulating or dumping a Base ERC-20, with the outputs (net buyers/sellers, whale transfers) spelled out. It is clearly distinct from base_token_info/risk in spirit, but never names a sibling to route the agent 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 opening 'Use when an agent must see who is accumulating or dumping ... right now' gives a clear trigger condition. It stops short of saying when not to use it or which sibling (base_token_risk, base_token_info) handles adjacent questions.

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

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

No annotations, so the description carries the full burden. It discloses error behavior (4xx for EOA/non-ERC-20, not charged), that name/symbol are self-reported, and includes pricing/payment method. Missing rate limits or caching details, but strong for a read-only tool.

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

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

Well-structured and front-loaded: use case, inputs, outputs, errors, example, price. Dense but no wasted sentences; the example and price are useful for 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?

For a tool with no output schema, the description enumerates output fields and error codes, and specifies pricing. An agent has everything needed to call and interpret it.

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

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

Schema description coverage is 100%, so baseline 3. The description restates the same parameter roles (holder adds balance/share, spender adds allowance) and adds 'flags unlimited approvals' which is output behavior rather than parameter semantics. Limited added value beyond schema.

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

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

States a specific verb (get) and resource (ERC-20 basics on Base) and scopes it to before quoting/transferring/approving. It implicitly distinguishes from siblings like base_token_risk and base_token_flows by focusing on static metadata rather than risk or flows.

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

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

Provides a clear when-to-use ('before quoting, transferring or approving'), but does not name alternatives or when-not-to-use. Clear context but no exclusions.

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

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

With no annotations, the description carries the full burden and does so well: it discloses the output shape (JSON signals with block+evidence), the specific signals tested, the crucial caveat 'signals, not a safe verdict,' the failure mode (400 on bad input/EOA, not charged), and the payment model (x402, $0.009). This is unusually rich behavioral context for a read-only tool.

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

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

Front-loaded with purpose, then usage, input, output, caveat, errors, and example in a logical order with no filler sentences. It is densely packed and the price/payment clause sits a bit awkwardly at the end, keeping it from a 5.

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, so the description must explain returns, and it does: the block+evidence JSON structure, the signals covered, the notChecked field, and the caveat that results are signals rather than a verdict. Error and cost handling are also covered, leaving nothing essential for correct invocation 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?

Only one parameter with 100% schema coverage, so the schema already documents address format, checksum, and the 400/not-charged behavior. The description's 'Input: address' and example add a usage example but little semantic detail beyond the schema, 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?

States a specific verb and resource ('Base ERC-20 token risk scan') and enumerates the concrete checks (honeypot, rug pull, scam check). This clearly distinguishes it from siblings like base_token_info (metadata) or base_token_flows (transfers), so an agent can route 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?

'Use when vetting a token' gives a clear use context, and the description implies this is the risk-assessment step of token analysis. However, it never names alternatives or states when NOT to use it (e.g., vs base_token_info), so it stops short of explicit 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?

With no annotations, the description carries the full burden and delivers: success/reverted semantics, block time, confirmations, fee split into L2 gas and L1 data fee, decoding capped at the first 25 transfers, and 404-without-charge for unknown or unmined hashes. It also discloses cost and payment rail (x402, USDC on Base/Solana), which an agent needs before calling.

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-loaded with the trigger, then Input/Output/Edge/Example/Price in telegraphic form; nearly every clause carries information. It is slightly dense and the pricing sentence is a separate concern, but nothing is redundant filler.

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

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

No output schema exists, so the description must describe return values and it does so in detail, including the decoded ERC-20 transfer cap and error behavior. Combined with the pricing note, an agent has everything needed to call and interpret this single-parameter tool.

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

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

Schema coverage is 100% with a single required parameter, so the baseline is 3 and the schema does the heavy lifting. The description adds value beyond it by restating the input shape, supplying a concrete example hash and query-string usage, and reinforcing the 404/not-charged behavior on unmined or unknown hashes.

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 (confirm a Base transaction/payment) plus the exact facts returned: success/reverted, payer/payee, token and amount. This cleanly separates it from siblings like base_token_flows or base_wallet_balances, which cover aggregate flows or balances rather than a single transaction's status.

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

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

Opens with an explicit trigger condition ('Use when an agent must confirm a Base transaction or payment landed'), which is clear usage context. It does not name a sibling alternative or state when-not to use it (e.g. versus base_token_flows for multi-transfer history), so it stops short of a full routing guide.

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

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

No annotations exist, so the description carries the full burden and does well: it discloses the paid x402 model ($0.002 USDC), the error contract (bad input → 400, not charged), the scope limit (chain state only, no prices), and the exact output shape. Auth requirements and rate limits are not mentioned, 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?

Front-loads the trigger with a labeled Input/Output/Bad input/Example structure that scans quickly. It is dense with genuinely useful facts, though the pricing sentence and worked example are the closest thing to padding.

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 and no annotations, the description fully compensates: it specifies the return payload (block+time, ETH balance, per-token symbol/decimals/raw+decimal balance, nonce, isContract), the input constraints, error handling, and cost. 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 coverage is 100%, so the baseline is 3, but the description adds value the schema lacks by enumerating the actual default token set (USDC, EURC, USDbC, WETH, cbBTC, cbETH, wstETH) and repeating the 20-token cap alongside a concrete example call.

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: what a Base address holds (ETH + ERC-20 balances) in one call, and the title adds nonce and contract flag. It is unmistakably distinct from siblings like base_token_flows or base_token_info, though it never explicitly names an alternative to steer the agent.

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?

"Use when an agent needs what a Base address holds in one call instead of one RPC call per token" is an explicit when-to-use with the efficiency motivation. No when-not guidance and no sibling alternatives are named, so it stops short of a 5.

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

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

With no annotations, the description carries the full burden and does well: it discloses the 5 MB size cap, a 3-page-per-call limit, supported input transports (GET url vs POST multipart/raw/base64), the output shape, and a paid x402 requirement at $0.015 USDC on Base or Solana. Gaps are minor: nothing about failure modes, low-confidence pages, or what happens when a page limit is exceeded.

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-loaded with the use case, followed by limits, input forms, output shape, alternative, example and price — a sensible priority order. The prose is dense and slightly run-on (input/output/pricing compressed into one block), keeping it just short of 5.

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

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

No output schema exists, yet the description enumerates the return fields (JSON markdown, per-page confidence, warnings), plus constraints, transports, cost and the sibling alternative. An agent has everything needed to construct a correct call and to interpret the result.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds real value beyond the schema: it explains that files can be supplied via POST multipart 'file' or raw body, transports the two named parameters cannot express. It also restates the 5 MB limit consistently with the schema rather than contradicting it.

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: OCR of scanned PDFs and PNG/JPEG/WebP images into Markdown, with language scope (Korean/English) and table handling. It also explicitly separates itself from the sibling convert_to_markdown / /v1/convert/markdown for PDFs with selectable text, so an agent can route without opening a 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?

Opens with an explicit trigger ('Use when an agent must read text from a scan, photo or screenshot') and names the exclusion case ('PDFs with selectable text: use /v1/convert/markdown'), pointing to the alternative tool by path. When-to-use, when-not, and the alternative are all present.

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

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

With no annotations, the description carries the burden and does so well: it discloses free-plan size caps with the resulting 413 status, per-type pricing tiers, the USDC/Base-or-Solana x402 payment path, and the shape of the returned JSON. It omits failure modes beyond the size cap and gives no hint about what 'warnings' contains, 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?

Front-loads the use condition, then input, output, and price in a tight telegraphic block with no filler prose. The pricing information is stated twice (per-type table plus a $0.0027–$0.009 range) and the payment/x402 note is split across two sentences, which is minor waste.

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

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

No output schema and no annotations, yet the description names the return fields (markdown, title, pages, sourceType, warnings), all input modalities, limits, and cost. For a conversion tool with 4 params this is close to sufficient; the missing sibling differentiation and the sparse handling of HWP vs HWPX size limits are the remaining gaps.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning the schema lacks: url is fetched via GET, while files arrive by POST as multipart 'file', raw body, or JSON contentBase64 plus filename. That transport mapping is not derivable from the parameter docs alone.

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 concrete verb and resource set: convert web page, PDF, DOCX, or Korean HWP/HWPX into clean Markdown with tables preserved. The agent knows exactly what transformation happens. It does not, however, distinguish itself from sibling extractors like docs_extract or web_read, so selection still requires inference.

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?

"Use when an agent must read a document as clean Markdown" gives a clear triggering condition, and the listed input types narrow the scope. No when-not or named alternatives appear, so an agent facing web_read or docs_extract has no stated tiebreaker.

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

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

With no annotations, the description carries the load and does well: it discloses the data source (computed from contract state), the reward exclusion caveat, the block pinning, and the payment model ("$0.0045 USDC (Base or Solana) via x402"). It stops short of stating rate limits, caching, or failure behavior beyond the schema's 400 note.

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

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

Front-loads the trigger ('Use when...') then Input/Output/caveats, which is the right order. It is dense but mostly earns its space; the trailing price sentence is awkwardly fused with the example and reads as an afterthought.

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

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

No output schema exists, and the description compensates by enumerating every returned field (supply/borrow APY, utilization, supplied/borrowed, TVL, block) plus the sort key. Input space, cost, and caveats are all covered; only freshness/refresh cadence and aggregation semantics (e.g., is TVL per market or summed) are unstated.

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

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

Schema coverage is 100% and both parameters carry their own descriptions including the 400-before-payment behavior, so the description adds little beyond restating the allowed protocol and asset values. The '?asset=USDC' example is illustrative but redundant with the schema's 'default all' note. 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?

States a specific verb and resource — 'compare lending yields on Base' — and enumerates the exact protocols (Aave v3, Compound v3, Morpho, Moonwell) and assets covered. No sibling tool in the list touches DeFi lending yields, so the boundary is unambiguous.

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

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

'Use when an agent must compare lending yields on Base' gives a clear triggering condition, and 'base rates, rewards excluded; not advice' frames the scope. There is no explicit when-not clause or named alternative, but no plausible sibling overlaps, so the gap is minor.

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

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

With no annotations, the description carries the full behavioral burden and does so thoroughly: it lists input methods (GET URL, POST multipart/raw/JSON base64), output fields, refusal before payment on bad input or model outage, and pricing ($0.009 USDC via x402). This gives the agent a clear picture of cost, error handling, and return format.

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

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

The description is a single dense paragraph that front-loads the usage scenario, then covers input/output/errors/pricing. Every sentence is informative, though slightly more structure (e.g., bullets) could improve readability. No redundant filler.

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

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

For a complex document-extraction tool with no annotations and no output schema, the description covers the essential context: supported formats, input encodings, output fields, payment model, and failure behavior. It omits file size limits or timeout behavior, but those are minor for selection and invocation.

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

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

Schema coverage is 100%, so the two parameters are documented, but the description adds critical detail not captured by the schema: how to POST a file using multipart 'file', raw body, or JSON contentBase64+filename. It also gives an example URL query. This compensates for the schema's inability to represent POST body encodings.

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 ('extract') and resource (Korean HWP/HWPX, PDF, DOCX or web page) and distinguishes itself from plain text tools by requiring 'key facts, not just its text'. It also names the structured JSON output, making the purpose unambiguous against siblings like convert_to_markdown or web_read.

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

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

Provides a clear usage condition: 'Use when an agent needs the key facts of a document, not just its text.' It does not name alternative tools or explicitly state when not to use it, but the context is sufficient to select it over text-only readers.

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

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

With no annotations, the description carries the full burden and does well: it discloses the 'No contact data' limitation, the payment model ($0.0045 USDC via x402 on Base or Solana), and that URLs are normalized. It leaves out rate limits and error behavior beyond what the schema already states for reserved names.

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-loads the use case, then segments Input, Output, and Price so an agent can scan the relevant part. Every sentence (including the contact-data exclusion and cost) contributes 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 single-parameter lookup with no output schema, the description fully specifies the input, the return payload field-by-field, the cost and payment rails, and the 400/not-charged edge case. Nothing an agent needs to invoke it correctly 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 the schema already documents the single parameter in detail; baseline would be 3. The description adds a concrete example ('e.g. example.com; URLs accepted') and a sample query string, giving marginal extra value.

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

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

States a specific verb and resource ('check a domain') and enumerates the questions it answers: resolution, DNS/mail hosting, email authentication, age, expiry. No sibling tool overlaps, so an agent can select it 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 'Use when an agent must check a domain' plus the enumerated questions gives clear context for invocation. It doesn't state exclusions or point to an alternative, but the sibling list contains nothing comparable, so no exclusions are strictly needed.

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

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

With no annotations, the description carries the full burden and does substantial work: it discloses the SMTP limitation (mailbox itself is not verified), the refusal-before-payment behavior for malformed addresses, and the pricing/rails. It omits rate limits, latency, and what an unverified mailbox means for the verdict's reliability in edge cases.

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-loaded with the usage condition, then input, output, limits, error behavior, example, and price in compact order. Every clause is load-bearing for an agent deciding whether and how to call it.

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

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

No output schema exists, yet the description enumerates the verdict values and the fields returned (reasons, MX hosts, null MX, SPF/DMARC, disposable, role, free provider). For a single-parameter tool this is complete enough to call without further discovery.

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?

Single parameter with 100% schema description coverage, so the baseline is already high. The description adds an inline example ("?email=info@example.com") showing the exact query-string form and reinforces that only a well-formed address is accepted, which the schema does not state.

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 the specific resource and the exact checks performed (syntax, MX, null MX, SPF/DMARC, disposable domain, role account, free provider) plus the final verdict type (deliverable/risky/undeliverable). Nothing about the operation is left ambiguous, and the scope boundary (no SMTP mailbox probe) is stated 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?

"Use when an agent is about to email or sign up a contact" gives a clear triggering condition and is well matched to the tool's purpose. There is no explicit when-not guidance or named alternative, but among the sibling list no other tool overlaps on email validation, so the omission is minor.

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

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

With no annotations, the description carries the full burden and does well: it discloses the ECB source and 'reference only' caveat, weekend/holiday fallback to the prior fixing, the output shape (per-target inverse and converted result plus fixing date used), and the paid x402 access with a concrete price. Remaining gaps are minor: no batch-limit or error behavior, and no statement on how failures for unsupported currencies are reported.

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 trigger condition is front-loaded, followed by input/output/source/price in a compact, well-ordered sequence. It is dense and packs a lot into a few sentences, but nearly every clause carries information an agent needs.

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 no annotations, yet the description defines the return shape, the fixing date semantics, and the payment requirement, which are exactly the parts an agent cannot infer from the schema. Nothing material is missing for correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds marginal value by restating the 1–10 target limit, the amount default of 1, the date format constraint, the 'since 1999-01-04' floor, and an illustrative query string. It does not add much beyond the schema field descriptions, so not 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 and resource ('convert an amount between currencies') and pins the rate source to ECB reference rates, with date scope 'today or on a past date'. This clearly separates it from the sibling fx_rates (raw rates) and fx_history (time series), and gives an example 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 opening 'Use when you need to convert an amount between currencies' gives a clear trigger condition plus concrete examples (USD↔KRW, EUR→JPY). It does not explicitly name alternatives such as fx_rates or fx_history or state when not to use it, so it stops short of a 5.

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

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

With no annotations, the description carries the full burden and does substantial work: it discloses data provenance (ECB statistics), a 'reference only' reliability caveat, hard limits (1999-01-04 floor, 366-day max, 1-10 symbols), defaults, output contents, and even the payment model ($0.002 USDC via x402). It does not mention rate limits, error behavior, or whether non-business days are absent from the series.

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-loaded with the when-to-use clause, then input, output, source, example, and price — a sensible order with no wasted framing sentences. It is dense to the point of being a run-on, and the example's 2026 dates are an odd artifact, but every block carries information.

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

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

No output schema exists, yet the description enumerates the return payload (daily series plus per-currency first/last, % change, min/max with dates, average, daily volatility), and with no annotations it still covers limits, defaults, source, and cost. An agent has everything needed to construct a valid call.

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

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

Schema description coverage is 100%, so the baseline is 3; the description adds a little by restating defaults and limits in prose and by giving a worked query example (?base=USD&symbols=KRW,JPY&start=...&end=...) that shows how the parameters combine. It does not add format or semantic detail beyond what the schema already documents.

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

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

States a specific verb and resource — 'historical exchange-rate series or a period summary' — and the title/description pin the source to ECB daily fixings, which separates it from generic rate tools. It never names its closest siblings (fx_rates, fx_convert), so the agent must infer that this is the historical/series variant rather than the spot-conversion one.

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?

'Use when you need a historical exchange-rate series or a period summary' plus a concrete scenario ('USD/KRW over the last quarter') gives a clear selection signal. There are no explicit exclusions or named alternatives (e.g. 'for a single current rate use fx_rates'), so the boundary with siblings is left implicit.

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

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

With no annotations present, the description carries the full burden and does so: it discloses provenance (ECB statistics), update cadence (~16:00 CET each TARGET day), staleness bound (~90 days), weekend behavior (prior fixing), a reference-only disclaimer, and even the $0.002 USDC x402 cost. These are exactly the traits an agent cannot infer 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?

Front-loaded with the "Use when" trigger, then organized into Input / Output / Source / Example / Price blocks with zero filler sentences. It is slightly dense and mixes operational metadata (pricing, update time) into the same paragraph, but nothing is wasted.

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

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

No output schema exists, yet the description fully characterizes the return value (JSON rates for the fixing date, % change vs prior fixing, converted amounts, raw ECB EUR rates). Combined with source, freshness, and cost, an agent has everything needed to call and interpret it.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaning beyond the schema: the default base (EUR), the YYYY-MM-DD date format, the weekend prior-fixing rule for date, and a concrete query example (?base=USD&symbols=KRW,JPY&amount=100). That extra semantic context lifts it above the baseline.

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

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

States a specific verb+resource (fetch official daily FX rate / currency conversion), names the currency universe (30 ECB currencies incl. KRW, JPY, CNY), and is unmistakably distinct from every sibling (gas, token flows, weather, sanctions, etc.). An agent knows exactly what this returns 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?

"Use when you need an official daily FX rate or currency conversion" gives clear positive triggering context, and the description scopes the data to the last ~90 days. It does not name an alternative or an explicit when-not, but there is no competing FX sibling to route against, so the guidance is effectively complete.

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

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

With no annotations, the description carries the full burden and does substantial work: it defines the ranking statistic (current 1h funding vs the coin's last 7 days), names the mover windows (24h and 1h), and discloses cost/access ('$0.006 USDC (Base or Solana) via x402'). It omits rate limits, caching/refresh cadence, and explicitly stating this is a read-only 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?

Front-loads the use case, then inputs, then outputs, then an example and price — a sensible order with no filler sentences. The density is high and the example/price run together slightly awkwardly, but every clause carries 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?

There is no output schema, and the description compensates by enumerating the returned structure (as_of, fundingExtremes ranked by |z|, oiMovers24h, oiMovers1h, funding APR, OI USD). For a two-parameter read tool that is nearly everything an agent needs; only the sibling boundary and response size/pagination are unaddressed.

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 fully documented in the schema, including the default 10 and the 1-50 range. The description restates the range and default and clarifies that min_oi_usd filters markets out rather than ranking them, but adds no format or type guidance beyond the schema. 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: which Hyperliquid markets have funding far from their own 7-day norm (ranked by |z|) and where open interest is jumping. The framing 'Use when hunting crowded perps' makes the intent unmistakable. It loses the top mark only because it never names or distinguishes itself from overlapping siblings such as hl_funding_screener, hl_funding_history, and hl_perp_metrics.

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?

Opens with an explicit use condition ('Use when hunting crowded perps'), which is clear context for invocation. It does not state when NOT to use it or point to the alternative funding tools, so an agent must infer the boundary with hl_funding_screener itself.

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

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

With no annotations, the description carries the burden well: it discloses data provenance (5-minute snapshots), the 400-before-payment behavior for unlisted coins, and the x402 pricing ($0.004 USDC on Base or Solana). Missing only explicit read-only/no-side-effect confirmation, but the payment and error preconditions are genuinely useful behavioral context.

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

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

Front-loaded trigger followed by compact Input/Output/Example/Price blocks; every section carries signal. Slightly dense with pricing and example packed into one paragraph, but no wasted sentences.

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

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

No output schema exists, and the description fully enumerates the return shape: current 1h funding and APR, 24h/7d/30d averages, percentile and z-score, positive-hour share, downsampled series, and OI changes. An agent knows exactly what it gets and what it costs before calling.

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 params are already documented with symbol examples and the 24-720 default range. The description largely restates those ('hours (24-720, default 168)') and adds one useful nuance—statistics always cover 7/30 days regardless of window—so baseline 3 is appropriate.

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

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

Specific verb+resource with explicit scope: judging whether a perp's funding is unusually high/low and tracking open-interest build-up. The name and title align, and the funding/OI framing separates it from siblings like hl_funding_screener and hl_perp_metrics.

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?

Opens with a clear 'Use when...' trigger covering the two main analysis cases (funding extremes, OI build-up). It doesn't name alternative siblings or state when NOT to use it, so routing between hl_funding_history and hl_funding_screener 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?

With no annotations, the description carries the full burden and largely meets it: it discloses the return shape (as_of, cache_age_s, rows, top/bottom 5), signals that results are cached (cache_age_s), and states the access cost/mechanism ('$0.009 USDC via x402'), which is critical auth/payment context an agent cannot infer from the schema. It does not cover rate limits or refresh semantics, so it stops at 4 rather than 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?

Front-loaded with purpose, then usage, then input/output contracts, then a concrete example — a sensible order with no wasted sentences. The appended pricing sentence is useful but sits awkwardly at the tail after the example, which slightly muddies the structure.

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

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

There is no output schema, and the description compensates by enumerating the returned fields and envelope keys. Combined with the disclosed payment mechanism, an agent has enough to call it correctly, though cache/refresh semantics and failure behavior remain undescribed.

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

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

Schema coverage is 100%, so the schema already documents all seven parameters, and the description's parameter recap ('sort, order, limit (1-50), min_oi_usd, min_volume_usd, funding, min_abs_apr') largely repeats it. The one added detail is the example query string (?sort=funding&limit=20), which is marginal, so 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+scope: a funding-rate screener over ALL Hyperliquid perps, ranked by funding, open interest, volume, basis or Binance/Bybit spread. That scope ('all perps', 'ranked by') distinguishes it from a single-market sibling like hl_perp_metrics without the agent needing to open either 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?

It gives a clear use case ('Use when hunting funding extremes or carry trades'), which is exactly the intent that would select this tool over a generic perp-metrics call. It stops short of naming alternatives or stating when not to use it, so it falls just below the explicit when/when-not/alternative bar.

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

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

With no annotations, the description carries the burden well: it discloses the full output shape, cache staleness (cache_age_s), error behavior (unknown coin → 400, not charged), and payment mechanism/price ($0.002 USDC via x402). It omits rate limits and latency expectations, which keeps it short of 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?

Front-loaded with purpose, then use case, then input/output contract, then error and pricing notes. Dense but every clause carries information; the output field list is long but necessary given no output 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?

For a single-parameter tool with no output schema and no annotations, the description covers input examples, return fields, staleness, error handling and cost. The only real omission is guidance on when to prefer hl_funding_screener over this single-market endpoint.

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 already 100%, so the bar is baseline 3. The description adds value by giving concrete example tickers (BTC, ETH, kPEPE) and restating the failure semantics for unlisted/delisted symbols, reinforcing what the schema says.

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 first sentence names the exact resource and scope: predicted funding comparison across Hyperliquid/Binance/Bybit for one perp market, plus funding rate, OI and basis. It is a specific compound verb+resource statement that an agent can match to a task immediately.

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?

"Use when an agent monitors a perp position or funding carry" gives a clear triggering context. It lacks an explicit exclusion or pointer to the sibling hl_funding_screener for multi-market screening, so the agent must infer single-market vs screener division.

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

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

Without annotations the description carries the full burden, and it discloses the upstream data source (Ministry of the Interior road-name API), the exact shape of returned fields, the payment model ($0.002 USDC via x402 on Base or Solana), and the not-charged-on-400 behavior. Missing only things like rate limits or caching, 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?

Front-loaded with the trigger, then Input/Output/Data/Example/Price in tight labeled segments; no filler. Slightly list-like and dense, but every sentence carries information an agent needs.

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

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

No output schema and no annotations, so the description must explain returns and cost on its own — it does both, plus the error/charging behavior. Only minor omissions (rate limits, Korean-only input expectation) keep it from a 5.

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 adds value beyond it: a concrete example query ('?q=테헤란로 152') and the 1-5 bound on limit, which the schema does not state (it only gives default 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?

States a specific verb+resource ('normalize or translate a South Korean address') with concrete scenarios (shipping, checkout, KYC). No sibling tool overlaps, so the purpose is unambiguous.

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

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

'Use when an agent must normalize or translate a South Korean address' gives a clear trigger context, reinforced with example workloads. It gives no explicit exclusion or alternative, but no sibling performs address normalization, so there is little to route against.

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

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

With no annotations, the description carries the full burden and does well: it discloses the data source (MOLIT), coverage since 2006, daily updates, request cost ($0.0045 USDC via x402 on Base or Solana), and the output field set. It omits rate limits and pagination, but covers the major behavioral traits an agent needs before paying for a call.

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-loads the usage condition, then follows with compact Data/Input/Output/Example/Price blocks. Every sentence carries information an agent needs, with no filler.

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

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

Given two required parameters and no output schema, the description fully specifies output fields (contract date, complex names, area, floor, build year, KRW/USD price, price per m2, deal type, cancelled flag). It also covers data provenance, freshness, error behavior, and payment cost.

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

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

Schema coverage is 100%, so both parameters (region, month) are already fully documented in the schema, including formats and examples. The description reinforces this with an example query and a Gangnam-gu code, but adds no semantics beyond the schema — baseline 3.

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

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

States a specific verb and resource — actual apartment sale prices in a South Korean district for a given month — and names the data source. Its sibling kr_apartment_trades_summary is a summary tool, and this description's emphasis on actual per-deal trades distinguishes it.

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?

Opens with a clear 'Use when you need...' statement and lists concrete scenarios (property research, valuation, comps). It does not explicitly name the sibling summary tool or state when not to use this tool, so it stops short of full 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?

With no annotations, the description carries the full burden and does well: it names the data source (MOLIT reported apartment sales), discloses that cancelled deals are excluded, states the price ($0.0045 USDC via x402 on Base or Solana), and notes that the call is paid. Missing operational traits such as rate limits, caching/freshness lag, and failure modes beyond the 400-invalid-region case keep it short of 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?

Front-loads the usage directive, then layers Data / Input / Output / Example / Price in a scannable structure with no filler sentences. The Input line duplicates the schema verbatim and the example is somewhat redundant, costing it the top mark.

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 endpoint with no output schema, the description usefully enumerates the return shape (count, median/avg/min/max, KRW and USD, size-class breakdown, top complexes) and the data provenance. It is close to complete; only error behavior other than the 400 case and the billing/retry semantics are unaddressed.

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 mostly restates the schema (5-digit LAWD_CD, YYYYMM) but adds a concrete invocation example '?region=11680&month=202609' that shows both required params combined. That is marginal added value over the schema's own examples, not new semantics.

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 resource (Korea apartment price summary for a district-month) with the concrete aggregates produced (count, median/avg/min/max, price per m²/pyeong). It explicitly contrasts with the raw-trades sibling ('a quick housing-market snapshot ... instead of raw trades'), so an agent can distinguish it from kr_apartment_trades without opening either 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?

Opens with a clear routing rule: 'Use when you need a quick housing-market snapshot ... instead of raw trades,' which effectively names the alternative. It lacks explicit preconditions or exclusions (e.g. what to do for non-apartment housing types or regions outside the MOLIT feed), so it is clear context rather than a full when/when-not matrix.

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

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

With no annotations, the description carries the full burden and does well: it discloses a 1,000-row cap, English labels/units/attribution in the payload, the failure mode for non-BOK tables (403, not charged), and the x402 payment requirement with price. It omits things like rate limits, pagination, or auth setup for the x402 flow, which keeps it short of 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?

A single dense block with a clear Input/Output/Example skeleton, front-loaded with the activation condition. Every clause carries information the agent needs — no filler, no restatement 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?

There is no output schema, so the description must describe returns — and it does: JSON series with English labels, units, observations [{period,value}], row cap, and source attribution. Combined with the 403 behavior and pricing note, 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 description coverage is 100%, so the schema already documents every parameter including cycle codes, period formats, and item examples. The description's worked example (?stat=722Y001&cycle=M&start=202401&end=202412&item=0101000) is a useful invocation pattern but adds no semantic detail beyond the schema, 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?

States a specific verb and resource: retrieve official Bank of Korea statistics (base rate, money supply, key indicators) as a time series. The scope constraint 'Only BOK-authored tables are served' further narrows it and distinguishes it from sibling tools like kr_trade_exports_10day or kr_apartment_trades, which cover different data sources.

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 'Use when you need official Bank of Korea statistics... as a time series' gives clear activation context, and the 'Only BOK-authored tables are served' line tells the agent when the tool will refuse. However, it never names an alternative tool or explicitly says when-not to use it, so routing against siblings 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?

With no annotations, the description carries the full load and does well: it discloses the upstream source (National Tax Service), a 30-minute sync cadence, the cost and payment rail ($0.002 USDC via x402 on Base or Solana), and the 400-without-charge behavior on bad check digits. Missing rate limits or failure modes beyond the check-digit case keep 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?

Information-dense and front-loaded: use case first, then input, output, data provenance, example, and price. The terse 'Input:/Output:/Data:/Price:' shorthand is slightly compressed but every sentence carries actionable content.

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

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

There is no output schema, so the description enumerates the returned fields (status enum, VAT type, closure date, tax-type change, e-invoice dates, companyId), which is exactly what's needed. Input, output, source, freshness, and cost are all covered for a one-parameter tool.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds genuinely new detail: the 1-20 count range, hyphen tolerance, and a working example URL. That extra guidance about what the string may look like is useful beyond the schema's '10 digits, comma-separated'.

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 ('check that a South Korean business is still operating') plus the data source (NTS), which is far more than a restatement of the name. It does not, however, distinguish itself from the sibling kyb_check, which an agent plausibly could confuse with this 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?

It gives concrete situations for use: before paying, contracting, or onboarding, and names the KYB/invoice-check use cases. It stops short of stating when NOT to use it or pointing to kyb_check as the alternative, so this is clear context without exclusions.

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

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

With no annotations, the description carries the full burden and largely meets it: it discloses the data source, the 366-day cap and 12-month default window, the output shape, and notably the cost ($0.009 USDC via x402 on Base/Solana), which is real behavioral context. It stops short of stating rate limits, whether the id is auto-resolved, or null-case 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?

It is front-loaded with a 'Use when...' clause and packs inputs, outputs, source, example and pricing into a compact block. It is slightly dense with semicolon-delimited lists and the pricing/example tail is mildly incidental, but nothing is wasted.

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 tool with no output schema and eight parameters, the description covers inputs, return shape (summary totals plus per-award fields), data provenance, and cost. The only gap is the zero-required-parameter ambiguity (id vs business_number) and any error/null 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 description coverage is 100%, so baseline is 3, but the description adds value the schema lacks: the YYYY-MM-DD format, the max 366-day span, the default 12-month window, and enumerated category values. It still doesn't clarify the fallback when both id and business_number are omitted.

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: retrieving a South Korean company's KONEPS government contract wins. It is immediately distinguishable from siblings like kr_company_profile, kr_company_resolve, and the kr_trade_* tools, and it names the exact data source (KONEPS).

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 usage context ('sales, credit or competitor research') and implies the entity must already be resolved via the id/business_number fields. However, it never names the companion tool (kr_company_resolve) or states when NOT to use it, so routing guidance is contextual 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?

No annotations exist, so the description carries the full burden and does well: it discloses the data staleness ('weekly snapshot of KRX-listed companies, asOf in response'), a scope limitation ('No CEO names'), the upstream sources (OpenDART, KONEPS), and the metered cost/payment rail. It omits auth/rate-limit behavior, keeping it out of the 5 range.

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-loaded with the usage trigger, then Input/Output, then sources, example, and price in a dense but scannable label-value structure. Every sentence carries information, though the run-on packing is slightly list-like rather than prose-clean.

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

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

No output schema exists, so the description must describe return values, and it enumerates the profile fields (names, business/corporate/DART/stock ids, market, KSIC, founding date, fiscal year end, address, homepage, KONEPS registration) plus the asOf freshness field. Nothing needed to call or interpret this single-purpose tool 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 the baseline is 3, but the description adds real value: it names the parameter, ties it to the producing endpoint (companyId from /v1/kr/company/resolve), and supplies a concrete example value (?id=kr-dart-00126380) that clarifies the expected format.

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 ('normalized profile of a South Korean company') and distinguishes itself from the adjacent siblings kr_company_resolve (supplies the id) and kr_company_procurement (different data slice). An agent can route to 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?

Explicitly names the trigger context ('for KYB, research or sales') and points to /v1/kr/company/resolve as the prerequisite for the id. It stops short of naming when-not-to-use or the alternative sibling tools (resolve, procurement), so 4 rather than 5.

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

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

With no annotations, the description carries the full load and does well: it discloses that output is AI-written, not advice, that each figure is source-checked, that dataGaps are returned, that recentEvents is DART-scoped to 90 days, and that the call is metered at $0.50 USDC via x402 on Base or Solana. It omits failure behavior (what happens when no company matches any identifier) and latency/rate-limit expectations for a multi-source aggregation.

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-loads the when-to-use sentence, then input, output, caveat, example, price – a sensible ordering with almost no waste. The final line compresses the example and the payment terms together, which slightly blurs two unrelated facts, but nothing is padded.

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

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

No output schema exists, so the description must enumerate return values, and it does so for every top-level key including the negative-signal fields (sanctionsResult, dataGaps, sources). With all six parameters schema-documented and the payment/caveat context supplied, 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%, so baseline is 3; the description earns above that by imposing an exclusivity rule ("one of business_number, dart_corp_code, stock_code or q") that the all-optional schema with no oneOf does not express, and by supplying the accepted values for format (json|markdown) and news (true|false) in a schema that declares them as unconstrained strings.

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 deliverable: a finished English due-diligence brief on a South Korean company, with an enumerated section list in the title and description. An agent can tell this is an aggregate report rather than a single-datapoint lookup. It never names the narrower siblings (kr_company_profile, kr_filings, kr_supplier_check), so the differentiation is inferable rather than 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?

"Use when an agent needs a finished English due-diligence brief" gives a clear triggering condition, and the input enumeration implies the resolver alternatives for narrower lookups. No explicit when-not guidance or named alternative tool is provided, so the agent must guess whether a cheaper single-field sibling would suffice.

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

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

Without annotations, the description carries the burden and does well: it discloses input priority ('first wins'), output structure (JSON with stable companyId, names, flags), data sources (OpenDART, KONEPS), and even pricing via x402. It omits rate limits or error behavior, but for a read-only resolver that is relatively minor.

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

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

The description is front-loaded with purpose, inputs, and outputs, and includes a useful example and pricing. It is efficiently structured but slightly dense; the pricing sentence could be separated, though it doesn't detract significantly.

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

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

Given no output schema and no annotations, the description provides a complete picture for calling: purpose, supported inputs, output fields, data sources, example, and cost. It lacks details on error handling or rate limits, but these are not critical for a simple resolver.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful context: it specifies that only one input is used, with a precedence order ('first wins'), and clarifies the exact-match behavior for q (ignoring 주식회사/(주)/spacing). This goes beyond the schema's individual parameter descriptions.

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

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

The description explicitly states the tool's role: identify a South Korean company before looking up its profile or public-procurement record. It names the supported inputs and output, and distinguishes itself from downstream siblings like kr_company_profile and kr_company_procurement.

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 indicates when to use the tool ('Use when an agent must identify a South Korean company before looking up its profile...'), implying it should be called first in a sequence. However, it does not explicitly name when not to use it or list alternative tools for other purposes.

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

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

With no annotations, the description carries the full burden and does disclose meaningful traits: it is a paid call ($0.0045 USDC via x402 on Base or Solana) and it names the exact output fields (rceptNo, date, Korean title, English type label, DART link). It omits error/empty-result behavior, pagination semantics around limit, and whether both corp and q may be supplied together.

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-loaded with the usage trigger, then input, then output, then cost — a sensible priority order with almost no filler. It is dense to the point of being slightly crammed (sibling-path and pricing squeezed onto the same lines), but every sentence carries information.

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

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

No output schema exists, so the description's field list for the returned JSON is genuinely load-bearing, and the pricing/auth model is disclosed. Given five optional params and no annotations, it would be stronger if it clarified precedence between corp, q, and date and what limit does to results.

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

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

Schema coverage is 100%, so the baseline is 3. The description does add a small amount beyond the schema: the days range bound (1-365) and the default (30), plus a concrete example query. It says nothing about limit, and redundant corp-format detail duplicates the schema rather than extending it.

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 (recent material disclosures) and resource (South Korean listed company DART filings), and enumerates the disclosure categories covered (rights offerings, CBs, buybacks, M&A, litigation, earnings, periodic reports). It also explicitly routes summary needs to a different endpoint, so an agent can distinguish it from kr_filing_summary without opening either 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?

"Use when an agent needs recent material disclosures..." gives an explicit trigger, and the input enumeration (corp/q with days, or date) tells the agent the two access patterns. The pointer to /v1/kr/filings/summary names the natural alternative. It stops short of stating exclusions (e.g. no historical-range mode, no full-text search) or prerequisites such as resolving a company name via kr_company_resolve first.

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

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

With no annotations, the description carries the full load and does so: it discloses that output is a machine-generated paraphrase rather than official text, that unknown rcept_no or model outage is refused before payment, and the exact price and payment rails ($0.02 USDC on Base or Solana via x402). That is precisely the pre-call context a paying 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?

Front-loaded with the use case, then labeled Input/Output/Example/Price segments, so an agent can scan quickly. It is slightly over-packed, cramming the full output field list, the payment rail, and the price into dense lines, but no sentence is truly wasted.

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, so the description enumerates the return fields (headline, what_happened, key_figures, parties, key_dates, why_it_matters, confidence, original title, DART link), plus cost, refusal behavior, and the paraphrase caveat. Nothing an agent needs to decide or call correctly 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% for the single parameter, so baseline would be 3; the description adds provenance the schema lacks — where to obtain the 14-digit rcept_no (/v1/kr/filings) and a concrete format example. It does not explain failure modes for malformed input beyond the generic refusal, keeping it just short of 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 — an English summary of a Korean DART corporate disclosure — and the title reinforces it with what happened, key figures, parties, dates. It is clearly distinct from the sibling kr_filings, which supplies the rcept_no this tool consumes, so an agent can tell the two apart without opening schemas.

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?

"Use when an agent needs a Korean corporate disclosure in English" gives a clear selection context, and the input note pointing to /v1/kr/filings implicitly routes the agent to the listing tool first. It stops short of explicit when-not guidance (e.g. when the original Korean text or a raw filing fetch is preferable), so it is not a 5.

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

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

No annotations are provided, so the description carries the full load and does reasonably well: it discloses the machine-translation caveat ('check the official page'), the per-call price and payment rails (x402, USDC on Base or Solana), and the KST time basis. It omits rate limits, error/empty-result behavior, and whether payment is required per request or per session.

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-loaded with the use condition, then input, output, caveat, example, and price in that order, with no filler sentences. The example query is compressed to ?q=AI&limit=5 rather than a prose walkthrough.

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 responsibly enumerates returned fields (Korean title, official link, published time, English brief with title_en/summary_en/agency_en/category/key_points) and the translation caveat. What remains thin is failure behavior and freshness/latency of the 'latest' feed.

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 adds real meaning: q accepts Korean or English, date must be YYYY-MM-DD in KST, and limit is bounded 1-20 with default 5 (the schema only says 'default 5' with no range). That extra constraint is the kind of detail an agent cannot get from the structured fields.

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: tracking South Korean government policy, regulation, and draft legislation, in English with briefs. That scope is separable from siblings like kr_filings, kr_filing_summary, and kr_bok_ecos_series without opening any 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?

Opens with an explicit 'Use when...' condition naming the tracking use case, and the example query shows a concrete invocation. It stops short of naming when-not conditions or the sibling tools an agent should prefer for corporate filings or economic series.

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

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

With no annotations, the description carries the full burden and does well: it discloses the upstream data source, that substitute/temporary holidays are included only once promulgated (a real freshness caveat), the exact response shape, and notably the monetization model — $0.0027 USDC via x402 on Base or Solana. It does not mention rate limits, error behavior for out-of-range years, or caching, 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?

Dense but front-loaded: the "Use when" clause leads, followed by labeled fragments for data source, input, output, example, and price. Every segment carries information, though the telegraphic labeling style ("Data:", "Input:", "Price:") reads more like a spec sheet than prose.

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 enumerating the returned fields (date, weekday, Korean and English name, isPublicHoliday, kind). Combined with the input range, source, and payment requirement, 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 coverage is 100% and the single parameter's description already states the YYYY format and the 2004–2100 bounds. The description repeats that range and adds only a usage example (?year=2026), so it adds little meaning beyond the schema — baseline 3.

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

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

States a specific verb+resource (South Korea's official public holidays for a year) and pins down the data source (KASI special-day register) plus the scope that matters for correctness (substitute and temporary holidays once promulgated). No sibling covers holidays, so it is unambiguously the right tool for this need.

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?

"Use when you need ... (business-day calculation, scheduling, settlement and payroll calendars)" gives concrete triggering contexts, which is more than most definitions offer. It stops short of naming exclusions or pointing to any alternative (e.g. a generic calendar/time tool such as time_convert), so it is clear but not fully routed.

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

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

With no annotations, the description carries the full burden and does well: it discloses the composite data sources (NTS, DART, 12-month KONEPS, OFAC/EU/UK screening), the shape of the result (riskLevel, riskFlags, per-section status), the scope limit that sanctions screening runs on the English name only, and the pricing/payment rail (x402, USDC on Base or Solana). It omits failure behavior, e.g., what happens when no company matches or when multiple candidates match the supplied name.

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-loaded with the 'Use when' trigger, then Input, Output, caveat, example and price, each sentence carrying distinct information. The example (?stock_code=005930) and price line are compact and actionable rather than filler.

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

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

With no output schema and no annotations, the description does the necessary work: it enumerates the returned sections and the risk summary, states the screening scope, and gives cost. Remaining gaps are edge behavior such as ambiguous or unmatched company names and any rate limits, which matter for an agent deciding whether to retry.

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 per-field meanings are already documented. The description nonetheless adds cross-parameter semantics the schema lacks: it states that exactly one of business_number, dart_corp_code, stock_code or q should be supplied, which is not encoded anywhere in the schema (no oneOf, required is empty). The note that q is an exact name match is echoed from the schema rather than added.

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 ('vet') and a specific resource ('South Korean supplier or counterparty') and clarifies it bundles NTS status, DART profile, procurement awards and sanctions in one call, which separates it from single-purpose siblings like kr_business_status or sanctions_screen. It does not, however, distinguish itself from the closely named sibling kyb_check, leaving an ambiguity an agent must resolve by guessing.

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?

'Use when an agent must vet a South Korean supplier or counterparty before paying, contracting or onboarding it' gives a clear triggering context, and 'Not a legal determination' sets a usage boundary. It stops short of naming alternatives or exclusion cases (e.g., use kr_company_profile when only a profile is needed, or sanctions_screen for address-level screening).

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

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

No annotations are provided, so the description carries the burden, and it does real work: it discloses the release schedule (11th, 21st, 1st), the paid x402 access model with price and chains, and the data start date. It does not cover failure modes or rate/limit 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?

Front-loaded with the use condition, followed by input/output/example/price in a compact sequence with no filler. The single long sentence is dense but each clause carries distinct 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 describe returns, and it lists USD exports, YoY, the 10-day increment, key items, markets, shares, and next release date. Missing only edge-case behavior (e.g. unavailable month) to be fully complete.

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

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

Schema coverage is 100%, so baseline is 3; the description goes further by giving a concrete example query (?month=202609) and restating the default-latest behavior and the period/month dependency in plain language.

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 verb and resource ('Korea Customs 10-day provisional release') and pins the scope (days 1-10, 1-20, full month). It clearly separates itself from the other Korea trade siblings by framing this as the earliest/flash read.

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?

'Use when you need South Korea's earliest export read' gives a clear use condition, and the release cadence tells the agent when data exists. It does not explicitly say when to prefer kr_trade_hs or kr_trade_pulse instead, so it falls 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?

With no annotations, the description carries the full burden. It discloses the data source and that figures are finalized monthly, plus the x402 payment requirement and price, which is genuinely useful. However, it never states permissions, whether results are cached, error behavior for invalid prefixes, or latency/rate characteristics of a paid endpoint — a significant gap for a metered tool.

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

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

One dense, front-loaded block covering trigger, data, inputs, outputs, example, and price — every clause carries information. The final price/example sentence is slightly crowded and breaks the input/output rhythm, keeping it just short of ideal.

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, so the description must explain return values, and it does: JSON totals in USD (exports FOB, imports CIF, balance, kg) plus 10-digit HSK lines with English descriptions and YoY percentages. Combined with the worked example, an agent has everything needed to call and interpret it.

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

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

Schema coverage is 100%, so the baseline is already 3, and the description adds real value on top: it enumerates the sort values (exports, imports, balance, total) and the default latest month, neither of which the schema spells out. It still doesn't clarify the number-or-string union on limit, but that is a minor omission.

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 — monthly Korean trade by HS code — with concrete HS prefixes as examples (8542, 870323, 2710). The agent can immediately tell this apart from the sibling flash estimators kr_trade_exports_10day and kr_trade_pulse because the title and description anchor on finalized monthly Customs data.

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

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

Opens with an explicit trigger: 'Use when you need South Korea's monthly trade for a product by HS code.' That is a clear usage context, but it never states when NOT to use it or names an alternative for flash/10-day estimates, so routing against siblings is only implied.

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

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

With no annotations provided, the description carries the behavioral disclosure burden and does well: it names the data source (Korea Customs 10-day and monthly releases), states there are no inputs, enumerates the return contents, and discloses pricing/payment via x402. It does not mention update cadence beyond 'latest release', rate limits, or latency, leaving minor behavioral gaps.

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

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

The description is front-loaded with the usage condition, then efficiently covers data source, input, output shape, example endpoint, and price. Every element earns its place because there is no output schema to document the return payload elsewhere.

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

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

Given zero parameters, no annotations, and no output schema, the description supplies the necessary context: data source, input absence, detailed return fields, example endpoint, and payment cost. An agent can understand what it gets and how to invoke it without needing additional structured fields.

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

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

The tool takes zero parameters, so parameter semantics are inherently simple. The description explicitly says 'Input: none', which matches the schema. Baseline for zero parameters is 4.

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

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

The description clearly states a specific capability: a one-call read on South Korea's export cycle for macro, FX, or chip-sector analysis. It covers the data sources and output dimensions, so the purpose is concrete. It does not explicitly differentiate itself from nearby siblings such as kr_trade_exports_10day or kr_trade_hs, which keeps it from 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?

The opening sentence gives clear usage context: use when you need a consolidated read on Korea's export cycle for macro, FX, or chip-sector analysis. It does not state when to avoid this tool or name alternatives like the more granular trade siblings, so it stops short of full 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?

With no annotations, the description carries the full burden and does well: it discloses the data provider, update cadence (issued 8 times a day), grid resolution, the x402 payment requirement and price ($0.0045 USDC on Base or Solana), and that out-of-domain requests return 400 without charge. Missing only rate limits/response latency.

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 when-to-use clause is front-loaded, followed by tight Data/Input/Output/Example/Price segments that are easy to scan. It is dense but nearly every clause carries information an agent needs; the example URL is the only borderline-redundant element.

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 enumerates the return payload (hourly then 3-hourly temperature, sky, precipitation type/probability, rain/snow amounts, humidity, wind, daily min/max) and covers pricing and error behavior. It is nearly complete for a two-parameter point forecast; only units for wind and response size are unstated.

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

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

Schema coverage is 100% and both parameters are already documented with WGS84 format and KMA domain bounds, so the baseline is 3. The description reinforces 'WGS84 decimal; Korea only' and adds a concrete example query string, but contributes no 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?

States a specific verb+resource (official weather forecast), the exact geographic scope (a point in South Korea), the horizon (~3-5 days), and the source (KMA village forecast on a 5 km grid). This clearly separates it from the sibling weather_global without needing to open either 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?

Opens with an explicit 'Use when you need...' trigger plus the 'Korea only' constraint, which is clear usage context. It stops short of naming weather_global as the alternative for non-Korean points, so the exclusion is implied by geography 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?

With no annotations, the description carries the burden well: it discloses the return summary, the specific sanctions lists, GLEIF parent data, VIES results, partial-failure behavior ('a down VIES/GLEIF marks only that part'), the legal disclaimer, and the x402 payment cost/rails. It stops short of rate limits, caching, or idempotency details.

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

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

Front-loaded with the use case and structured into input/output/example/price. Dense but largely purposeful; the long output enumeration could be tightened slightly.

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 four-parameter tool with no output schema, the description explains what comes back (sanctions hits, LEI status, VAT validity, GLEIF parents), partial failure behavior, and payment requirements. An agent has enough to invoke and interpret it correctly.

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

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

Schema coverage is 100%, so the schema already documents name, country, lei, and vat with useful descriptions. The description restates inputs and adds a worked example, but does not add semantics beyond the schema (e.g., matching behavior for names or format nuances for lei/vat).

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 specific verbs and resources: vet a company/counterparty with sanctions (OFAC/EU/UK), LEI, and EU VAT checks. The combined scope clearly distinguishes it from single-purpose siblings like sanctions_address or sanctions_screen.

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

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

Explicitly says when to use it: before paying, onboarding, or invoicing. It does not name alternative tools or when-not-to-use cases, but the context is clear.

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

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

With no annotations, the description carries the full burden and does disclose meaningful behavior: output shape (per-1M input/output, cached/batch, context window, as_of + source commit) and the payment mechanism (x402, $0.004 USDC on Base or Solana). It omits auth/rate-limit details and whether failed calls are billed beyond the 'not charged' note that lives in the schema.

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-loaded with the usage trigger, then inputs, outputs, example, and price in a compact sequence. It is dense and slightly run-on in the output enumeration, but every clause carries 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 10-parameter tool with no output schema and no annotations, the description covers both input modes and enumerates return fields plus the billing model. Remaining gaps (auth requirements, pagination/limit behavior nuances) are minor.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds real meaning: the mutual exclusivity of the two parameter groups (model vs. mode/provider/min_context/capabilities) and a concrete example query string. That interplay is not spelled out in the schema descriptions.

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

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

States specific verbs and resources: pricing an LLM call, calculating token cost, and ranking the cheapest model. The scope (USD per 1M tokens, provider, capabilities) is precise, and no sibling tool in the list overlaps with model pricing, so disambiguation is trivially clear.

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

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

Opens with an explicit trigger: 'Use when an agent must price an LLM call or pick the cheapest model,' then splits the two invocation modes (model given vs. no model + filters). No explicit when-not guidance or named alternative, but the context is unambiguous for this tool.

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

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

With no annotations, the description carries the full burden and does so: it discloses the return shape (overview, clusters, sources), the content limit ('Headlines and links only' — signaling no full article text), the billing model ($0.007 USDC via x402 on Base or Solana), and 'Failures not charged.' These are exactly the behavioral facts an agent needs before committing a paid call.

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-loaded with the use case, then a compact Input/Output/limits/pricing block — every sentence carries information. The inline example query and price line make it slightly denser than ideal, but nothing is truly wasted.

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 and no annotations, the description supplies the return shape, content limits, cost, and failure policy, which is close to sufficient for a 3-param tool. Minor gaps remain: empty-result behavior and how payment/authentication is actually performed are implied rather than stated.

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 adds meaning the schema lacks: it enumerates time_range values (day, week default, month, year) where the schema only says 'Window (default week)', and bounds max to 1-10 where the schema only says 'Headlines considered (default 10).' That is genuine added value beyond the structure.

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

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

The description states a specific capability: clustered, deduplicated English-language news on a topic, with Korean/Asian coverage emphasized. The verb+resource ('what is happening on a topic right now') is concrete and the clustering/dedup behavior distinguishes it from a generic web_search. It stops short of naming a sibling to avoid, so it lands just below the top mark.

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?

'Use when an agent needs what is happening on a topic right now, in English' gives a clear triggering condition, reinforced by the example query. There is no explicit when-not or routing to alternatives such as web_search or web_read for full text, so it is clear-but-bounded rather than exhaustive.

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

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

With no annotations, the description carries the full burden and does so well: it discloses supported chains, the pool venues and routing used, a depth threshold, that results are spot and not TWAP, and that bad input returns 400 before payment. Cost and payment mechanics via x402 are also stated. It omits rate limits, freshness/latency, and caching, which keeps it off 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?

Front-loads the trigger, then uses labeled Input/Output blocks followed by qualification (depth floor, spot-not-TWAP) and price. Dense but every line earns its place; the trailing example and pricing sentence are slightly tacked on rather than integrated.

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

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

There is no output schema, and the description fully compensates by enumerating return fields: per-token priceUsd, confidence, pool with fee tier and USD depth, path (direct USDC or via WETH/SOL), and warnings. For a single-parameter read tool this is complete enough to call correctly on the first attempt.

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 (comma-separated chain:address, max 10, base:0x…/sol:<mint> base58, 400 on bad input). The description restates that format and adds only a concrete example query, so it adds marginal value over the schema — baseline 3.

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

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

States a specific verb and resource: a token's USD price sourced directly from onchain DEX pools on Base and Solana, naming the exact venues (Uniswap v3 / Aerodrome / Orca Whirlpool). This cleanly separates it from feed-based siblings like fx_rates, llm_model_prices, and the token_info/risk 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?

Explicit trigger: "Use when an agent needs a token's USD price without a third-party price feed," plus a hard usability boundary ("no price below $1,000 depth") that tells the agent when the tool will not answer. It does not name alternative siblings (e.g. base_token_info, fx_rates) or say when to prefer them, so it stops short of a 5.

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

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

With no annotations, the description carries the burden and does well: it discloses the 20 s cache, the quoting sources (Uniswap v3 QuoterV2 / Aerodrome, Orca CLMM estimate), and the x402 payment price. It omits failure/rate-limit behavior and what happens when a pool lacks depth, so not 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?

Dense and front-loaded: trigger, input shape, output shape, cache, all in a few clauses. The trailing example is written as a URL query string ('?tokens=...&amount_usd=5000') rather than tool arguments, which is minor noise for a tool whose params are object properties.

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-param tool with no output schema, the description enumerates the returned fields (priceUsd, confidence, pool, depth, tokensOut, effectivePriceUsd, priceImpactPct) and the caching and payment model. An agent has enough to decide and 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 coverage is 100%, so both parameters are already documented, including the 25-token cap, Solana sub-limit, and default 1000. The description restates those same constraints and adds no syntax or format meaning beyond the schema, 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?

States a specific verb+resource: batch token prices plus simulated buy cost/price impact across Base and Solana DEX pools. This clearly separates it from the single-token sibling onchain_prices without opening either 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?

'Use when a trading agent needs many token prices at once plus what a buy would really cost' gives an explicit triggering context. It implies batch-vs-single usage but never names onchain_prices as the alternative or states an exclusion for single-token lookups.

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

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

With no annotations, the description carries the behavioral burden and discloses important traits: data comes from OSV.dev, output shape is JSON with severity/advisory details, and usage costs $0.003 USDC via x402. It does not describe rate limits or error behavior, but the key operational facts are present.

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

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

The description is compact and front-loaded: use case, inputs, outputs, data source, example, and price are each handled in one clause. Every sentence contributes 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?

For a three-parameter read query with no output schema and no annotations, the description supplies the missing return-value overview, data provenance, cost, ecosystem coverage, and a concrete example. Nothing essential for calling the tool correctly appears 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 description coverage is 100%, so the schema already documents package, version, and ecosystem semantics. The description repeats the input names and adds ecosystem examples plus a sample query, but adds only limited meaning beyond the structured schema.

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

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

The description states a specific verb and resource: check whether an exact package version is vulnerable before installing or upgrading. It names the focused query and immediately clarifies the intended dependency-checking scenario, making the tool distinguishable from unrelated sibling tools.

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

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

It gives clear context for when to use the tool: 'before installing or upgrading' to check a dependency. It does not name when-not-to-use cases or alternatives, but no obvious sibling tool covers vulnerability checking.

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

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

With no annotations at all, the description carries the full burden and does so: it discloses the payment model ($0.01 USDC via x402 on Base or Solana), that bad input or the daily cap is refused before payment, the execution engine (headless Chrome on Cloudflare), and the exact output shape (JSON fileBase64 to decode, bytes, page settings). That is precisely the behavioral context an agent needs before committing a paid call.

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-loaded with the when-to-use clause, then input, output, engine, error and price in six tight sentences — no filler. The telegraphic shorthand ('Input: GET ?url=', 'Price: $0.01 USDC') trades some readability for density.

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 6-param tool with no annotations and no output schema, the description covers the return payload (fileBase64, bytes, page settings), the payment and refusal behavior, and the rendering backend. Gaps are minor: no mention of render timeouts, JS/pagination handling, or max input size.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds real value beyond it: it supplies the format values A4|Letter that the schema's enum-less 'Page size' field lacks, explains the GET-vs-POST split for url/html/markdown, and shows a concrete usage example. Margin units and landscape semantics are left to 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 concrete verb and resource (render HTML, Markdown, or a public page to a print-ready PDF) and enumerates the artifact types it serves (report, invoice, summary, receipt). It reads clearly distinct from sibling render_png and from the conversion siblings like convert_to_markdown.

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 'Use when an agent must hand over a document as a PDF' gives an explicit trigger, and the input section clarifies which mode to choose (GET ?url= for public pages, POST JSON for html/markdown). It stops short of naming alternatives such as render_png or convert_to_markdown or stating when not to use it.

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

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

With no annotations, the description carries the full burden and does so: it discloses that Korean fonts are included, that bad input or the daily cap is refused before payment, and that the call costs $0.01 USDC via x402 on Base or Solana. It also states the exact output shape (JSON fileBase64 to decode, bytes, viewport), which is essential for a paid tool with no output schema.

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?

Dense and front-loaded: purpose first, then input contract, output shape, failure behavior, example, and price. Every clause earns its place, though the telegraphic 'Input: GET ?url=, or POST JSON {...}' phrasing is terse to the point of being slightly cryptic.

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-mode rendering tool with no output schema and no annotations, the description covers invocation modes, output decoding, pricing, and pre-payment validation — everything an agent needs to call it correctly and anticipate cost or refusal.

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 adds real value beyond it: the width range 320-1920 (schema only gives the default), the GET-vs-POST usage split, and the meaning of full_page. Minor gap: 'full_page' is typed as a string in schema while the description writes it as a boolean-ish flag.

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 precise verb+resource: converting the agent's own HTML/Markdown or a URL into a PNG, with named use cases (social card, chart, table snapshot, preview). It does not explicitly contrast with close siblings like render_pdf or web_screenshot, so differentiation is left to inference.

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 'Use when an agent must turn its own HTML or Markdown into an image... or capture a page as PNG' gives a clear triggering context. There are no explicit exclusions or named alternatives (e.g., when to prefer render_pdf or web_screenshot), so it falls short of a 5.

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

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

With no annotations, the description carries the load well: it discloses the output fields (listed yes/no, SDN entry, programs, network, list as-of date, data age), a legal caveat ('Not a legal determination'), and the payment/auth model ($0.0045 USDC via x402). It omits error behavior and any rate limits, so it falls short of exhaustive.

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-loads the usage trigger, then labels Input/Output and closes with pricing — a clear structure. Most sentences earn their place, though the example URL is terse and the price sentence borders on promotional.

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, so the description must describe returns, and it does so thoroughly (listed flag, SDN entry, programs, currency/network, link, as-of date, data age), plus input formats, caveat, and cost. 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%, and the schema already explains both address and chain, including the EVM/BTC/TRX/SOL formats and the optional-chain behavior. The description largely restates this, adding only the 'EVM matched on every EVM chain' nuance, 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?

States a specific verb and resource: checking a crypto wallet address against OFAC's digital-currency SDN list. The scope ('digital currency addresses') implicitly distinguishes it from the sibling sanctions_screen, which covers name/entity screening, so an agent can tell the two apart.

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 clear trigger condition: 'use when an agent must check a crypto wallet ... before paying or accepting funds.' It does not explicitly name sanctions_screen as the alternative for non-address screening, so the when-not case is only implied by the input type.

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

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

With no annotations, the description carries the full burden and does substantial work: it discloses cost and payment rail ($0.01 USDC on Base or Solana via x402), validation behavior ('unknown formats refused before payment'), output contents, and a legal disclaimer ('Not a legal determination'). It does not cover latency, rate limits, or failure semantics for partially-valid batches.

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-loaded with the usage trigger, then input, output, caveat, example, and price in a tight sequence — every clause carries information. It is dense to the point of being crowded (formats, example addresses, pricing all in one paragraph), costing a bit of readability.

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

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

There is no output schema, and the description compensates fully by enumerating return fields (per-address yes/no, detected chains, SDN entity, programs, summary counts, list date). Combined with the payment and validation details, 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 coverage is 100%, so the single parameter is already documented. The description still adds value by presenting the alternative POST JSON {addresses:[...]} body form and reinforcing the 1-50 mixed-chain constraint, which is more than restating 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+resource+scope: screening many wallets at once (up to 50, mixed chains) against OFAC SDN wallet addresses. The 'many at once / bulk' framing cleanly separates it from the single-address sibling sanctions_address without needing to name it.

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

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

Explicitly says 'Use when an agent must screen many wallets at once (payouts, counterparty lists)', giving concrete triggering scenarios. It lacks an explicit when-not or a named pointer to sanctions_address for single-address screening, so it stops short of full 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?

With no annotations, the description carries the full load and does well: it discloses the return payload fields (score, programs, countries, aliases, OFAC link), freshness metadata (list as-of date, data age), a legal disclaimer ('not a legal determination'), and the pricing/payment mechanism. It omits auth/rate-limit details, keeping it just short of 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?

Front-loaded with the trigger and input/output shape in tight, information-dense form; the example and price are useful for x402 callers. The single block is slightly crammed, but every sentence contributes.

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

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

Substitutes for a missing output schema by naming the return fields and adding freshness and legal caveats, which is exactly what an agent needs before acting on a hit. The main hole is the undisclosed multi-list capability, which affects how results should be interpreted.

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 five parameters, making 3 the baseline. The description corroborates fuzzy matching with aliases and gives a worked example, but it mentions only the OFAC list and never surfaces the `lists` parameter (eu, uk, all) that the schema exposes, so it undersells an agent-relevant capability.

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 (check/screen) and resource (name against the U.S. Treasury OFAC SDN list), covering persons, companies, vessels and aircraft. The 'OFAC sanctions name search' framing makes it clearly distinct from sibling sanctions_address, which screens addresses rather than names.

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 an explicit when-to-use trigger: 'before paying, onboarding or shipping'. This is clear operational context. It does not explicitly route between sanctions_screen and sanctions_address, though the name-vs-address subject matter makes the split fairly self-evident.

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

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

With no annotations, the description carries the burden and does well: it discloses that bad formats are refused before payment, states the price and payment rail (x402, $0.009 USDC), and adds a 'not a legal determination' caveat. It stops short of describing rate limits, latency, or what happens on a valid-format but unlisted/unknown tx.

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-loaded with the usage trigger, then input/output/behavior/price in a compact telegraphic style; every segment carries information. Slightly list-like density makes it less readable than prose, but there is no filler.

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

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

No output schema exists, and the description compensates by enumerating returned fields (verdict, parties, roles, listed yes/no, SDN entity, programs, tx status, list date). Together with the input format and payment note this is nearly complete for a 2-param screening call; only error/edge behavior 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%, so baseline is 3, and the description adds real value beyond the schema by naming the accepted network values ('eip155:8453 default, or solana') which the schema leaves as an open string with no enum, plus a usage example '?tx=0x…'. It does not explain edge cases like what tx formats are rejected.

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 ('screens its direct parties ... against OFAC SDN wallet addresses') and enumerates exactly what is screened on each chain (sender, recipient, contracts, Transfer parties on Base; accounts and token owners on Solana). This transaction-level scope is clearly distinguishable from the address-level siblings like sanctions_address and sanctions_screen.

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

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

Gives an explicit trigger condition: 'Use when an agent must check a transaction before accepting or relaying funds.' That is a clear use context, but it does not name alternatives (e.g., when to prefer sanctions_address or sanctions_addr_batch instead) or state exclusions.

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

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

With no annotations, the description fully carries the burden and does so well: it discloses the per-date return shape (clearest scene, cloud %, NDVI mean/median, three PNG products), the derived change + reliability fields, the failure mode (404 when no scene) with the significant commercial consequence that it is not charged, and the x402 payment price and rails. Cost, error behavior, and payment mechanics are exactly the traits an agent cannot get 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?

Front-loaded with the 'Use when' trigger, then organized into Input / Output / Error / Example / Price blocks — nothing is wasted. The telegraphic spec-sheet phrasing ('Output: JSON per date: …') is dense but scannable; a slightly less compressed output sentence would read better.

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, 7 parameters, and no annotations, the description covers the essentials an agent needs: trigger, inputs, return payload, error semantics, and price. Remaining gaps are minor — what 'reliability' measures and the two optional tuning params (size, window_days) are never mentioned.

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 adds genuinely new constraints not in the schema: the radius_m operating range of 200–10000 m (schema only gives the default) and a fully worked query example for lat/lon/before/after. It omits size and window_days entirely, and drops the schema's '2017-01-01 or later' floor for `before`.

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 pair — checking what changed at a place between two dates — and enumerates the concrete use cases (construction, deforestation, flooding, crops). It implicitly distinguishes itself from satellite_image (single scene) and satellite_trend (time series) via the 'two dates before/after' framing, but 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?

Opens with 'Use when checking what changed…' which is a clear positive selection rule, and adds hard preconditions (dates 20+ days apart, radius 200–10000). It gives no exclusions or explicit pointers to satellite_image / satellite_trend for single-date or long-series needs, so the agent must infer 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?

With no annotations, the description carries the burden and does so well: it discloses scene-selection behavior (clearest scene by cloud share inside the requested area, not the whole tile), error semantics ('No scene: 404, not charged'), and payment requirements ('$0.009 USDC (Base or Solana) via x402'), plus the exact output fields. It omits rate limits and whether returned PNG URLs expire, which is the only material gap.

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

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

Compact and front-loaded with a Use-when clause followed by Input/Output/Error/Price blocks; nearly every fragment earns its place. It is dense to the point of reading like a manual, but not padded.

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

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

No output schema exists, so the description compensates by enumerating returns (JSON PNG URL, scene date, area cloud %, alternatives) and error/payment behavior. It is nearly complete; only minor edges like size default interplay with radius_m and URL lifetime are left implicit and covered by the schema instead.

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 adds real value beyond the schema: it enumerates mode values (true_color, false_color, ndvi, ndwi, moisture), states the radius_m working range (200-10000), and clarifies that other mode URLs are returned alongside the chosen one. That goes beyond what the terse schema descriptions provide.

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 ('see a place from above'), names the concrete product (Sentinel-2 true color / NDVI imagery) and its scope, so it is immediately distinguishable from every sibling (crypto, KR trade, weather, etc.). An agent knows exactly what capability this unlocks.

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

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

'Use when an agent must see a place from above or check vegetation, water or change' gives a clear positive trigger context. There are no realistic alternative siblings to route to, so no exclusion clause is needed, but it also gives no when-not guidance (e.g., clouds/coverage limits).

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

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

With no annotations, the description carries the full burden and does so: it enumerates the return fields and status values (ok, cloudy, no_scene), states that missing scenes return 404 and are not charged, and discloses the $0.012 USDC x402 payment requirement on Base/Solana. That covers cost, error behavior, and response shape an agent needs 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?

Front-loaded with the use case, then inputs, outputs, edge case, and price in a compact telegraphic style with no filler. Minor friction from the run-on 'Example: ?lat=... Price: ...' and an example without a base URL, but nothing is wasted.

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

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

No output schema exists, yet the description fully specifies the returned series fields, aggregate min/max and change, the no-scene outcome, and payment mechanics. For a 5-parameter read tool with no annotations, 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 coverage is 100%, so the baseline is 3; the description goes beyond it by adding the radius_m valid range (200-10000), the months range (1-12), and a concrete example query. It still lets the schema do most of the per-parameter work.

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 activity (tracking crops, greenery, land change month by month) and the concrete resource (per-month JSON with NDVI mean/median, cloud %, scene status). The phrase 'Numbers only, no images' implicitly separates it from satellite_image and satellite_compare, 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?

'Use when tracking crops, greenery or land change month by month' gives a clear triggering context, and the inputs/limits (radius 200-10000, months 1-12) scope it further. There is no explicit when-not or named alternative, which keeps it just below a 5.

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

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

With no annotations, the description must carry the behavioral load, and it does: it names the data source (SEC EDGAR), the payment mechanism and price ($0.0027 USDC via x402), and a real limitation ('Insider forms without filer names'). It stops short of rate limits or auth details beyond payment, keeping it out of the top band.

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-loaded with the 'Use when' trigger followed by input, output, and data-source details in a compact block. It is dense but every clause (fields, caveat, pricing example) is informative, with little padding.

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

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

No output schema exists, so the description usefully previews the return payload (company profile fields, filing dates, 8-K item codes, XBRL flags, sec.gov links). Combined with input coverage, data source, and pricing, an agent has enough to call it correctly; only auth/rate-limit context 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 description coverage is 100%, so all five parameters are already documented with examples in the schema. The description restates ticker/cik, form (comma list), since, and limit without adding syntax or format meaning beyond what the schema provides; the example query string adds marginal 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?

States a specific verb and resource ('needs a U.S. public company's SEC filings') and enumerates the form types covered (10-K/10-Q, 8-K, proxies, S-1s). No sibling in the list offers SEC EDGAR data, so the purpose is unambiguous and easily separated from neighbors like site_profile or web_metadata.

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?

Opens with an explicit 'Use when...' trigger tied to public-company SEC filings and provides a concrete example query. There is no overlapping sibling to exclude against and no when-not guidance, but the usage context is clear.

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

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

With no annotations, the description carries the full burden and does so: it discloses the x402 payment ($0.05 USDC on Base or Solana), that limits are checked before payment, that 4xx/503 means not charged, that the txHash is confirmed before settling, and daily caps per address and overall. These are exactly the behavioral facts an agent needs before spending money.

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-loaded with the use condition and the core behavior (input → amount → output) in a tight sequence. It is dense with high-value facts, though the example URL and price sentence add some visual clutter rather than pure 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?

No output schema exists, and the description enumerates the returned JSON fields (txHash, explorerUrl, amountEth, from, to) plus the confirmation guarantee. For a one-parameter paid call, everything needed to invoke and interpret the result is present.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds a worked example (?to=0x...dEaD) and restates the recipient meaning, which helps concretely. The EIP-55 checksum detail lives only in the schema, so the description stops just short of fully supplementing.

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 action and asset: sends 0.1 SepETH to the given recipient via a single x402 call. It explicitly distinguishes itself from the sibling sepolia_eth_1 by noting the 1 SepETH variant path, so an agent can pick the right size without opening either 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?

"Use when an agent, test suite or CI job needs Sepolia gas now" gives a clear triggering condition, and the parenthetical path routes larger needs to the 1 SepETH sibling. It does not state explicit exclusions (e.g. mainnet use or non-test use), but the 'Test ETH has no monetary value' line effectively bounds the use case.

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

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

With no annotations at all, the description carries the full burden and does so: it discloses the x402 payment path, the $0.50 USDC price and networks, that limits are checked before payment, that bad input/caps/out-of-stock yield 4xx/503 without being charged, and that the tx is confirmed before settling. The 'no monetary value' note pre-empts a common agent misjudgment.

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-loaded with the use case, then input/output, then limits and price — a sensible ordering. It is dense (limits, price, example, currency networks in three sentences) but nearly every clause is actionable; the noting of 'both sizes' is the only slightly oblique phrasing.

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 enumerating the return fields (txHash, explorerUrl, amountEth, from, to) and noting confirmation timing. Pricing, payment rail, rate limits and failure behavior are all present, so an agent has everything needed to call and interpret it.

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

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

Schema coverage is 100% and the only parameter's description already covers checksum format and the no-charge failure modes. The description restates the parameter role and adds a concrete ?to=0x… example, but supplies no semantics beyond what the schema already documents, so 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 with the exact quantity: sends 1 SepETH to a recipient, framed for contract deploys/tests/CI. The '('bulk)' in the title and the mention of 'both sizes' implicitly point at a sibling tier, but the description never names the sibling tool, so differentiation is only inferable.

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?

Explicit 'Use when a contract deploy, test suite or CI job needs more Sepolia gas than a faucet gives', which names the trigger condition and contrasts with a faucet. It gives no guidance on when the other SepETH size (sepolia_eth) is preferable, so the sibling choice 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?

With no annotations at all, the description carries the full burden and does it well: it discloses the exact output surface, HTTP/HTTPS behavior, that private/internal targets return 400, and — unusually — the cost and payment rail ($0.009 USDC on Base or Solana via x402). Cost, payment mechanism and error semantics are exactly the behavioral traits an agent needs before calling a paid endpoint, and none of it is derivable from the schema.

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?

One dense paragraph, but it is deliberately ordered: trigger, input, output, example, price. The output enumeration is long yet every item earns its place because the agent needs to know this single call replaces several. The trailing price sentence is arguably its own concern but is front-adjacent enough to remain useful.

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

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

With a one-parameter schema, no output schema and no annotations, the description must supply everything, and it effectively does: the agent knows the trigger, the accepted input form, the failure mode, the full response shape and the cost. Nothing required to decide whether and how to call it 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 description coverage is 100% for the single parameter, and the description's 'url or bare domain' plus the example '?url=stripe.com' largely restate what the schema already documents, including the https:// assumption. No added semantics such as length limits, encoding requirements or IDN handling, so this sits at the mandated 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 states a specific verb-and-resource pair ('vet or research a website in one call') and enumerates the resource surface precisely: page metadata, HTTP status, HTTPS/redirect, security headers, robots.txt/llms.txt, DNS, mail auth, RDAP. That is far more specific than a title restatement. However it never names or differentiates from the obvious siblings web_metadata and domain_lookup, so the agent has to infer the overlap boundary itself.

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 concrete when-to-use triggers ('lead research, security or SEO check, is this site legit'), which is stronger than implied usage. It stops short of a full 5 because there are no exclusions or alternatives named, despite two sibling tools who would be candidates for a narrower version of the same task.

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

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

With no annotations, the description carries the full burden and does well: it discloses error semantics (400 bad input, 422 not-a-mint, 404 unknown, no charge on failures), billing ($0.002 via x402), and the shape of the returned JSON. It does not mention rate limits, caching, or whether failures on the same mint are retried, which keeps it out of the top band.

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-loaded with the usage trigger, then Input, Output, error behavior, example and price — every clause carries information and there is no filler. The list-style output enumeration is dense but scannable.

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

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

No output schema exists, so the description must describe returns, and it does so field-by-field including the Token-2022 extension set. Combined with error codes and pricing, an agent has everything needed to decide and 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?

Only one parameter and schema coverage is 100%, so the schema already covers base58/32-byte format and error codes. The description adds a concrete worked example (`?mint=EPjFWdd5...`) that makes the expected identifier form immediately recognizable, which is a small but real gain over 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?

Names a specific resource (Solana SPL / Token-2022 mint) and enumerates exactly what it returns: supply, decimals, authorities, extensions, issuer. The 'basics' framing cleanly separates it from the adjacent sol_token_risk sibling without opening either 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?

Opens with an explicit trigger — 'Use when an agent needs a Solana token's basics before quoting, transferring or accepting it' — which gives a concrete decision context. It stops short of naming sol_token_risk as the alternative for risk assessment, so the routing rule 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.