WarpPay402 Gateway

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive behavior, so the safety profile is covered. The description adds genuinely useful context that annotations do not: a per-call cost of $0.001 USDC. It does not otherwise describe resolution precision or failure behavior, so it is a modest addition over the 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?

A single front-loaded sentence with the core purpose first and the cost appended. No filler, no restated name, nothing 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 one-parameter, read-only tool with an output schema and full annotation coverage, the description supplies what is missing structurally: the cost. Return values are handled by the output schema. Only a brief note on input format or failure modes would make it 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?

A single parameter with 100% schema description coverage means the schema already fully documents 'address'. The description's phrase 'standardizes addresses' loosely confirms the input is a raw address string but adds no format, example, or constraint 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+resource: standardizing addresses and resolving lat/lon coordinates. The purpose is unambiguous and distinguishable from all siblings, none of which touch address normalization. It stops short of 5 only because it doesn't scope what kinds of addresses or what 'standardize' means in output terms.

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

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

No when-to-use guidance, no prerequisites, and no alternatives named. The agent must infer from the name and description that this is the tool for turning a raw address into a canonical form, but nothing states that explicitly or warns about when it is the wrong choice.

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

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

Annotations already declare destructive=true, idempotent=false, readOnly=false, and openWorld=true, so the safety profile is covered. The description adds domain context about concentrated liquidity ranges, but does not disclose what gets destroyed, whether token approvals are needed, or any rate-limit/auth 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?

A single front-loaded sentence with no wasted words. The parenthetical '$0.01 USDC' is ambiguous but does not significantly bloat the description.

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 multi-action, destructive, open-world LP tool with an output schema and rich annotations, the description is under-specified. It omits the collect action entirely, gives no per-action semantics, and provides no usage guidance to help an agent select the correct action.

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 action, token0, and token1. The description adds no parameter-level meaning, syntax, or constraints beyond the schema 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 domain and operation family: concentrated liquidity range management on Aerodrome Slipstream. It partially maps to the enum actions ('open' ≈ mint, 'adjust' ≈ increase/decrease), but omits collect and does not name or distinguish sibling tools like aerodrome_swap or aerodrome_veaero.

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 no explicit when-to-use guidance, prerequisites, or alternatives. The reader can infer it is for LP range operations, but nothing tells an agent when to choose this over aerodrome_swap or aerodrome_veaero.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the safety profile is covered and the description does not contradict it. The description adds only 'low-slippage' and the price note; it omits any warning that swaps are irreversible, that token approvals may be required, or how slippage is actually controlled.

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 front-loaded sentence that names the action, the router, and the network without padding. The trailing '($0.01 USDC)' is cryptic and slightly detracts, keeping it just short of 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?

An output schema exists, so return values need not be described. However, for a destructive, non-idempotent swap tool the description leaves key operational context unstated: approval/allowance requirements, absence of slippage-tolerance or deadline controls, and no routing guidance versus its aerodrome_clamm sibling.

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 each of the five parameters is already documented inline; that sets the baseline at 3. The description adds no parameter meaning beyond the schema, and notably does not explain that no slippage-tolerance or deadline parameter exists despite the 'low-slippage' claim.

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: executes token swaps via the Aerodrome Finance Router on Base Mainnet. It implies a router-level (spot pool) swap, but does not explicitly distinguish itself from the sibling aerodrome_clamm, so an agent must still infer when this versus the CLAMM tool is appropriate.

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?

There is no when-to-use or when-not-to-use guidance and no named alternative, despite several closely related Aerodrome siblings (aerodrome_clamm, aerodrome_veaero). The parenthetical '($0.01 USDC)' is unexplained and reads more like an incidental cost note than usage direction.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the mutation/irreversibility profile is covered structurally. The description adds one genuinely new behavioral fact, the $0.01 USDC fee per invocation, but omits auth/approval requirements and whether lock actions are reversible.

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

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

A single front-loaded sentence with no wasted words; the core resource and fee are stated immediately. It stops just short of being too terse for the number of sub-actions it bundles.

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?

An output schema exists so return values need not be explained, and annotations carry the safety profile. However, for a multi-action governance tool with destructive effects, the description says nothing about network/chain scope, token approvals, or how the five action values behave differently.

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

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

Schema description coverage is 100% and both parameters (action, amount) are documented with an enum for action, so the schema carries the parameter burden. The description only loosely maps its three named flows onto the five enum values and adds no formatting or unit detail beyond what the schema gives.

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 specific verbs and resources (AERO locking, epoch gauge voting, bribe reward harvesting) scoped to Aerodrome, which clearly separates it from swap/liquidity siblings like aerodrome_clamm and aerodrome_swap. It never explicitly names those siblings or states it is not a swap tool, but the activity described is distinctive enough that an agent can tell it 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?

There is no when-to-use or when-not-to-use guidance, no prerequisites, and no named alternatives among the 27 sibling tools. The action enum implies selectable flows, but the description gives no trigger conditions or routing advice.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint. The description adds one genuinely useful non-annotation fact: the call costs $0.001 USDC, which matters for an agent's decision to invoke it. It says nothing about rate limits, latency behavior, or freshness of the metrics.

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 front-loaded sentence naming the three data categories, with the cost appended last. No filler or redundant restatement of the tool name.

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?

An output schema exists, so return values need not be described, and the safety profile is fully covered by annotations. The description is nearly complete for a parameterless paid fetch, losing only sibling differentiation and usage context.

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 single optional parameter (includeLatency) is fully documented in the schema, so the baseline is 3. The description adds no syntax or format detail beyond what the schema already provides.

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

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

States a specific verb (Fetches) and resource (Arc Mainnet block height, gas fees, node metrics), so an agent knows exactly what data comes back. It does not differentiate itself from the overlapping sibling arc_network_oracle_query or base_analytics, which is the only thing keeping 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?

There is no when-to-use or when-not-to-use guidance and no named alternative, even though arc_network_oracle_query sounds like it could serve a similar need. Usage is only inferred from the data listed.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the agent understands this is an irreversible state-changing cross-chain operation. The description adds the useful cost context ($0.25 USDC), but says nothing about irreversibility, confirmation needs, or failure handling beyond what annotations supply.

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 sentence that front-loads the action and resource, then tacks on mechanism, source, and cost. No filler; every clause earns its place.

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

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

With an output schema present, return values need no explanation, and annotations cover the mutation/safety profile. The description supplies source chain and fee, which are the key contextual facts; only explicit usage guidance for choosing this over manual alternatives 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% and all three parameters are documented, including an enum for destinationChain, so the schema carries the burden. The description adds no parameter-level detail beyond what the schema already states, making 3 the correct 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 (Bridges), resource (USDC), source (Arc Mainnet), and mechanism (Circle CCTP), so the agent knows exactly what operation this performs. It does not differentiate from siblings, but no sibling tool offers cross-chain bridging, so the omission is minor.

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

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

Usage is implied by the description: use it when USDC sits on Arc Mainnet and needs to reach another chain. There is no explicit when-to-use/when-not statement and no named alternative, since none of the siblings overlap, so this is only minimally adequate.

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

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

Annotations already declare readOnly, openWorld and non-destructive, so safety is covered; the description usefully adds the Arc Mainnet network and the $0.001 USDC call cost, which is real behavioral context. It does not disclose price freshness/update cadence or any rate limits, so it stops at a 3.

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 front-loaded sentence with the core identity first and the cost parenthetical last. No filler, though it is a single bare sentence with no elaboration.

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?

An output schema exists, so return values need not be explained, and annotations carry the safety profile. However, for an oracle tool in a crowded sibling set, the description omits which pairs are usable and when to route here versus other price sources.

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 'pair' parameter, so the schema already explains it. The description's 'ETH/USDC' merely echoes the default value and adds no syntax or supported-pair-range detail beyond the schema.

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

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

The description states a specific verb+resource ('spot price resolver and DEX oracle') and scopes it to ETH/USDC on Arc Mainnet, which distinguishes it from forex_oracle and the network oracles. It stops short of explicitly naming which sibling to prefer, so it's clear but not fully differentiated.

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

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

There is no when-to-use or when-not-to-use guidance despite several competing oracle/tool siblings (forex_oracle, arc_network_oracle_query, data_feeds, public_data_feed). Usage is only implied by the 'ETH/USDC' scoping in the text.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and openWorld, so safety is fully covered. The description adds one genuinely new behavioral fact—the $0.10 USDC charge—but discloses nothing about auth requirements, rate limits, or cost behavior on retries.

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 sentence that front-loads the scope and lists the returnable signals plus cost. No filler, nothing repetitive.

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 an output schema present, return-value explanation is unnecessary, and the description correctly avoids duplicating it. For a two-boolean read tool whose annotations cover safety, the definition is nearly sufficient, lacking only explicit usage routing against sibling oracles.

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 booleans (includeGasTrends, checkMerchantAccount) are already fully documented. The description adds no extra parameter meaning, which is the expected baseline when the schema does the 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 concrete purpose ('Pre-flight Arc Mainnet telemetry') and enumerates the exact signals returned (RPC latency, gas prices, USDC balance, account nonce). This clearly separates it from sibling oracles like arc_dex_oracle or arc_analytics, though 'telemetry' is a noun phrase rather than a crisp verb+resource.

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

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

'Pre-flight' implies the usage context (a health/readiness check before acting), and the $0.10 USDC cost hints that it is a deliberate, occasional call. However, no alternatives or when-not conditions are named, so the agent must infer the timing 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds a real behavioral fact not present in structured data — the $0.002 USDC cost — which is valuable for an agent deciding whether to call it, but it says nothing about latency, rate limits, or error 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?

A single compact sentence that front-loads the action and resource and appends the cost. No filler, nothing to trim.

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?

An output schema exists, so return values need not be described, and annotations carry the safety profile. The description supplies the cost context and chain scope, leaving only usage-vs-alternatives unaddressed for what is a simple single-parameter read.

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

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

There is a single parameter and schema description coverage is 100%, with the schema already documenting 'Target 0x EVM wallet address on Base Mainnet'. The description contributes the chain/net constraint but no additional format or validation detail. 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 ('Fetches') plus the resource ('Base 0x wallet balance and nonce stats'), so an agent knows exactly what it returns. Chain/scope qualifiers (Base, 0x) implicitly separate it from chain-specific siblings like arc_analytics, but no sibling is named 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?

There is no statement of when to use this tool versus alternatives such as arc_analytics or arc_network_oracle_query, nor any prerequisites. Usage is only implied by the Base/0x scoping in the description.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=true and idempotentHint=false, so the safety profile is covered. The description adds one genuinely useful behavioral fact not in annotations: the per-call cost of $0.005 USDC, plus the 'unblockable' anti-bot claim. It says nothing about rate limits, latency, or failure modes.

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 front-loaded clause with no filler; each element (unblockable, JS-rendering, price) carries information. It is arguably terse to the point of under-specification, but nothing is redundant.

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?

An output schema exists, so return values need no explanation, and the single parameter is fully documented. What is missing is routing context against the many sibling retrieval tools and any note on blocking behavior, timeouts, or how the USDC charge is applied.

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

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

There is only one parameter and schema description coverage is 100%, so the schema already explains that the url must point to a dynamic or protected site. The description adds no syntax or format detail about the URL beyond that, 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?

The description names a specific verb+resource ('browser scraper') and qualifies it with the differentiating traits 'JS-rendering' and 'unblockable', which separates it from plain 'web_scraper'. It does not, however, explicitly contrast itself with siblings like web_scraper or render_screenshot.

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

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

Usage is only implied: 'JS-rendering' and the schema's 'Dynamic or protected website URL requiring headless browser rendering' suggest when this tool is needed over a static scraper, but the description never states when to use it versus web_scraper or render_screenshot.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so safety is covered. The description's one added behavioral fact is the cost ($0.001 USDC per call), which is genuinely useful for an agent deciding whether to invoke it, but it says nothing about freshness, rate limits, or what a feed contains.

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 terse phrase, zero filler, and the resource plus price are front-loaded. It is efficiently written, though the brevity borders on under-specification rather than pure concision.

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?

An output schema exists, so return values need not be explained, and the tool is low-complexity with one fully-documented parameter. However, a paying tool with a paid-call side effect and many overlapping siblings should at least state what a 'feed' is and when to choose 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%: feedId is documented with an example ('trending-pairs'). The description adds no information about valid feed IDs, discovery of IDs, or defaults, 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?

The description is a noun phrase with no verb: 'Pre-scraped AI data feeds' largely restates the tool name, though the modifiers 'pre-scraped' and 'AI' plus the price hint at a distinct resource. An agent can guess it retrieves pre-scraped feeds, but the action (list? fetch by ID?) is left implicit.

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

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

No when-to-use guidance is given, and no alternative among the many siblings (public_data_feed, web_scraper, browser_scraper, arc_analytics) is named or excluded. The only selection aid is the embedded price.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the write/irreversible nature is covered structurally. The description adds the concrete cost ($5.00 USDC) and the target network, which are useful operational facts, but says nothing about payment authorization or what happens on failure. With annotations carrying the safety profile, this is adequate but thin.

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 compact sentence with the action, the contract scope, the network, and the cost front-loaded; no filler. The only defect is the inaccurate 'agent' term, which is a precision issue rather than bloat.

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

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

An output schema exists, so return values need not be explained, and annotations cover the write semantics. What remains missing for a paid, irreversible mainnet deployment is guidance on prerequisites, alternatives, and confirmation/payment 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% and the single enum parameter is fully documented in the schema, so the baseline is 3. The description's enumeration of contract types partially duplicates the enum but introduces 'agent', which is not a valid value, adding confusion rather than meaning.

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

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

States a specific verb (deploys) and resource (escrow/bounty/agent smart contracts) and names the target chain (Arc Mainnet), which separates it from deploy_contract and deploy_solana_contract. However the description names an 'agent' contract while the schema enum lists 'subscription' instead, a small mismatch that muddies what can actually be deployed.

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

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

No guidance on when to pick this over the sibling deployment tools (deploy_contract, deploy_solana_contract) or what prerequisites exist. The only implicit cue is the $5.00 USDC cost, which hints at a paid mainnet deployment but doesn't route the agent between alternatives.

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

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

Annotations already declare the safety profile (readOnlyHint=false, destructiveHint=true, idempotentHint=false, openWorldHint=true), so the description only needs to add beyond that. It contributes the real, non-annotation detail that each deployment costs $5.00 USDC on Base Mainnet, which materially affects invocation decisions. It does not state irreversibility, wallet/auth requirements, or failure modes, keeping it out of 5 territory.

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 front-loaded sentence that packs verb, resource, chain, and cost with zero filler. Nothing could be removed without losing selection-relevant 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 an output schema present, return values need not be explained, and the single enum parameter is fully covered by the schema. The description supplies chain and cost context that an agent needs to choose between the deploy_* siblings. It is nearly complete, missing only explicit routing guidance to the alternatives.

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

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

There is only one parameter and schema description coverage is 100%, so the schema already fully documents contractType including its enum values. The description's enumeration of 'escrow, bounty, or agent' adds no syntax or format detail and actually diverges from the enum, so it neither compensates nor extends meaningfully.

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 (Deploys) and resource (smart contracts) plus the target chain (Base Mainnet), which implicitly separates it from the sibling deploy_arc_contract and deploy_solana_contract. It stops short of naming those siblings or explicitly contrasting them, and the listed contract types ('escrow, bounty, or agent') only partially match the enum (which includes subscription and pendle and omits '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?

The chain and price hint at when this tool is appropriate (Base deployments instead of Arc/Solana), and the $5.00 USDC cost is a useful selection signal. However, there is no explicit when-to-use/when-not-to-use guidance, no prerequisites, and no reference to the alternative deploy tools by name.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the safety profile is covered. The description adds genuinely useful context beyond that: this is a paid operation ($5.00 USDC) on Mainnet (real funds). It stops short of saying whether the fee is charged on failure or how retries behave despite non-idempotency.

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

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

A single dense sentence with the cost front-loaded-ish and zero filler; the resource list is the only heaviness, and it maps directly to the enum. Appropriately sized for the amount of information conveyed.

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?

An output schema exists, so return values need not be described. However, for a destructive, non-idempotent, paid deployment tool whose `params` object is entirely untyped, the description omits what happens on partial failure, whether the fee is refunded, and what keys the params object expects.

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 contractType enum is self-documenting, so baseline 3 applies. The description's list of contract types merely mirrors the enum and adds no new meaning, and it does nothing to clarify the opaque `params` object, which is typed only as a generic object with no defined properties.

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 ("initializes") plus the exact resource types (SPL Escrows, cNFT Badge Issuers, Raydium Vaults) and pinpoints the chain (Solana Mainnet), which cleanly separates it from the deploy_contract and deploy_arc_contract siblings. An agent can identify the tool 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?

Usage is only implied: an agent infers this is the Solana-deployment tool and that it costs $5.00 USDC. There is no explicit when-to-use/when-not-to-use guidance, no prerequisites (wallet, funding, network config), and no routing statement pointing to the sibling deploy tools.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=false, so safety is covered. The description adds genuinely useful context the annotations lack: the $0.01 USDC cost per call, which matters for an agent deciding whether to invoke it. It stops short of explaining payment mechanics or rate limits.

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

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

A single front-loaded sentence with zero filler; the cost is appended compactly in parentheses. Very efficient, though extremely terse relative to the tool's complexity.

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?

An output schema exists so return values need no explanation, and annotations cover safety. But for a paid, open-world extraction tool with a nested schema parameter, the description omits usage guidance and any payment/auth mechanics, leaving meaningful 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 description coverage is 100%, so both url and schema parameters are already documented in the schema. The description adds nothing about the schema parameter's format or how extraction targets are specified, 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 (extracts) and resource (structured JSON data from web pages), which is clear and distinguishable from pdf_extractor or web_scraper by the structured-JSON output framing. However, it does not explicitly differentiate itself from sibling scraping tools like browser_scraper or web_scraper, which would be needed for 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?

No indication of when to use this over web_scraper, browser_scraper, or pdf_extractor, nor any prerequisites (e.g., payment, auth). The agent must infer usage from the name alone.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=false, and destructiveHint=false, so the safety and idempotency profile is covered. The description adds a pricing detail ($0.0005 USDC), which is useful behavioral context, but does not describe latency, data source, rate limits, or error 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?

A single sentence with the core purpose front-loaded and no filler. The cost annotation is the only extra and it earns its place by informing invocation cost.

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

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

For a one-parameter read-only oracle with an output schema and rich annotations, the description covers purpose and cost adequately. It does not need to explain return values because an output schema exists, though it could mention base-currency behavior or data freshness.

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 single baseCurrency parameter is fully documented in the schema with its default. The description adds no parameter meaning beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb ('Resolves') and resource ('real-time global foreign exchange fiat rates'), clearly distinguishing this oracle from siblings like weather_oracle or arc_network_oracle_query. The parenthetical cost is incidental but the core 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?

Provides no when-to-use guidance, no alternatives, and no conditions for selecting this tool over other oracle/data-feed siblings. Usage is only implied by the name and resource phrase, so the agent must infer context.

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

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

Annotations already establish readOnly, idempotent, openWorld, and non-destructive behavior. The description adds genuinely new context — that this is a paid call ($0.003 USDC) with live data — but says nothing about rate limits, caching, or data staleness, so it is useful without being rich.

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

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

One tightly packed sentence that front-loads the core purpose and appends the data sources and cost. Efficient, though the trailing price parenthetical is slightly awkward in an otherwise content-focused sentence.

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?

An output schema exists, so return-shape explanation is unnecessary, and the description still names the returned fields and sources. The main gap is the absence of when-to-use routing among the many Aerodrome and oracle siblings.

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 single minTvlUsd filter is fully documented in the schema already. The description adds no extra meaning about thresholds, units, or default behavior, which is the expected baseline when the schema does the 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 verb and resource ('Fetch live Aerodrome DEX pool yields') and enumerates the returned data (APYs, TVL, pool addresses, DefiLlama UUIDs). Clear on its own, but it never distinguishes itself from closely named siblings like aerodrome_clamm, aerodrome_swap, or aerodrome_veaero.

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

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

No indication of when to use this tool versus the other Aerodrome or oracle siblings, and no prerequisites or exclusions are stated. The only operational note is the price, which is a cost signal rather than usage guidance.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=false, covering the safety profile. The description adds two valuable pieces of context beyond the annotations: the operation is limited to public repositories and carries a per-call cost of $0.002 USDC, which an agent needs to know before invoking a paid 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?

A single, front-loaded sentence with no filler. It packs purpose, scope, and cost into minimal text, with nothing that could be removed without losing 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?

An output schema exists, so return-value details are unnecessary in the description, and the annotations cover the safety profile. The description supplies purpose, public-repo scope, and cost, which is nearly complete for a one-parameter read tool; only explicit usage guidance 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%; the single 'repository' parameter is fully documented as 'owner/repo format'. The description adds no additional parameter semantics, so the baseline of 3 applies when the schema carries the full burden.

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 ('Queries') plus resource ('public GitHub repo stars, open issues, licenses, and push activity'), making the tool's output scope immediately identifiable. No sibling tool covers GitHub repository health, so the distinction is trivially clear without needing to name an alternative.

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 word 'public' implies the tool only applies to public repositories, which is useful scoping guidance, but there is no explicit when-to-use/when-not-to-use instruction and no alternatives referenced. Usage is only implied by the resource description.

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

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

Annotations already cover the safety profile (readOnly=true, destructive=false, openWorld=true, idempotent=false), so the description's real added value is the 'real-time' freshness signal and the explicit per-call price of $0.002 USDC, a payment/auth requirement an agent must know before invoking. It does not explain non-idempotent behavior, but 'real-time' implicitly signals results change between calls.

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 sentence front-loads the action, resource, scope, and cost with zero filler. Nothing needs trimming and nothing essential is buried.

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 an output schema present, return values need no explanation, and read-only annotations cover safety. The description supplies the domain, the lookup key, freshness, and price, leaving only minor gaps such as US-only coverage (implied by 'US ZIP') and behavior when no outages are found.

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 the required zipCode and the serviceType enum are fully documented in the schema. The description maps 'power grid, ISP broadband, and cellular network' onto the enum values, which adds minor semantic grounding but no syntax or format detail 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 (resolves), a concrete resource (power/ISP/cellular outages), and the lookup key (ZIP code), which cleanly separates it from sibling oracles like weather_oracle and forex_oracle. An agent knows exactly what domain data this returns.

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

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

Usage is implied by the tightly scoped domain (real-time outage lookup by ZIP), but there is no explicit when-to-use/when-not guidance and no routing to alternatives such as weather_oracle or data_feeds. The '(\$0.002 USDC)' note hints it is a premium paid call, which is useful context but not a usage rule.

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

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

Annotations already declare readOnly, idempotent, non-destructive and open-world behavior, so the safety profile is covered. The description adds genuinely new behavioral context: the call costs $0.005 USDC and returns a 'preview' (i.e., truncated) rather than full text, which an agent must know before invoking.

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

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

One compact sentence that front-loads the action, output type, input constraint, and cost. No filler to trim.

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?

Output schema exists so return values need not be described, and the cost and preview-scope caveats are disclosed. Minor gaps remain around size/page limits and failure modes for non-public or malformed URLs, but the essential picture is complete.

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

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

Schema description coverage is 100% for the single pdfUrl parameter, so the schema already carries the semantics. The description reinforces the 'public' constraint but adds no format or syntax detail 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 (Extracts) and resource (plain text preview from public PDF URLs), which cleanly separates it from generic siblings like web_scraper and browser_scraper. It does not explicitly name an alternative, so it stops short of a 5.

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

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

The phrase 'public PDF URLs' implicitly scopes usage to remote, publicly reachable PDFs, but there is no explicit when-to-use or when-not-to-use guidance and no named alternative among the many scraping/extraction siblings.

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

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

Annotations already declare readOnly, idempotent, open-world, and non-destructive, so safety is covered. The description adds a genuinely useful behavioral fact the annotations lack: the $0.005 USDC cost per call. It says nothing about latency, rate limits, or freshness of comps, so it is incrementally but not richly transparent.

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

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

One front-loaded sentence naming the three outputs, with the cost appended parenthetically. Nothing is wasted, though the parenthetical cost could arguably be its own clause for clarity.

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?

An output schema exists, so return values need no explanation, and annotations cover the safety profile. What is missing is routing context versus real_estate_calculator and any hint about data freshness or coverage, which matters for an open-world valuation tool.

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

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

Schema description coverage is 100%, so zipCode, bedrooms, and squareFeet are already fully documented in the schema. The description adds no format or constraint detail beyond that, 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 (Generates) and three concrete deliverables (market valuations, price-per-sqft comps, annual tax estimates), so the agent knows exactly what comes back. It does not differentiate from the sibling real_estate_calculator, which likely overlaps, so it stops short of a 5.

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

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

There is no when-to-use, when-not-to-use, or alternative-tool guidance. With real_estate_calculator among siblings, the agent has no basis in the description for choosing between them.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds one genuinely useful piece of behavioral context – a cost of $0.0001 USDC per call – which annotations do not convey, though payment/auth mechanics remain unstated.

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 front-loaded line with no filler, and the cost term is placed where it is immediately visible. It is arguably too terse, but nothing in it 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?

With only one required parameter, an output schema already present, and annotations covering mutation semantics, there is little an agent needs beyond what is provided. The main residual gap is not knowing how to choose this tool over the sibling "data_feeds."

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 single filename parameter is already documented with an example in the schema. The description contributes nothing beyond that, so the baseline of 3 applies.

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

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

The description names a resource ("public attestation data feed JSON records") but supplies no verb, so it is unclear whether it fetches, lists, or streams the records. It also fails to distinguish itself from the near-identical sibling "data_feeds," leaving an agent to guess which one to pick.

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

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

There is no when-to-use, when-not-to-use, or alternative guidance at all. With a sibling literally named "data_feeds" plus many *_oracle tools in the set, the absence of routing context is a real selection hazard.

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

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

Annotations already declare readOnly=true, idempotent=true, destructive=false, closed-world, so the safety profile is covered. The description adds genuine behavioral context beyond that: the call costs $0.0005 USDC, which tells an agent this is a paid operation. It does not explain payment mechanics or any rate limits.

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

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

A single tight sentence with the outputs and the cost front-loaded and zero filler. Nothing could be removed without losing 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?

Output schema exists, so return values need no explanation, and annotations carry the safety profile. The description covers purpose and price, leaving the only real gap as how NOI/DSCR can be derived from just purchasePrice and monthlyRent (hidden expense/loan assumptions) and any usage routing.

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

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

Schema description coverage is 100% with only 2 parameters, so the schema already documents both inputs fully; the baseline is 3. The description adds no syntax or unit detail beyond what the schema provides, though it does imply these two inputs drive the listed metrics.

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 ('Calculates') plus the exact metrics returned (NOI, Cap Rate, Monthly Cash Flow, DSCR) for a defined domain (real estate deals). This clearly separates it from siblings such as property_comps_estimator, which estimates comps rather than underwriting 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?

No indication of when to use this tool versus the nearby property_comps_estimator, nor any prerequisites (e.g., which deal inputs are needed). The only context provided is that it costs money, which is not usage guidance.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint=false and destructiveHint=false, so the safety profile is covered. The description adds a genuinely useful behavioral fact not present in any structured field: the call costs $0.01 USDC. It still says nothing about latency, rendering timeouts, or failure modes.

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 short sentence, front-loaded with the action and resource, with the cost appended rather than padding the sentence. No wasted words.

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

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

For a single-parameter tool with an output schema and rich annotations, the definition covers what it does and what it costs. The missing piece is routing guidance against the numerous web-fetching siblings, which is a real but modest gap.

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

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

Schema description coverage is 100% with a single documented 'url' parameter, so the schema fully carries the parameter burden and the description adds no syntax or format detail. 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 ('Captures rendered webpage screenshot image data'), and the phrase 'screenshot image data' differentiates it from text-returning siblings like web_scraper and browser_scraper. It does not name those siblings explicitly, so it falls just short of a 5.

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

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

No guidance on when to choose this over browser_scraper or web_scraper, which are the obvious alternatives in the sibling list. The only usage-adjacent signal is the price, which implies a paid call, but there is no stated condition for using 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?

Annotations already declare readOnly, idempotent, non-destructive behavior. Description adds the $0.001 USDC cost detail, which is useful context beyond annotations, but does not explain rate determination or output structure.

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

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

Single, front-loaded sentence with zero waste. Price detail in parentheses is relevant and concise.

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?

Output schema exists, so return values need not be explained. Description covers what the tool does, pricing, and tiers; only usage context and rate methodology are absent, which is minor given the schema and annotations.

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

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

Schema coverage is 100%, so parameters are fully documented. Description adds no parameter details, making the baseline 3 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?

States a specific verb+resource (calculates shipping rates) and names the three tiers (ground, priority, express). It does not differentiate from siblings, but no sibling overlaps, so 4 is appropriate.

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

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

Implies use for shipping rate estimation but gives no when-to-use guidance, no prerequisites, and no alternatives. Adequate but minimal.

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

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

Annotations already establish that this is a safe, read-only, idempotent, open-world operation, so the description does not need to repeat those traits. It adds a key behavioral fact beyond the annotations: the tool costs $0.02 USDC per call, which is important for an agent to know before invoking it.

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

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

The description is a single front-loaded sentence that lists the main capabilities and ends with the cost. There is no redundant or filler text.

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

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

With an output schema present, the description need not explain return values, and annotations cover the safety profile. It mentions the key operations and cost, but omits any usage guidance or prerequisites, which is a minor completeness gap for a paid verification tool.

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

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

Schema description coverage is 100% for the single address parameter, and the schema already explains that it is a Base contract address to verify on Basescan. The description adds no parameter-level meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description names three specific operations — source code analysis, ABI fetching, and proxy validation — so an agent can tell it is a contract inspection/verification tool rather than a deployment or swap tool. It does not explicitly differentiate itself from all siblings, but the verb+resource combination is 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?

There is no guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. The description only states what it does and the cost, leaving usage context entirely 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?

Annotations already declare readOnly, non-destructive, open-world, non-idempotent behavior. The description adds the materially important fact that the call costs $0.001 USDC, which is real behavioral context (a payment requirement) not present in the annotations. It stops short of auth mechanics or rate limits, but the cost disclosure is genuinely valuable.

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 front-loaded sentence with the verb and resource first and the cost trailing as a secondary detail. No wasted words, though the unexplained 'clearances' clause is arguably filler that could be clarified.

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?

An output schema exists, so return-value description is unnecessary, and annotations cover the safety profile. Still missing is any guidance for choosing this over sibling oracles and any explanation of the 'flight safety clearances' output, leaving modest 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% and both latitude/longitude are documented in the schema, so the description carries no extra semantic burden. It adds nothing beyond the schema, matching the baseline of 3.

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

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

States a specific verb (Fetches) and resource (live atmospheric conditions), which clearly separates it from oracle siblings like outage_oracle and forex_oracle. However, the appended phrase 'flight safety clearances' is ambiguous and never explained, slightly muddying what the tool actually returns.

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?

There is no statement of when to use weather_oracle versus the many other *_oracle tools, and no prerequisites or exclusions are given. The description is purely a capability statement with no routing guidance.

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

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

Annotations already declare read-only, open-world, non-destructive, and non-idempotent behavior. The description adds useful cost context ($0.001 USDC), but does not disclose rate limits, authentication needs, or handling of dynamic pages beyond what the annotations provide.

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 front-loaded sentence that states the action, output format, and cost with zero wasted words. The cost is placed at the end without disrupting 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?

For a simple one-parameter tool with an output schema and rich annotations, the description is nearly sufficient: it explains purpose, output format, and cost. The main gap is sibling routing against browser_scraper, which is more of a usage-guidelines concern.

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 single url parameter is already documented as the target public website URL. The description does not add syntax, format, or validation details beyond the schema, so the 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 (Scrapes), resource (web pages), and output format (clean markdown), so the agent knows what it does. However, it does not distinguish itself from the sibling browser_scraper, which likely has overlapping functionality.

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

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

No explicit when-to-use, when-not-to-use, or alternative tool routing is provided. The sibling browser_scraper is especially relevant but unmentioned, leaving the agent to infer when this tool is preferred.

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