OrbitWan.io

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

Annotations already cover the safety profile (readOnly, non-destructive, closed-world), so the description's added value is the match semantics: case-insensitive substring across label/project/kind, a 50-match ceiling per call, and total_matches for the full count. The injection warning about treating labels as data is a genuinely useful behavioral caveat. Minor tension between "up to 50 matches per call" and the schema limit default of 25 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?

Three tight sentences, front-loaded with the core action and return shape, then filters, then the cap and safety caveat. No filler 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?

With no output schema, the description steps in to say it returns addresses plus total_matches, and it discloses the per-call ceiling. The only real gap is how the limit parameter interacts with the 50-match cap, which an agent would need to know to paginate 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 0%, so the description must compensate and it does for two of three parameters: query is defined as case-insensitive substring over label/project/kind, and type is described with example values. The limit parameter is never explained, leaving the relationship between limit and the stated 50-match cap ambiguous.

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: search the curated tag registry by name and return Wanchain addresses matched on label, project or kind. The matching fields and the example ("every wallet tagged Binance") make it easy to separate from siblings such as get_address_tags, which goes the opposite direction (address to tags).

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 usage context via the Binance example and names the optional type filter (exchange, validator, token, contract). It does not explicitly say when not to use it or point to an alternative sibling, 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that pagination is cursor-based, which is useful behavior beyond the annotations, but it omits ordering (newest first?), what 'recent' bounds mean, and whether results include failed transactions.

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; the scope (Wanchain address) and pagination model are stated immediately.

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 five parameters, 0% schema coverage, and no output schema, the description leaves too much unspecified: which chains are covered, whether activity is inbound/outbound/both, what the category filter does, and what shape the returned records take.

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 0%, so the description must carry parameter meaning, and it only partially does: 'transactions, token transfers, or internal calls' loosely maps to the view enum (txs/transfers/internal). The category enum with 8 values, the limit default/maximum, and how cursor values are obtained are all left unexplained.

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 (transactions, token transfers, internal calls) scoped to a Wanchain address, which is more informative than the bare name. It does not contrast itself with near-siblings such as get_address_ledger, get_address_crosschain or get_address_flows, so an agent must guess which activity view 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 indication of when to choose this over get_address_ledger, get_address_crosschain, get_address_flows, or get_address_summary despite several overlapping siblings. The only implicit guidance is the word 'Recent', which is not framed as a selection criterion.

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

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

Beyond the readOnly/openWorld/destructive annotations, it explains provenance (decoded from task board events), exact inclusion rules (successful outbound and paid transactions), ordering (newest first), pagination (cursor), and units (base-unit integer strings). This is substantial 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 and dense with no filler, but the first sentence is a long chain of clauses that could be broken up for easier scanning. Still appropriately sized for the amount of return detail 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?

There is no output schema, so the description carries the return-value burden; it does that well with inclusion rules, ordering, pagination, and units. It is slightly incomplete on optional parameter semantics (limit) and error/empty 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?

With 0% schema description coverage, the description adds meaning for address (Wanchain address) and cursor (cursor pagination), but says nothing about limit and does not clarify cursor format or address encoding. It partially compensates for the schema gap.

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 (Bridge to Earn activity) scoped to a Wanchain address and states the data source (task board events). This is clearly distinguishable from list_bridge_to_earn_tasks and get_bridge_activity by its address-level, event-decoded activity focus, even without naming siblings.

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

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

It gives clear context that this is for an address's Bridge to Earn activity, so use is implied. It does not say when to prefer it over list_bridge_to_earn_tasks, get_bridge_activity, or prepare_bridge_to_earn, nor note prerequisites or 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?

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds genuinely non-structured behavior: results are ordered newest first, output is paged ('rows is one page'), and count_30d is a 30-day total rather than a page-scoped count.

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

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

Two tight sentences, with scope front-loaded before the return-shape note. The second sentence is telegraphic ('count_30d is the 30-day total; rows is one page') but every clause carries real 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 usefully sketches the return shape (rows plus a 30-day count) and paging behavior. It leaves gaps for a 3-parameter tool with 0% schema coverage: limit bounds, cursor semantics, and address-chain interpretation are all 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 0%, so the description must carry all three parameters, and it does not name any of them. 'newest first' and 'rows is one page' gesture at cursor/limit paging but never state that limit defaults to 25, what cursor encodes, or which chain the address is interpreted on.

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

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

The description gives a concrete verb+resource: cross-chain bridge transfers where the given address is sender or recipient, on any chain. That scope cleanly separates it from address-scoped siblings like get_address_bridge_to_earn and aggregate tools like get_crosschain_stats, though it never names an alternative explicitly.

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

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

Usage is implied by 'the rows the site's Cross Chain tab shows' and the sender-or-recipient framing, so an agent can infer when this fits. There are no explicit when/when-not rules and no named alternative such as orbitpay_crosschain_history or get_bridge_activity for the aggregate 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?

Annotations already establish that this is a non-destructive, closed-world read, so the description correctly spends its words elsewhere: it discloses the output encoding ('base-unit integer strings') and the 1-90 day window bound, both of which are non-obvious. Worth flagging that the stated 1-90 day bound conflicts with the schema, which allows any integer up to 9007199254740991 and negative values, so an agent may not know which limit governs.

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

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

Two sentences, no filler, and the substantive content (what is summed, for which chain, over what window) is front-loaded. The units note is a tight second sentence that earns its place.

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

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

With no output schema and no parameter documentation, the description carries real burden, and it does explain the shape of what comes back (per-token in/out sums plus native flows, integer base units). It stops short of saying how tokens are keyed in the response or whether zero-activity tokens are included, which leaves a small gap for an agent that must post-process 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 description coverage is 0%, so the description must carry both parameters, and it does: 'address' is typed as a Wanchain address and 'days' is given meaning as a 1-90 day window (with a default of 30 visible only in the schema). The only weakness is the mismatch between the stated 90-day ceiling and the schema's effectively unbounded maximum.

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 output (per-token in/out sums plus native WAN flows) scoped to a Wanchain address and a time window, which is concrete enough to picture the result. It does not explicitly contrast itself with near-neighbours like get_address_activity, get_address_ledger, or get_address_holdings, so the agent must infer the boundary from the word '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?

There is no statement of when to reach for this tool versus the ~39 siblings, several of which are plausible substitutes for address-level history. The 1-90 day window bound is a constraint on a parameter rather than usage routing, so nothing tells the agent when this 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 cover the safety profile (readOnly, non-destructive, closed-world), and the description usefully adds provenance (decoded from the governor's own events) and an output-format note (amounts are base-unit integer strings). It still omits ordering, pagination, and whether empty results are possible for non-participants.

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: purpose first, then the precise event definition, then returned fields, then the amount format. Nothing is redundant with the title or annotations.

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

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

With no output schema, the description does the right work by enumerating the returned concepts (proposal, vote, pledge mechanism, voting power, assets) and the amount encoding. Only result ordering and volume characteristics are left unspecified.

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

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

Schema coverage is 0% for the single `address` parameter, so the description must carry that weight. Saying 'for a Wanchain address' identifies what the parameter means but not its expected format (e.g. 0x-prefixed hex), which is the one detail an agent could get wrong.

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 (governance activity) and the exact scope (only governor-sent transactions and governor payouts), which separates it from the generic get_address_activity sibling by implication. It never names the sibling explicitly, so an agent must infer the boundary rather than being told 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?

The scope sentence ('every successful transaction it sent to the governor and every governor transaction that paid it') implies when the tool applies and implicitly excludes general activity, which is useful. But there is no explicit 'use X instead when Y' routing among the many get_address_* 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 read-only, non-destructive, closed-world, so the bar is lower, yet the description still adds real behavioral context: the read is pinned to one block, prices come from OrbitWan's table, amounts are base-unit strings, and the total is nulled with a failed count when any per-token read fails. That partial-failure semantics is exactly the kind of detail annotations cannot carry.

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

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

Three short sentences, each carrying distinct information: what is returned, how amounts and prices are derived, and how failures are surfaced. No filler and the core identity is front-loaded.

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

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

With no output schema, the description takes on return-value explanation and does reasonably well (base-unit string amounts, priced values, null total plus failure count). The shape of the per-token list itself and address format expectations are the remaining minor 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 0% for the single required 'address' parameter, so the description must compensate. It only implies the parameter ('of an address') without specifying expected format (hex, checksummed, chain prefix), so it partially but not fully closes the gap.

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 (token balances of an address) with a clear verb (read live at one pinned block), which separates it from siblings like get_address_activity or get_address_flows. It does not explicitly name which sibling to use for non-balance questions, but the resource 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?

There is no when-to-use/when-not guidance and no mention of alternatives (e.g., get_token_prices for price-only queries, list_tokens for token metadata). The description describes what the tool returns rather than when to select it over the many adjacent get_address_* 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 read-only, non-destructive, closed-world, so the safety profile is covered. The description adds genuinely non-obvious behavior: node-paid lines carry a null tx_hash and instead name cause_tx and cause_method, and reconcile triggers a from-genesis summation compared against node balance. Missing only things like rate limits or ordering guarantees beyond 'newest first'.

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 what the tool returns, then the null-tx_hash edge case, then paging. Dense and mostly run-on sentences, but no filler — every clause carries semantic 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?

With no output schema, the description must convey the return shape, and it does precisely: per-line signed amount, counterparty, transaction reference, and post-transaction balance, plus how node-originated entries differ. Paging and the reconcile option are both covered, so an agent can call this correctly without further 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 coverage is 0%, so the description must carry the parameters, and it does: limit is narrowed to 1-100 (the schema's actual minimum is a meaningless -9e15), cursor is defined as next_cursor from the prior answer, and reconcile is defined as a genesis-summing cross-check. The address parameter is only implicitly covered by 'ledger of a Wanchain address', which keeps this off 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 — the WAN ledger of a Wanchain address, every WAN in and out, newest first — and enumerates the per-line fields (signed amount, counterparty, transaction, post-balance). This makes it distinguishable from siblings like get_address_activity, get_address_flows and get_address_summary, which would otherwise read as vague overlaps.

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 explains how to page (limit 1-100, cursor from the previous answer) and what reconcile=true does, which is real usage context. But it never says when to pick this over get_address_activity or get_address_flows, leaving sibling choice to inference.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so safety is covered; the description adds real context beyond them — the data comes from OrbitWan's own node, and every program carries ok/complete/floors so unread or partial figures are not silently presented as zero. It does not mention auth, rate limits, ordering, or pagination.

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

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

Three sentences, front-loaded with the resource and scope, then the integrity flags rule, then the unit convention. Dense but each sentence adds information; no filler or 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?

With no output schema, the description usefully pre-empts the biggest misreading of the results (partial/unread values masquerading as zero) and states that amounts are base-unit integer strings. The remaining gap is input-side: nothing about address format or what the response contains per program beyond principal and pending rewards.

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 0% for the single required 'address' parameter, so the description must carry the burden — but it only says the input is 'a Wanchain address' with no format expectation (hex 0x prefix, case, checksum) or validation behavior. The sentence about base-unit integer strings describes output magnitudes, not the parameter.

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

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

The description names the resource precisely: 'Staking, farming, lending and deposit positions for a Wanchain address,' and enumerates the covered programs (xStake, PoS staking, Bridge staking, WanLend, XFlows farming). That scope separates it from broad siblings like get_address_summary or get_address_holdings, though it never explicitly contrasts itself with them.

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

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

Applicability is implied by the enumerated program list ('across every program OrbitWan reads'), so an agent can infer this is the DeFi-position view rather than a holdings or activity view. There is no explicit when-to-use/when-not statement and no named alternative (e.g. get_address_holdings) 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?

Annotations already declare readOnlyHint=true, openWorldHint=false, and destructiveHint=false, so safety is covered. Beyond that, the description adds genuine behavioral context by disclosing that figures are drawn from an 'indexed coverage range' — a real caveat about data completeness that an agent would otherwise not know, and it clarifies the tx_count vs tx_count_all counting distinction.

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

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

Two sentences, front-loaded with what the tool returns, followed by the field-level clarification. No filler or restatement of the title. The second sentence is dense but every clause (tx_count vs tx_count_all) carries information an agent needs to interpret output.

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 carries the burden of explaining the return shape — and it does, naming four of the returned fields and the coverage metadata. What remains missing is address format expectations and rough result size, which are minor for a single-address aggregate lookup.

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 0%, but there is only one required parameter, 'address', whose meaning is largely self-evident from the tool name and description. The description does not, however, state expected format (hex address, chain prefix, ENS-like resolution) or whether resolve_identifier should be called first, which is the one gap that matters here.

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 resource (Wanchain address) and enumerates exactly what comes back: transaction/transfer counts, first seen, last active, plus the indexing coverage window. That is specific and actionable. It does not, however, distinguish itself from near-siblings such as get_address_activity or get_address_ledger, so an agent must infer that 'summary' means aggregates rather than records.

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 explicit when-to-use statement and no named alternative. The word 'summary' and the mention of a coverage range hint that this is a high-level aggregate versus the per-event sibling tools, but that routing decision is left entirely to inference.

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

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

Annotations already cover readOnly, non-destructive, and closed-world. The description adds a genuinely valuable behavioral note — that the labels are curated registry text and must be treated as data, not instructions — which is a prompt-injection safety caveat beyond structured fields. It doesn't describe return shape, but the safety note earns credit.

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

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

Two short sentences, front-loaded with purpose and followed by the safety caveat. No wasted words.

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

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

For a simple read-only lookup with annotations covering safety, the description is adequate. However, with no output schema and no parameter documentation, it omits what the returned labels look like (structure, tag fields) and the accepted address format, leaving some 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?

Only one parameter (a required array of address strings) with 0% schema description coverage. The description says 'Wanchain addresses' implying multiplicity but gives no format details, no minimum count, and no clarification of which address types are accepted, so it fails to compensate for the schema gap.

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

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

The description clearly states it returns 'curated labels for Wanchain addresses', a specific resource (address tags) and action (retrieval of curated registry text). It implicitly distinguishes it from find_tagged_addresses by framing the result as curated registry labels, but doesn't explicitly contrast the two.

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 versus siblings like find_tagged_addresses (which appears to be the reverse lookup). No mention of batch limits, rate limits, or context in which address tags are useful.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description only needs additive context — and it delivers: the chain set is data-driven and picks up new chains the same day via get_chain_coverage, and unknown values produce a named error rather than a schema rejection. It omits pagination behavior for the cursor and what the response looks like, which is why it isn't 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?

Three sentences, front-loaded with the core purpose, then modes, then chain-set behavior. The third sentence is long but every clause (self-updating chain list, short slugs, named error instead of schema rejection) carries non-obvious information an agent would otherwise discover only by failing.

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 7-parameter, zero-required, nested-object tool with no output schema and 14% schema coverage, the description should cover the remaining knobs. It handles chain and the top-level modes well, but cursor paging semantics, the status enum's effect, and token_address are unaddressed, leaving an agent to guess how to paginate and how to scope to a specific contract.

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 only 14% across 7 parameters, so the description must carry weight. It meaningfully explains chain (accepts any live slug, errors on unknown), and implicitly covers recent/symbol/counterparty via the mode list. But status, cursor, and token_address get no explanation anywhere, leaving a real gap.

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 a specific resource and verb ('Cross-chain bridge transfers from the transfers pipeline') and enumerates the three access modes (network-wide recent, by token, by counterparty). That scope distinguishes it from siblings like get_address_crosschain or get_crosschain_stats without needing to name them. It stops short of an explicit sibling contrast, keeping it at 4 rather than 5.

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

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

The mode list ('recent network-wide, by token, or by a counterparty on a foreign chain') gives an agent a clear selection rule for which parameters to combine. It also routes to get_chain_coverage for discovering valid chains. No exclusions or negative guidance (e.g. when to prefer get_address_crosschain instead) are stated.

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

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

Annotations already declare readOnlyHint, destructiveHint=false, and openWorldHint=false, yet the description still adds substantial behavioral context: the four states and what each means, that ratio exists only for COMPLETE, that a FLOOR ratio is a lower bound only, and that blocked_by names the blocker. The caveat 'A FLOOR ratio must never be read as the true ratio' is exactly the kind of misinterpretation guard the description should carry.

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

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

Front-loaded with the result semantics, and nearly every sentence contributes a rule an agent could otherwise get wrong. Minor redundancy in restating UNREADABLE twice, and 'returned exactly as the recorder route sent them' is thin added value, 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?

With no output schema, the description carries the return-value burden and does so well, covering states, ratio availability, blocked_by, and the run-level below_1 summary. The remaining gap is operational: no mention of pagination via limit, ordering of components, or how the history mode changes the response shape.

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

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

Schema coverage is only 25%, so the description must compensate. It does explain the state enum values in detail, which is the highest-risk parameter, and 'per token component' plus the history schema description cover symbol indirectly. However, the limit parameter, result ordering, and whether state/symbol filters are inclusive are never addressed.

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 and scope: custody-versus-liability observations from the newest finished recorder run, per token component. The 'recorder run' framing implicitly distinguishes it from the sibling get_bridge_solvency_live, but that sibling is never named, so the 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?

There is no explicit guidance on when to use this tool versus get_bridge_solvency_live, get_bridge_activity, or get_chain_coverage. 'Observations only' hints that it is a read of recorded data, but no condition, prerequisite, or exclusion is 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?

Adds substantial context beyond the readOnly/non-destructive annotations: per-scope refresh intervals (EVM sites every minute, other sites and scope all every 5 minutes), the meaning of each state (COMPLETE, FLOOR, UNREADABLE, NO_LIABILITY), the explicit warning that ratio_floor is a lower bound and never the true ratio, and 'Observations only'. That is exactly the caveat layer the schema and annotations cannot carry.

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

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

Purpose is front-loaded in the first clause and every sentence carries information. The prose is dense and comma-spliced in places (the scope sentence and the include_sites sentence run long), which costs a point on readability, 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?

With no output schema, the description must explain the return payload, and it does: it enumerates the per-component fields (state, custody_raw, liability_raw, ratio, ratio_floor, worst_case, verified, first_verified_at) and even defines the verification rule. Nothing material an agent needs to interpret results 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 0%, so the description must carry all parameter meaning — and it does: it defines both enum values of scope with their cost/freshness tradeoff, states that symbol filters to a single asset, and states the dependency that include_sites only works together with symbol and what it returns (sites chain by chain with address, value, block).

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: live WanBridge custody measured against bridge-issued supply, with the concrete anchor of the Bridge Solvency tab on orbitwan.io/data. It does not contrast itself with the sibling get_bridge_solvency, so an agent must infer that 'live' means current-state vs. the static/historical variant.

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 actionable selection guidance within the tool: scope majors (default) vs scope all and the different refresh cadence of each, plus 'symbol filters to one asset' and 'include_sites, with symbol only'. Missing the one piece of routing advice that matters most here — when to pick this over get_bridge_solvency — 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?

Annotations already declare readOnlyHint, so the description adds context about the returned data (counts and timestamp) without contradicting. No side effects mentioned, but the read-only nature is adequately covered.

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

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

The description is a single dense sentence that conveys all necessary information without fluff, using concise and specific language.

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 parameters and no output schema, the description sufficiently explains what data will be returned, making it complete for a user to understand the tool's purpose and output.

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 has no parameters, so the description does not need to explain them. The schema is trivially covered, and no additional parameter details are relevant.

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

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

The description clearly states the tool returns per-chain cross-chain transfer coverage, including counts as source and destination and the latest timestamp, which distinguishes it from other get_* tools that focus on addresses or transactions.

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

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

The description does not explicitly mention when to use this over alternatives, but the focus on chain coverage implies it is for network-level metrics. No explicit exclusions are given.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful context about the data source and notes that row counts are approximate, but it does not disclose freshness, update cadence, or empty/failure behavior. This is adequate but not 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?

A single dense sentence that places the key output terms first and contains no filler. The source qualifier 'OrbitWan Wanchain archive indexer' is relevant and is appended without bloating the 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?

For a zero-parameter read-only tool, this is nearly complete: it names the resource, the source, and the three categories of returned information. The absence of an output schema is partly mitigated by these specifics, though exact units or the format of 'head' and 'progress' are left unspecified.

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

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

The input schema has zero parameters with 100% coverage, so the baseline is 4; no parameter-level guidance is needed. The metrics mentioned in the description are return values, not arguments, so there is no semantic gap to compensate for.

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 identifies a specific status resource for the Wanchain archive indexer and enumerates the metrics returned: indexed head, genesis backfill progress, and approximate row counts. It lacks an explicit verb and does not contrast with the sibling get_chain_coverage, so it is clear but not fully differentiating.

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 is provided about when to use this tool versus alternatives such as get_chain_coverage, nor are there any exclusions or prerequisites. The only usage signal is the read-only annotation and the status-oriented wording.

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, destructiveHint=false, and openWorldHint=false. The description adds non-obvious behavioral context: a null creation result should not be treated as proof that no creator exists while the genesis backfill floor is above zero.

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

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

Two compact sentences: the first front-loads the returned fields, and the second adds an important caveat. There is little wasted text, though the first sentence is a noun phrase rather than an explicit verb statement.

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 read-only lookup with one parameter, the description covers returned fields and a key null-result caveat. However, it omits address format guidance and sibling-tool selection guidance, which are meaningful gaps 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?

There is one required parameter, 'address', with 0% schema description coverage. The description does not clarify the expected address format or confirm whether it must be a Wanchain contract address, leaving the parameter under-specified.

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 the specific record returned for a Wanchain contract: creator address, creation transaction, block, and timestamp. It is clear what resource is involved, but it does not explicitly differentiate this from sibling contract-oriented tools such as get_verified_contract.

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 explicit guidance on when to use this tool versus alternatives, nor any prerequisites. The caveat about null creation is useful interpretation guidance, but it does not tell an agent when this tool is the right 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 mark the tool as readOnly and non-destructive, so no safety caveats are needed. The description adds useful context: data source ('transfers pipeline'), 'raw' nature, and the specific aggregation dimensions returned. This is sufficient behavioral transparency for a zero-parameter 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?

A single, tightly worded sentence front-loads the key concept ('Raw cross-chain transfer tallies') and then lists concrete output categories. Every part of the sentence adds value; there is no fluff or repetition of the title.

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

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

For a zero-input read-only tool without an output schema, the description fully conveys what an agent will receive: counts by status, source chain, destination chain, and the latest transfer timestamp. No additional input or behavior details are needed 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?

The tool has zero parameters, so the empty input schema already conveys all parameter information. The description correctly implies no input is required by presenting pre-aggregated statistics. Baseline 4 is appropriate because there is nothing for the description to add beyond the schema.

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

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

The description uses a specific verb and resource ('Raw cross-chain transfer tallies') and lists exact data dimensions: counts by status, source chain, destination chain, and latest network timestamp. This clearly separates the aggregate stats tool from event-level siblings like get_bridge_activity.

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 'Raw cross-chain transfer tallies' implies this is for aggregate transfer counts rather than address-level flows or bridge activity, but no explicit when-to-use or alternative tool names are given. An agent must infer when this is preferable to get_bridge_activity or orbitpay_crosschain_history.

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 read-only, non-destructive, closed-world behavior. The description adds useful provenance—DefiLlama sourcing and WanBridge reachability—but does not explain return shape, pagination, or any other behavioral detail.

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 tightly written sentence with the key distinction front-loaded and no wasted wording.

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 needs to carry more weight about return values and structure. It does not explain what a yield opportunity or earn position contains, nor does it mention the section parameter, leaving the agent under-informed for 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 description coverage is 0%, and the sole section parameter with its wanchain/crosschain/all enum is not mentioned. The description obliquely distinguishes native and cross-chain categories, but it does not explain the parameter, the default 'all', or how filtering works.

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 resource—earn yields—and clearly splits Wanchain-native positions from cross-chain DefiLlama-sourced opportunities. It is distinguishable from sibling tools like get_address_bridge_to_earn and list_bridge_to_earn_tasks, though it does not explicitly say it returns a list.

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 describes what data exists but gives no guidance on when to use this tool versus related siblings such as get_address_bridge_to_earn or list_bridge_to_earn_tasks. No exclusions or conditions are stated.

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

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

Annotations already declare read-only, non-destructive, closed-world. The description adds genuinely non-obvious behavior: failed transactions are included in the count, only completed days are indexed so today is never returned, and the range is capped at 366 days. These are exactly the surprises an agent would otherwise hit.

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

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

Three sentences, front-loaded with the resource and metric list, then the 'day' mode, then the range mode and its constraints. Every clause carries information; nothing is restated from the title or 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?

With no output schema, the description takes on the job of describing return values and does list the metric fields and the top-10 breakdown. The only gap is precedence when multiple optional parameters are combined, and there are no required parameters to worry about.

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 0%, so the description carries the full burden and does so: it names each parameter's meaning, the YYYY-MM-DD format, the 366-day cap, and the 30-day default. It stops short of saying what happens when 'day' and 'from'/'to' are supplied together, which is the one ambiguity left.

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 (Wanchain network activity per UTC day) and enumerates the metrics returned (transaction count incl. failed, failed count, distinct senders, contract creations, block range). It's clear what the tool does, but it never contrasts itself with aggregate siblings like get_crosschain_stats or get_chain_status, so sibling differentiation is implicit 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?

Gives explicit invocation modes: pass 'day' for that day plus its top 10 recipients/senders, pass 'from'/'to' for a daily series, omit both for the last 30 days. That's clear operational guidance, but it explains how to call rather than when to prefer this over alternative stats 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?

The annotations already establish that this is a read-only, non-destructive, closed-world operation. The description adds useful context by listing returned fields and mentioning cursor pagination, but it does not explain error behavior, rate limits, or how the limit parameter affects the result.

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 definition is a single compact sentence with no filler. It front-loads the key returned fields and ends with the pagination note, making it efficient to scan.

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 helpfully enumerates the main fields returned. However, it does not fully specify the required address semantics or the limit parameter, so an agent still lacks complete context for invoking the tool correctly.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It only partially does so: 'cursor pagination' explains cursor, and 'Wanchain token contract' implies the address parameter, but 'limit' and its default behavior are never described, leaving a significant gap.

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

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

The description clearly identifies the resource and returned data: a Wanchain token contract with symbol, decimals, transfer_count, last transfer time, and recent transfers. It is specific, though it lacks an explicit verb and does not directly distinguish itself from siblings such as list_tokens or get_token_prices.

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

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

The description provides no when-to-use guidance, no prerequisites, and no named alternatives. An agent can infer that it is for token-level summary and transfers, but it is not told when to prefer this over list_tokens or get_token_prices.

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 a safe read (readOnlyHint=true, destructiveHint=false, openWorldHint=false), and the description adds non-obvious behavioral facts: the price source, that the zero address is native WAN, and that null is returned for unpriced tokens rather than zero. That null-vs-zero rule is exactly the kind of semantic the agent can't infer from structured fields. It does not mention batching behavior or rate limits, so a 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?

Four short sentences, front-loaded with the resource and source, then the zero-address convention, then the historical option, then the null-price caveat. No sentence is redundant and each adds information the 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?

With no output schema, the description must convey the return shape and it largely does ('USD price ... keyed by token address', plus null semantics). It could be slightly more explicit that the response is a per-address mapping and that Wanchain is the only supported chain, but an agent has enough 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 0%, so the description carries the full burden and does so for both parameters: the address is a token address keyed to a USD price, with the zero address meaning native WAN, and block selects the historical price point. It omits that addresses is a multi-item array (batch lookup) and that empty arrays are rejected, which is the only gap.

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 clause names the resource and unit precisely ('USD price per Wanchain token') and even names the data source ('OrbitWan's price table'), which no sibling tool covers. It does not explicitly contrast with nearby tools like get_token or list_tokens, 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?

'Pass block for the price at a past block' gives conditional guidance for the historical case, and the zero-address rule tells the agent how to price native WAN. However, there is no statement of when to reach for this tool versus get_token/list_tokens (metadata) or orbitpay_token_supplies, so routing 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so safety is covered. The description adds real value by disclosing the response contents (token transfers, cross-chain leg, internal calls), which matters since there is no output schema, but it says nothing about behavior for unknown hashes or partial/failed transactions.

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 no filler; the enumerations of returned data are the useful payload. It is a fragment rather than a full sentence, but that costs nothing in 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?

With no output schema, the field enumeration carries meaningful weight, and one required parameter is easy to infer. Still missing hash format/validation expectations and any note on error or not-found behavior, which an agent would need to call it reliably.

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 0% and the single 'hash' property has no description. The text implies the input identifies a transaction but never states the expected hash format (0x-prefixed, length) or whether it is a Wanchain tx hash versus a cross-chain message id.

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 and resource ('Full detail for a Wanchain transaction') plus an enumeration of what the detail contains (core fields, token transfers, cross-chain leg, internal calls). This clearly separates it from address-level siblings like get_address_summary and get_address_crosschain, though it does not explicitly 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?

No guidance on when to use this tool versus neighboring lookups such as get_address_activity or get_crosschain_stats, and no prerequisites (e.g., hash format or chain assumption) stated. Usage is only inferable from the name and the field list.

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

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

Beyond the readOnlyHint and destructiveHint annotations, the description adds meaningful behavioral detail: the available views, the default profile view, pagination limits for flows, the special 'Stake returned' label, the presence of found/type/name in every answer, and the exited-validator behavior. It does not cover auth requirements or rate limits, but for a read-only lookup it is substantially informative.

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

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

The description is compact and front-loads the core resource and view model, but it is a single dense paragraph with run-on phrasing such as 'flows pages with limit ... and includes stake returns'. It is not bloated, but its structure could be easier to scan.

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

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

For a read-only lookup with no output schema and four parameters at 0% schema coverage, the description covers enough: it explains the view model, pagination, and key return indicators (found, type, name, exited status). It still leaves some gaps around the address parameter's expected form and whether exactly one node is returned, but overall it is usable.

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

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

With 0% schema description coverage, the description carries the burden and mostly succeeds: it explains the view enum values and their node-type mappings, states the default profile view, gives a limit range and cursor meaning for flows, and implies the address parameter through the not-found behavior. The address parameter itself is not explicitly described as required or as a node address, and the stated limit range (1 to 25) differs from the schema's broad minimum/maximum, leaving a small semantic gap.

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 identifies the resource as a Wanchain PoS validator or Storeman node and implies a lookup by address, which is clear enough when paired with the tool name get_validator. It does not explicitly state a verb like 'returns' or 'retrieves', and it does not explicitly differentiate itself from list_validators.

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 node-type and view descriptions, but there is no explicit guidance on when to use this tool instead of list_validators or the get_address_* siblings. The description also does not state prerequisites or when-not-to-use conditions.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so safety is covered. The description does add that the ABI summary is always returned while full ABI and source files are opt-in, but it is silent on behavior for unverified contracts and on response size/pagination for large source bundles.

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; the semicolon cleanly separates the always-returned versus optional payload. Slightly dense but 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?

For a two-parameter read-only lookup with no output schema, the description covers the resource, the provenance aspect, and what each payload mode yields. No output schema exists, so return-shape explanation is appropriately kept high-level rather than exhaustive.

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 0%, so the description must compensate. It successfully explains include_sources as toggling the full ABI and source files, but leaves 'address' undefined (expected format, chain qualification) — a notable gap for an identifier-style parameter.

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

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

Names a specific resource (source-verification status and provenance for a Wanchain contract) plus the extra payload (ABI summary, optional full ABI/sources). It does not reference the obvious sibling list_verified_contracts, so an agent must infer that this is the single-contract lookup vs. the enumeration tool.

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

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

Usage is only implied: the required address argument makes the single-contract case apparent, but the description never states when to prefer this over list_verified_contracts or get_contract_creation, nor what happens when a contract is not verified.

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=false, and destructiveHint=false, so safety is covered; the description adds meaningful behavioral context beyond that - the data source ('read live from OrbitWan's own node'), the two fixed time windows, and the precise definition of burn (any WAN sent to 0x...dEaD via Convert n' Burn). It stops short of describing caching, pagination, or response shape.

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 governing question, then the metric definitions and scope in a dense two-sentence block with no filler. The closing note about the orbitwan.io homepage card is marginal but does convey which window a human-facing consumer defaults to, so it earns its place.

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

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

With no parameters and no output schema, the description carries the full burden of describing what comes back, and it does so: emission, burn, their ratio, and both time windows, plus the provenance of the data. An agent can predict the result set without any structured return definition.

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 there is nothing for the description to disambiguate; the baseline for a no-parameter tool is 4. The description correctly implies the time windows are fixed rather than caller-selectable, which prevents a false expectation of window arguments.

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 and question ('Is WAN deflationary?') plus the exact quantities returned: emission, burn, and burn/emission over 30-day and 12-month windows. It is unambiguous in scope, but never explicitly contrasts itself with plausible siblings such as get_network_stats or orbitpay_economics_series, which an agent might otherwise consider.

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

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

Usage is only implied by the framing question 'Is WAN deflationary?' and the mention that the orbitwan.io card opens on the 12-month window. There is no explicit when-to-use, when-not, or named alternative, so the agent must infer that this is the deflation-metric tool rather than a general stats 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?

Annotations already establish read-only, non-destructive, closed-world behavior. The description adds valuable caveats: limit capped at 25 and unavailable legs are reported as not_seen or not_indexed rather than pending or failed.

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 resource and then covers lookup, filters, and index limitations with little waste. The middle sentence is dense and could be split, but overall it is appropriately sized.

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 still says what a message record includes: source and destination legs, apps, payload, Storeman group, and failed delivery attempts. All six optional parameters and the index limitation are covered.

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

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

Schema coverage is 0%, so the description carries the parameter burden and does so well: key can be a message id or any message transaction, chain accepts a captured chain key or XPort chain id, app is 0x hex, limit is up to 25, and cursor is mentioned.

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, XPort (Wanchain Message Bridge) messages, and scopes it to OrbitWan's own index while enumerating what each record contains. It does not explicitly contrast itself with nearby cross-chain siblings such as get_address_crosschain or get_bridge_activity, so 4 rather than 5.

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

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

The description explains lookup behavior: key answers a specific message, otherwise newest-first with filters. That implies when to use it but gives no explicit when-not-to-use guidance or named alternatives among the many cross-chain/bridge 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 establish this as a read-only, non-destructive, non-open-world operation, and the description adds useful behavioral context: results are read at one Wanchain block, Express includes quote/rate/WAN balance and payment capacity, XFlows includes vesting periods, and the response includes exact approve and sell calls. It does not cover auth or rate limits, but it meaningfully supplements the annotations.

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

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

The description is front-loaded with the core purpose and packs route, vesting, and returned-call details efficiently. It is somewhat dense and grammatically knotty, but each sentence contributes useful information and there is little obvious 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?

There is no output schema, so the description carries the burden of explaining return content, and it does so by naming quotes, rates, WAN balance, payment capacity, vesting schedules, and exact approve/sell calls. It is complete enough for a read-only one-parameter tool, though amount formatting remains underspecified.

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

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

Schema description coverage is 0%, and the only parameter is amount. The description clarifies that amount is an xWAN amount being converted, but it does not specify units, formatting, decimal handling, or whether the value is human-readable versus raw. This is minimally adequate but leaves a meaningful gap for the sole parameter.

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

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

The description states a specific resource and outcome: the WAN amount an xWAN amount converts into by each route, read at one Wanchain block. It distinguishes the Express route from XFlows vesting routes, though the phrasing is a dense noun phrase rather than a direct verb-led purpose statement.

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 implies this tool is for comparing conversion routes and explicitly says no route is recommended, leaving the choice to the owner. It also notes that the wanchain-xwan-express skill covers selling, but it does not give a clear when-to-use/when-not-to-use rule or name an alternative tool for route comparison.

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, and openWorldHint=false, so the safety profile is covered. The description adds substantial context beyond that: data comes from OrbitWan's own node, amounts carry an exact decimal string beside the raw base-unit integer, null means 'not proven' rather than zero, ends_in uses the node's own clock, urls expose claim/transaction/token pages, and task names are never served. This is rich behavioral disclosure that an agent could not infer from annotations or 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?

The description is front-loaded with the core purpose and then layers in only information the agent needs: polling behavior, sort semantics, output interpretation, and the handoff to prepare_bridge_to_earn. Despite being a dense paragraph, nearly every clause carries operational value, and there is no redundant restatement of the tool name or annotations.

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: default ordering, amount representation with null semantics, ends_in format, url contents, and the absence of task names. It also supplies the polling contract and the follow-up tool, making the definition complete for an agent to call and interpret this tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters, and it does. after_id is explained as 1 to 12 digits returning only higher-id tasks, with the polling contract against next_after_id, and sort is explained as newest-first by default with ending_soonest ordering by deadline. Both parameters gain meaning that is absent from the bare 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 resource and scope: open Bridge to Earn tasks on the Wanchain task board, read from OrbitWan's own node, newest first. It also distinguishes itself from prepare_bridge_to_earn, which is named as the tool that drives an individual task step by step. An agent can tell exactly what this tool returns versus its siblings.

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

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

Gives clear usage context: use sort=ending_soonest to order by deadline, and poll with after_id set to the returned next_after_id to get only newer open tasks. It names prepare_bridge_to_earn as the follow-up tool and describes the call-do-what-next-says-call-again loop. It lacks an explicit exclusion such as 'use get_address_bridge_to_earn for address-specific history', so it falls just 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?

Annotations already mark read-only, and the description adds that the payload includes an untagged count, revealing an extra behavioral detail. No contradictions; it doesn't disclose performance or pagination but is sufficiently transparent for a read-only list.

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

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

The description is a single sentence that front-loads the key phrase 'full token registry' and then enumerates the returned fields compactly. No unnecessary words.

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

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

For a parameterless list tool with no output schema, the description fully communicates what data is returned and even includes the untagged count. It is complete enough for an agent to invoke correctly.

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

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

The tool has no parameters, and schema coverage is complete (empty schema). Per rubric, baseline is 3 since no parameter info is needed in the description.

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

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

The description clearly states the tool returns the full token registry, listing address, symbol, decimals, and curated tag for every indexed Wanchain token. It distinguishes from get_token (single token lookup) and list_verified_contracts (contracts, not tokens).

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

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

The description implies usage for retrieving all tokens but does not explicitly compare with alternatives like get_token or mention when to prefer this over other listing tools. It lacks explicit guidance on when to use this vs. 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?

The annotations already cover the safety profile (readOnlyHint true, destructiveHint false, openWorldHint false), so the description is free to add operational detail — and it does: exited PoS validators follow live rows newest-exit-first, status 'exit' returns only them, and each live PoS row carries selected/paid counts and the current epoch's selection. Only pagination or result-limit behavior is 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?

Four dense sentences, each carrying distinct information (fields, status semantics, filter/sort rules, ordering rules) with the resource identity front-loaded. No filler or 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?

The tool has three optional parameters and no output schema, so the description must convey the return shape — it names the fields and the row ordering, which is substantial. It stops short of describing any pagination, result caps, or empty-result behavior an agent would want before calling a listing 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 description coverage is 0%, so the description must carry the parameter burden, and it largely does: sort direction is specified per field (fee ascending, others descending), fee/room are flagged as PoS-only, and the otherwise-unenumerated `status` parameter is explained via the epoch-selection vocabulary (selected / not selected / exit) plus the special 'exit'-only behavior.

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 definition opens with a specific verb-and-resource statement ('Every PoS validator and Storeman node') and enumerates the profile fields returned (stake, APR, fee, room, delegators, status), which lets an agent distinguish it from the singular sibling get_validator 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?

'Filter by type and status; sort by stake, apr, fee, room or delegators' tells the agent how to narrow and order results, which implies the tool's use case. However, it never names get_validator as the alternative for a single node, nor states when not to use this listing.

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, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds the useful scoping qualifier 'source-verified' (i.e., only verified contracts appear), but says nothing about result volume, ordering, or pagination behavior for what is clearly a list endpoint.

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 no filler, and the key qualifier ('source-verified') is front-loaded. It is efficient but arguably under-specified rather than deliberately lean.

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, an undocumented limit parameter, and no indication of what fields a roster entry contains or how the result is bounded, the definition leaves too much for an agent to guess 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 description coverage is 0% and the single parameter (limit, default 25) is not mentioned anywhere in the description. The description does not compensate for the coverage gap, so an agent learns nothing about how to constrain the roster size or what the default returns.

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

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

The description names the resource ('roster of source-verified Wanchain contracts'), which conveys a listing of verified contracts. But it is a bare noun phrase with no verb, and it does not distinguish itself from the sibling get_verified_contract (singular lookup). An agent can guess the purpose but must infer the list-vs-detail relationship.

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 roster versus get_verified_contract, get_contract_creation, or get_chain_coverage. No conditions, exclusions, or alternatives are named.

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, non-destructive, closed-world), so the description's added value is the disclosure that results carry a tier distinguishing verified-ABI matches from heuristic-table matches — important for trusting the output. It does not say what happens on a miss or how unambiguous the heuristic tier is, which keeps it below 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?

One front-loaded sentence that delivers purpose and the meaning of the tier field with no 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?

With no output schema, the description must describe returns, and it does name the three meaningful outputs (name, signature, tier). It stops short of covering the unresolved-selector case or the accepted input format, which are the remaining gaps for a one-parameter lookup.

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 0%, so the description must carry the burden, and it only partly does: '4-byte function selector' implies a hex selector value but never specifies 0x-prefixing, casing, or whether an 8-character hex string is required. That is thin for the single parameter the tool depends on.

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: resolves a 4-byte function selector to name and signature. It is clearly distinct from the address/transaction-oriented siblings, though it does not differentiate itself from the potentially confusable resolve_identifier.

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

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

The description is a pure definition with no when-to-use guidance, no prerequisites, and no mention of alternatives such as resolve_identifier or get_verified_contract. The agent must infer the trigger condition entirely from the 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 establish readOnly and non-destructive, so the description's job is to add the commercial and procedural context, which it does: prepaid credit at 0.0005 USDT per 100 rows, an explicit prerequisite step (orbitpay_info) before invocation, and a concrete alternative payment path with price, chain, and URL. It stops short of stating rate limits, credit-exhaustion behavior, or result-size behavior beyond the limit cap.

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

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

Purpose and pricing lead, followed by the payment procedure and the alternative route — a sensible front-loaded order with little filler. The URL and price detail are dense but each earns its place for a paid tool.

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

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

With no output schema, no parameter descriptions, and a nested open-ended filters object, an agent still cannot construct a correct call from this description — filter key vocabulary, cursor semantics, and returned row shape are all undefined. Payment is covered thoroughly; the actual invocation surface is not.

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 0% across five parameters, including a nested free-form 'filters' object with additionalProperties string, so the description carries the full burden. It only gestures at 'filtered and paginated', which hints at from/to and cursor but explains nothing about filter key syntax, cursor lifetime, or the interaction between limit and cursor.

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 ('bulk cross-chain transfer history') plus its two defining traits, filtered and paginated. The word 'bulk' implicitly separates it from the per-address sibling get_address_crosschain, but no sibling is named, so the differentiation is inferential 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?

It gives real operational routing guidance — call orbitpay_info for payment/signing, or use the x402 HTTP route instead if the agent holds a wallet — which tells the agent how to pay. It says nothing, however, about when this premium export should be chosen over the free cross-chain siblings such as get_address_crosschain or get_crosschain_stats.

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

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

Annotations already cover read-only and non-destructive behavior, and the description adds meaningful context the annotations cannot: prepaid credit pricing at 0.0005 USDT per 100 rows, the need to call orbitpay_info first, and an alternative 0.01 USDC x402 path. It does not explain pagination behavior with the cursor or the shape of the returned 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?

Two compact sentences that front-load the resource and then the payment mechanics, with the HTTP fallback at the end. No filler, though the URL detail is dense and somewhat tangential to invocation semantics.

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, a nested filters object, and zero schema description coverage, the description should explain what the series contains and how filtering/pagination work. It covers monetization well but leaves the actual call semantics underspecified.

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

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

Schema description coverage is 0% across five parameters including a nested free-form filters object, and the description supplies no parameter meaning at all. Only 'over time' hints that from/to are a time range; limit, cursor, and the filters keys are left entirely undocumented.

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

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

States the resource and its content clearly: 'Premium Wanchain economics time series (supply, fees, and related metrics over time).' That distinguishes it from siblings like get_network_stats or get_wan_deflation, though the verb is implicit rather than stated as an action.

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

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

Gives concrete routing for the payment path (call orbitpay_info, or use x402 on the HTTP route), which is genuinely useful. However it never says when to prefer this premium series over free sibling tools such as get_wan_deflation or get_network_stats, leaving the main selection decision to inference.

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

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

Annotations only declare a safe read, but the description adds substantial behavior: it is free, it idempotently returns a manual, it details the exact signing scheme (EIP-191 personal_sign over 'orbitwan-api <unix_seconds>'), the required X-Payer/X-Timestamp/X-Signature headers, and a per-request x402 fallback. This is far beyond what 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?

Front-loads the key point ('Free.') and stays on topic, but the x402 parenthetical with wire-version details is dense and could be trimmed. Every sentence is relevant to a payment manual, so little 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 no params, no output schema, and safe-read annotations, the description fully covers what the tool returns and why. It explains both the OrbitPay prepaid-credit flow and the x402 alternative, so an agent knows how to proceed after 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?

The tool takes zero parameters, so there is no parameter semantics to miss; baseline 4 applies. The description correctly signals a no-argument, informational 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 and resource ('Returns the live payment manual') and enumerates exactly which four sibling tools it documents. An agent can distinguish this from the premium data tools 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?

Explains the trigger (called unauthenticated or with no wallet credit, the four tools return this manual) and offers an alternative path (x402 clients pay without OrbitPay onboarding). It does not explicitly order the agent to call this first, but the context for use is clear.

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

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

Annotations already establish readOnly/openWorld=false/destructive=false, so the bar is lower; the description adds real behavioural context beyond them: a pricing model (0.0005 USDT per 100 rows), a prerequisite payment/signing step via orbitpay_info, and an alternate x402 route with its own price. It does not disclose pagination behaviour or how rows are returned, which is the remaining 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?

Three short sentences, front-loaded with what the tool is, followed by cost and the mechanics for paying. The payment detail earns its place because it is a prerequisite to calling, but the sentence is dense with numbers and could have been split for readability.

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

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

For a five-parameter, zero-coverage schema with a nested filter object and no output schema, the description covers only the commercial/auth layer. It says nothing about parameter meanings or the shape of an exported tag row, leaving an agent unable to construct a call or interpret results without guessing.

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 0% across five parameters, including a nested 'filters' object, and the description explains none of them. An agent cannot tell whether 'to'/'from' are addresses, dates, or cursors, nor what keys 'filters' accepts; the description must compensate here and does not.

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: "Premium bulk address-tags export", which contrasts implicitly with the single-address siblings get_address_tags and find_tagged_addresses. The 'bulk' qualifier and the 'export' framing let an agent distinguish it from those listing tools, though 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?

The description gives strong guidance on the payment path (prepaid credit, call orbitpay_info for signing, or x402 per-request at a specific URL), which is genuinely actionable. However, it never says when to choose this bulk export over get_address_tags or find_tagged_addresses, so the selection guidance among siblings is only implied by the word 'bulk'.

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

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

The description adds vital behavioral and operational context beyond the structural hints, specifying the financial model ('0.0005 USDT per 100 rows') and the required operational steps ('Payment and signing steps'). This is essential for a 'premium' tool definition.

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

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

The description is dense but organized logically: data type, cost, and execution steps. Every piece of information, including the alternative routes, appears to be necessary for the tool's operational viability.

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 detailing how and for how much the data is delivered, the definition is incomplete because it omits the semantics of the input schema. An agent cannot meaningfully select the correct parameters without this explanation.

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 0%, yet the description fails to explain what the input parameters (to, from, limit, cursor, filters) represent or what they control. It focuses entirely on the execution and cost structure rather than the functional inputs.

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

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

The description clearly states the resource provided: 'Premium token supply data.' It is precise about the type of data returned, which is helpful for an agent deciding on the tool's applicability.

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?

This is exceptionally clear, offering two distinct methods for consumption. It explicitly routes 'Wallet-holding agents' away from this paid method and toward a standard HTTP endpoint and a different cost structure.

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, and openWorldHint=false. The description adds meaningful behavioral context beyond annotations: the vault address is deterministic per wallet, no WAN is needed, no second transaction is required, and credit arrives after 12 confirmations. It still does not fully state whether calling this tool itself requires authentication, but the added operational details are substantial.

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 core action and scope, then adds only relevant operational details. Every sentence contributes to selecting or using the tool, and 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?

For a one-parameter, read-only address tool with no output schema, the description explains what is returned (the vault address), how it behaves (deterministic), and how deposits work. The main remaining gap is the undefined 'beneficiary' parameter, which prevents a perfect completeness score.

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 0%, so the description must carry parameter meaning. It implies that the single parameter represents the wallet for which the deterministic vault address is returned ('for a given wallet'), but it never names or defines 'beneficiary' explicitly. The hint is useful but incomplete.

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: 'Get your dedicated OrbitPay deposit vault address.' It also distinguishes the tool's role from the broader OrbitPay setup by referring to orbitpay_info for auth details. An agent can tell this is an address-retrieval tool for deposits, not a general info or transaction 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 clear usage context: bridge wanUSDT/wanUSDC to the vault via XFlows with toAddress set to the vault, and credit lands after 12 confirmations. It also points to orbitpay_info for the auth scheme needed to check credit. It does not explicitly state when not to use this tool or name alternatives, 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?

The description mandates that steps involve signing and broadcasting transactions, and involves complex workflow progression. This directly contradicts the `readOnlyHint: true` and `destructiveHint: false` annotations, making the safety profile extremely misleading.

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 excessively verbose and dense, using technical, run-time logic instructions in a narrative format. It lacks conciseness and is overwhelming to read.

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 complexity of the task (chain hopping, internal states, manual signing), the description is exceptionally complete, providing all necessary context for a developer to understand the tool's operation.

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

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

Since schema coverage is 0%, the description must define parameter usage, which it does exhaustively. It explains the specific requirements for parameters like `source_address` and the internal logic for `next.action`, providing deep semantic context.

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

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

The description clearly defines its purpose: 'Drives one Bridge to Earn task for an address.' It distinguishes this from simple lookup tools by detailing the complex, iterative nature of the task.

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

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

It provides highly specific usage instructions, including the starting point (claim always comes first), loop mechanics (call with task_id and address), and specific actions based on the current state (fund, send, wait, done, stop).

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

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

The description adds value by confirming the 'read-only' nature of the operation through words like 'Classifies' and 'checks existence.' Since annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false), the description fulfills its role with a baseline level of additional context.

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

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

The description is a single, efficient sentence that packs all necessary information—input types and core functionality—without any unnecessary verbiage.

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 dealing with diverse identifier formats, the description is highly complete. It tells the agent exactly what input types are acceptable for classification and existence checking.

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

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

With 0% schema description coverage, the description is vital. It defines the semantics of the `identifier` parameter by specifying that it can accept four distinct types of inputs (address, transaction hash, block number, or 4-byte selector), which is critical for the agent.

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

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

The description clearly states the purpose: classifying and checking the existence of an identifier. By listing specific types (address, hash, block number, 4-byte selector), it provides a necessary functional definition for the 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?

The description does not explain when to use this tool versus others in the ecosystem. Since many sibling tools also operate on addresses or selectors, the description lacks guidance on whether this should be a pre-check for a more specialized call.

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