OrbitWan.io

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

Annotations already establish readOnlyHint=true and destructiveHint=false. The description adds behavioral context beyond that by specifying cursor pagination and the range of activity types covered, which helps the agent understand the shape of the call. It does not mention rate limits or result ordering, but the existing annotations lower the burden.

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, tightly worded sentence with no filler. It front-loads the core purpose and appends the pagination detail efficiently.

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 0% parameter coverage, the one-sentence description leaves too much unstated: the meaning of the 'category' enum, the relationship between 'view' and 'category', and how to use cursor/limit correctly. An agent would likely need to guess or probe to invoke this tool reliably beyond the happy path.

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 does partially explain the 'view' parameter through 'transactions, token transfers, or internal calls' and hints at 'cursor', but it leaves the 'category' parameter completely unexplained and says nothing about 'limit' semantics or how parameters interact. This is insufficient for a 5-parameter tool with two enums.

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 (a Wanchain address) and the specific activity types returned (transactions, token transfers, internal calls), which distinguishes it from address-focused siblings like get_address_summary or get_address_flows. It lacks an explicit verb like 'retrieves' or 'lists', but the meaning 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?

The description implies that this tool is for recent address activity, and the mention of transaction types makes the use case evident. However, it gives no explicit guidance on when to prefer this over get_address_flows, get_address_summary, or get_address_tags, and does not state any 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 and destructiveHint=false, and the description adds useful behavioral context by stating that all amounts are base-unit integer strings and that the window is 1 to 90 days. This helps an agent parse results correctly without contradicting 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 two short sentences with no filler. The core result is stated first, followed by the window constraint and amount format, making it efficient and easy 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 simple read-only endpoint with two parameters and no output schema, the description conveys the result granularity, the address scope, the allowable window, and the amount representation. It is sufficient for correct invocation, though return-structure details are not elaborated.

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 compensate. It gives meaning for both parameters indirectly: address is a Wanchain address and days corresponds to a window of 1 to 90 days. However, it does not explicitly mention the default of 30 days or parameter names, leaving some inference required.

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 what the tool returns: per-token in/out sums and native WAN flows for a Wanchain address over a time window. It is specific about the resource and scope, though it does not explicitly contrast itself with sibling tools like get_address_activity or get_address_summary.

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 given about when to choose this tool over alternatives. It states the supported window length but does not describe use cases, exclusions, or how it differs from related address 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 description discloses that amounts are base-unit integer strings and that each program carries ok, complete, and floors flags to prevent unread or partial figures from being presented as zero. This adds significant data-integrity context beyond the readOnlyHint annotation and does not contradict any 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 two sentences, front-loaded with the operation and scope, followed by critical data-format and integrity notes. Every sentence earns its place with no redundancy.

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 description covers the data type, source (OrbitWan's own node), and handling of incomplete data, which is sufficient for a read-only tool. There is no output schema, but the description gives enough context to understand what the tool returns. Slight gap: no explicit note on what the response structure looks like, but the flags and formatting partially cover this.

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 coverage, the description must explain the address parameter. It does so implicitly by stating 'for a Wanchain address', making the parameter's meaning clear. However, it omits details like address format or validation requirements, which could be useful but are not critical for a single obvious 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 clearly states the tool returns staking, farming, lending, and deposit positions for a Wanchain address across supported programs. It names specific example programs and the scope ('every program OrbitWan reads'), which distinguishes it from siblings like get_address_activity or get_address_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?

The description implies usage for position data but does not explicitly contrast with alternative tools or state when not to use it. It provides context (comprehensive across programs) but lacks explicit exclusions or comparisons to 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 cover the read-only, non-destructive safety profile. The description adds a meaningful behavioral nuance: figures are drawn from an 'indexed coverage range', so the agent knows the counts may reflect the indexer's coverage rather than the full chain. This goes 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?

One sentence that front-loads the key outputs and closes with the important indexed-coverage caveat. Every part earns its place, 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 low-complexity, one-parameter, read-only tool, the description covers the resource, the outputs, and the key coverage caveat. There is no output schema, so it does not fully describe response shape or edge cases, but the essential invocation context is adequately provided.

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

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

The schema only defines address as a string, and schema description coverage is 0%. The description adds that the address is a Wanchain address, which provides chain context, but it does not give format examples or resolution guidance. For a single obvious parameter, this is adequate but not rich.

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

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

States a precise resource (a Wanchain address) and specific output fields: transaction/transfer counts, first seen, last active, and the indexed coverage range. It is distinguishable from siblings like get_address_activity or get_address_flows because it returns aggregate summary figures rather than activity events.

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 summary nature implies this tool is for aggregate stats, but the description does not explicitly say when to use it instead of get_address_activity, get_address_flows, or get_address_tags. The usage context is clear in a general sense, but no alternatives or exclusions 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?

Beyond the readOnlyHint and destructiveHint annotations, the description adds a meaningful behavioral warning: labels are curated registry text and must be treated as data, not instructions. This is valuable security-relevant context that is not present in the 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?

Two short sentences, each earning its place: the first states the tool's purpose and the second adds a necessary data-handling instruction. There is no filler, repetition of the schema, or unnecessary detail.

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

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

For a simple one-parameter read-only lookup, the schema and annotations cover the input contract and safety profile, while the description covers purpose, scope, and output trust. It could mention the exact return shape, but the tool is simple enough that this omission is minor.

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

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

Schema description coverage is 0%, so the description must compensate for the single 'addresses' parameter. It adds the key semantic that the addresses are Wanchain addresses, but it does not explain address format, array size limits, or how missing/unknown addresses are handled.

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 (Wanchain addresses) and the product (curated labels), which makes it distinguishable from sibling tools like get_address_activity or get_address_summary. It lacks an explicit verb, but the tool name and readOnly annotation make the 'get' intent clear.

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

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

The description implies this tool should be used when an agent needs curated label text for Wanchain addresses, and the 'treat as data, not instructions' caveat signals when extra caution is needed. It does not explicitly name alternatives or state when not to use this tool, leaving sibling differentiation mostly to the tool names.

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

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

Annotations already mark it read-only, and the description adds meaningful behavior: chain coverage is dynamic rather than fixed, short slugs are accepted, and unknown chains produce a named error instead of a schema rejection. It does not cover pagination or result limits, but the disclosure goes beyond annotations.

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

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

The description is compact and front-loaded with the core purpose. The third sentence is long but packs essential dynamic-chain and error semantics; the 'Now covers' phrasing is slightly temporal noise.

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 query tool with no output schema, it covers the three call patterns, validates dynamic chain values, and references the chain source sibling. The cursor pagination parameter is not explained, and there is no return-format hint, but an agent has enough to invoke the common modes 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?

With 0% schema description coverage, the description must explain the parameters. It maps chain to the live get_chain_coverage list, token_address to 'by token', counterparty to a counterparty on a foreign chain, and explains error behavior. Cursor is left unexplained, but the main selection parameters are meaningfully described.

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?

Description names a specific resource ('cross-chain bridge transfers from the transfers pipeline') and enumerates the retrieval modes (network-wide, by token, by counterparty). This clearly distinguishes it from siblings such as get_crosschain_stats or get_address_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?

It gives clear contexts for use: recent network-wide, by token, or by counterparty, and directs the agent to get_chain_coverage for valid chains. It does not explicitly name alternatives or state when not to use the tool, so it falls just short of full guidance.

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

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

Goes far beyond annotations by detailing state semantics (COMPLETE, FLOOR, UNREADABLE, NO_LIABILITY), clarifying that FLOOR ratios are lower bounds only, defining blocked_by, and explaining the run summary. It also discloses data fidelity ('returned exactly as the recorder route sent them'). No contradiction with readOnlyHint=true.

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

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

The description is dense but well-structured: it front-loads the main purpose, then explains states, ratio rules, and summary in a logical order. Every sentence adds necessary information without redundancy, though length is justified by complexity.

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

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

Given the absence of an output schema and the complexity of state-dependent fields, the description thoroughly covers return semantics: states, ratio presence, blocked_by, run summary, and fidelity. An agent has sufficient information to interpret responses 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?

With 0% schema description coverage, the description compensates by explaining the 'state' parameter thoroughly with enum meanings and behavior. 'symbol' is implied via 'token component' but not explicitly linked. 'limit' is not addressed. Partial but not complete compensation for all parameters.

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 precisely identifies the tool as returning WanBridge custody-vs-liability observations per token component, with detailed state explanations. It clearly distinguishes from sibling tools like get_bridge_activity (activity vs solvency) and sets expectations about data origin and structure.

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 custody/liability analysis but does not explicitly state when to use this tool over alternatives or provide exclusions. It references 'Observations only' and data from recorder runs, but lacks direct comparison with sibling tools or conditions indicating alternatives.

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

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

Annotations already declare 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 and non-destructive behavior, and the description adds a meaningful non-obvious behavior: a null creation result is not proof that no creator exists while the genesis backfill floor is above zero. This is useful data-integrity context beyond the annotations.

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

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

The description is two tight sentences with no filler. The primary output fields are front-loaded, and the caveat is placed second, making the most important information immediately visible.

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

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

For a simple single-address lookup with annotations covering safety, the description covers the returned fields and an important edge case. It does not explicitly describe return formatting, but the listed fields and the caveat about null results provide enough context for an agent to interpret the tool's 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 partially compensates by implying the input address is a Wanchain contract and indicating what lookup results will be returned. However, it does not clarify address format, whether checksums are expected, or how to interpret the required address parameter beyond 'for a Wanchain contract.'

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 lists the data returned — creator address, creation transaction, block, and timestamp — for a Wanchain contract, so an agent can tell what the tool provides. It lacks an explicit verb like 'Retrieves' and does not explicitly contrast itself with siblings such as get_verified_contract, but the resource and output are specific enough.

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 no direct guidance on when to use this tool versus alternatives like get_verified_contract or get_address_activity. The caveat about null creation and genesis backfill is interpretation guidance, not usage-selection guidance.

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

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

Annotations already 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 declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds useful sourcing context ('DefiLlama-sourced', 'via WanBridge'), but does not disclose return format, pagination, or whether the data is live vs cached; this is acceptable given the simple read-only role.

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 sentence delivers the core scope and data provenance without redundancy. The most important qualifier (Wanchain-native vs cross-chain) comes first, and the parenthetical is compact and informative.

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

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

For a tool with one optional parameter, no required arguments, and a read-only annotation, the description is nearly sufficient for an agent to select and invoke it. It lacks explicit return-value details, but given the absence of an output schema and the simplicity of the tool, the description covers the essential selection and invocation context.

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

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

Schema description coverage is 0%, but the single optional section parameter has self-documenting enum values wanchain/crosschain/all. The description indirectly maps to these values through 'Wanchain-native' and 'cross-chain', yet it never explains the default behavior or the meaning of 'all', leaving the description to provide only partial compensation.

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: Wanchain-native earn positions and cross-chain yield opportunities sourced from DefiLlama via WanBridge, which separates it from the address/transaction/bridge sibling tools. It lacks an explicit verb like 'lists' or 'returns', but the tool name supplies the get action and the scope 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?

The description implies use for yield-related queries by naming the resource, but it never explicitly tells the agent when to prefer this tool over siblings or how the section parameter should be set for particular intents. No exclusions or alternative routing are provided, so guidance is only implicit.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds behavioral context by mentioning 'cursor pagination,' which tells the agent that results are paginated with a cursor, and it lists the specific data fields returned. It does not contradict annotations. This adds value by clarifying the output structure beyond the safety flags.

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 efficiently lists the returned fields and pagination. It is concise and front-loads the key content (fields) before mentioning the contract type and pagination. It could be slightly improved with a separate mention of parameters, but it is not verbose.

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

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

For a simple tool with 3 parameters and no output schema, the description provides a list of returned fields and mentions pagination, which is useful. However, it does not describe the response structure (e.g., JSON object shape) or the 'limit' parameter's behavior and default. Without an output schema, the agent may be uncertain about the exact format of the response, and the missing limit explanation is a notable gap.

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

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

Schema description coverage is 0%, so the description must explain all parameters. It implicitly covers 'address' (as the token contract) and 'cursor' (through 'cursor pagination'), but it completely omits the 'limit' parameter, its default value, and how it controls the number of transfers returned. The description does not explicitly map parameters to their purposes, leaving the agent unsure about limit's role.

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 specific fields (token symbol, decimals, transfer_count, last transfer time, recent transfers) for a Wanchain token contract, and mentions cursor pagination. This distinguishes it from siblings like list_tokens, which would list multiple tokens, and get_address_activity, which focuses on address actions. The verb is implicit but the resource and scope are explicit.

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

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

The description implies this is for querying a specific token contract by address, and it mentions pagination. However, it does not explicitly state when to use this tool versus alternatives such as list_tokens (for enumerating tokens) or get_address_activity (for address-centric queries). There is no 'when not to use' or comparisons to sibling tools, leaving the agent to infer usage context.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds value by specifying the exact behavioral scope: it returns core transaction fields, token transfers, cross-chain leg details, and internal calls, context beyond the structured 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 a single, tightly written sentence with zero filler. It front-loads the primary purpose ('Full detail for a Wanchain transaction') and then lists the specific content included, making every word informative.

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

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

For a simple one-parameter, read-only tool, the description adequately covers what the agent can expect the tool to return by enumerating the detail categories. It does not describe error behavior or response format, but without an output schema and given the tool's simplicity, this is a minor gap rather than a completeness failure.

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 description does not elaborate on the hash parameter at all. The parameter name 'hash' plus the title makes its purpose inferable, but the description does not compensate for the missing schema documentation, nor does it clarify format or domain (transaction hash, not block hash or other identifier).

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: 'Full detail for a Wanchain transaction' and enumerates the concrete data categories it returns (core fields, token transfers, cross-chain leg, internal calls). This clearly distinguishes it from sibling tools like get_address_activity or get_bridge_activity, which target different resources or scopes.

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 intended use is implied by the name and description: call this when you need transaction-level detail. However, it provides no explicit guidance on when to prefer this over potentially related siblings such as get_bridge_activity or get_crosschain_stats, especially given the cross-chain leg mention.

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 declare readOnlyHint=true and destructiveHint=false, so the safety profile is established. The description adds the two-mode behavior (rewards vs flows), but does not disclose return format, pagination, or address-format expectations.

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; every word contributes to purpose and scope. It is appropriately sized for a simple two-parameter tool, though it leaves some operational details to the schema.

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

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

For a simple read-only tool with two parameters and no output schema, the description covers the core domain well. Gaps remain: it does not explicitly say that the view parameter selects between rewards and flows, and it omits return-value or address-format details.

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 must compensate. It does clarify the view enum values by saying 'per-epoch incentive rewards or delegate in/out flows', and it implies the address is a validator address. It does not explain address format or the default view 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 description identifies a specific resource (Wanchain validator) and the two data categories it returns: per-epoch incentive rewards and delegate in/out flows. It is clearly distinguishable from generic address tools like get_address_flows, though it lacks an explicit verb such as 'gets' or 'returns'.

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

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

The phrase 'for a Wanchain validator' implies the tool is for validator-specific queries and not for generic address activity. However, there is no explicit guidance about when to choose this over sibling tools like get_address_flows or get_address_activity.

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, covering the safety profile. The description adds that an ABI summary is always returned and that include_sources toggles the full ABI and source files, which is useful context. However, it does not disclose what happens for unverified addresses or error conditions, leaving a 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?

A single clear sentence that front-loads the core purpose and appends the optional behavior. No wasted words; information density is appropriate and the structure is easy 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 tool with two parameters and no output schema, the description provides a high-level overview but omits details such as expected output fields, error handling for unverified contracts, and differentiation from sibling tools. These omissions leave an agent with uncertainty about edge cases and exact return 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 description coverage is 0%, so the description must compensate. It explains that include_sources controls whether full ABI and source files are returned, which adds semantics beyond the schema. The address parameter is only implied as the contract address from the resource, but not explicitly described.

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 specifies the resource (a Wanchain contract) and the data returned: source-verification status, provenance, an ABI summary, and optionally the full ABI and source files. This distinguishes it from sibling tools like list_verified_contracts by focusing on a single contract's detailed verification data.

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

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

The description implies usage for retrieving detailed verification details of a specific contract, but it does not explicitly state when to choose this over alternatives such as list_verified_contracts or get_contract_creation. No exclusions or alternative guidance is provided, leaving the agent to infer the intended scenario.

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?

Annotations already declare the operation read-only and non-destructive. The description adds the scope ('source-verified Wanchain contracts') and the fact that it returns a roster rather than a single contract, but it does not disclose pagination, ordering, result shape, or any rate-limit concerns. This is modest value beyond the annotations.

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

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

The description is one short, direct sentence with no filler or repetition. It is front-loaded with the key resource information, although it sacrifices helpful detail for brevity.

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

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

The tool is simple and annotated as read-only, but there is no output schema and the description does not explain what fields each verified contract entry contains, how limit affects the response, or whether pagination exists. This is enough to make a default call, but not enough to confidently handle different result sizes or interpret the 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 sole parameter, limit, is not explained in the description and the schema provides only its type and default value. With 0% schema description coverage, the description was responsible for explaining limit semantics, but it never mentions pagination, maximum values, or how the limit affects results. The name and default give a weak hint, but the gap remains.

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 resource—source-verified Wanchain contracts—and the word 'roster' implies a listing operation. It is distinguishable from the sibling get_verified_contract, which is singular, but the description does not explicitly state 'list' as the action or name that 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?

There is no guidance about when to use this tool versus get_verified_contract, list_tokens, or other siblings. No alternatives, exclusions, or conditions are mentioned, so an agent must infer usage solely from the tool name.

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

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

Annotations already declare the tool read-only and non-destructive, and the description adds useful behavioral context: the return includes a name, a signature, and a tier indicating whether the match came from a verified ABI or a heuristic table. It stops short of explaining failure behavior when no match is found, but this is a strong addition given no output schema.

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

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

A single sentence that is front-loaded with the core purpose and immediately follows with the tier detail. Every clause earns its place, with no redundant or filler 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?

For a low-complexity, one-parameter resolver, the description is largely complete: it identifies the input, the output components, and the provenance tier. The only notable omission is handling of unknown selectors or exact input formatting, but the overall picture is clear enough for an agent to invoke the tool confidently.

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?

Although the schema provides only 'selector' as a generic string with 0% description coverage, the description compensates by clarifying it must be a 4-byte function selector. It does not explicitly state the expected hex format or 0x prefix, but for a single simple parameter this is a meaningful semantic improvement over 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 verb ('Resolves'), a precise resource ('4-byte function selector'), and the result ('name and signature'). It also distinguishes itself from siblings like resolve_identifier by focusing on selector-to-signature resolution and mentioning the verified-ABI versus heuristic-table tier.

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 no explicit guidance on when to use this tool instead of siblings such as resolve_identifier, nor does it state when not to use it. Usage must be inferred entirely from the function of resolving a selector; there are no prerequisites, exclusions, or alternative routing signals.

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, and the description adds genuinely useful behavior beyond them: the premium paywalled nature, archival data source, filtered and paginated delivery, and per-row pricing. The 'export' wording aligns with read-only semantics, so there is no contradiction.

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

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

Three sentences, each carrying distinct information: purpose, cost/payment routing, and the alternative HTTP route, with the purpose front-loaded. The URL template 'https://orbitwan.io/idx<route>' is cryptic and would benefit from a concrete route value, but overall there is no wasted prose.

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

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

The payment and signing flow is covered thoroughly, which is critical and unusual context for this tool, but the rest of the picture is incomplete. With no output schema and 0% parameter documentation, the description omits the export's return format and the semantics of `to`/`from`/`filters`, leaving an agent unable to fully validate its request.

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 5 parameters, so the description must compensate, but it only gestures via 'filtered and paginated', loosely mapping to filters/cursor/limit. The meanings of `to` and `from` (addresses, chains, or time bounds?) and the valid keys for the `filters` object are unexplained, so an agent cannot reliably build a correct request.

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, 'Premium bulk cross-chain transfer history from ARCHIVE, filtered and paginated', states a specific resource (cross-chain transfer history from archive) and operation (bulk export), and it matches the title. Scope markers like 'bulk' and 'ARCHIVE' distinguish it from siblings such as get_crosschain_stats and orbitpay_tags_export, 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 provides concrete usage conditions: prepaid credit at a stated rate, an explicit directive that 'Payment and signing steps: call orbitpay_info', and an alternative x402 HTTP route for wallet-holding agents with its own cost. It lacks explicit when-not-to-use guidance or exclusions against sibling history/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 annotation readOnlyHint:true and destructiveHint:false are consistent with the description's payment focus, implying no side effects. The description adds cost-related behavior (premium, payment methods) but does not describe the return format or any potential limitations. There is no contradiction with annotations.

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

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

The description is moderately concise but includes unnecessary details like the full HTTP URL and pricing specifics. It is structured as a single sentence with embedded clauses, which is acceptable but not optimal for quick scanning.

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

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

With no output schema, no parameter descriptions, and no mention of required filters or response structure, the tool description is incomplete. It provides payment context but omits essential usage details such as what 'filters' expects or what data the response contains, making it insufficient 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 input schema has 5 parameters (to, from, limit, cursor, filters) with no descriptions and 0% coverage. The description does not explain the meaning or purpose of any parameter, leaving agents without guidance on how to set them. This is a critical gap for usability.

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 provides a Premium Wanchain economics time series from ARCHIVE, covering supply, fees, and related metrics over time. This gives a specific and distinct purpose, though it does not explicitly contrast with sibling tools like get_token or list_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 provides payment instructions (prepaid credit or per-request x402) and references orbitpay_info for signing steps. However, it does not specify when to use this tool over alternatives or what conditions might require it, leaving usage context partially vague.

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 indicate readOnlyHint=true and destructiveHint=false. The description adds substantial behavior context: pricing tiers, wallet credit requirements, EIP-191 signing details, x402 alternative, and the fallback behavior of returning the manual instead of data. This goes well beyond the structured 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 purpose and every sentence conveys unique information, but the text is long and dense. Technical specifics like EIP-191, x402, and header names could be condensed without losing meaning.

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

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

For a zero-parameter, read-only info tool with no output schema, the description covers the return content, pricing model, payment authentication paths, and fallback behavior. Minor ambiguity remains about whether the info call itself is charged, but overall the description is sufficiently complete.

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

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

With zero parameters, schema description coverage is 100%, so the baseline is 4. The description adds relevant contextual information about required HTTP headers (X-Payer, X-Timestamp, X-Signature) for payment, even though these are not schema parameters.

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 that the tool returns the live payment manual for OrbitWan premium data, providing a specific verb (returns) and resource (payment manual). This distinguishes it from sibling data retrieval tools like get_token or get_transaction, which return data rather than payment instructions.

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 when the manual is returned (unauthenticated or with no wallet credit) and details both OrbitPay and x402 payment methods. However, it does not explicitly route the agent to an alternative tool; it only describes an alternative protocol, so the when-to-use guidance is strong but not fully explicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: it discloses the payment model (prepaid credit with per-100-row pricing, or per-request x402 on an HTTP route) and directs agents to orbitpay_info for payment steps. It also specifies the data source ('ARCHIVE') as historical. This exceeds annotation coverage and provides actionable behavior details, but doesn't mention rate limits or response streaming, which keep it from a 5.

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

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

The description is two sentences long and front-loads the core purpose in the first clause. It packs essential payment and routing information efficiently without excessive elaboration. While the payment instructions are technical, they are necessary for a paid premium tool. The structure is clear, though the payment details could be split for readability; overall it is appropriately concise.

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

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

The tool has five parameters, no output schema, and no structured parameter documentation, yet the description only covers payment mechanics and data origin. It does not explain how to construct the request (pagination via limit/cursor, filters semantics) or what the response contains, which is critical for reliable invocation. The payment steps are well-covered, but the missing parameter semantics and response format make the definition incomplete for a 5-parameter bulk export tool.

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

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

Schema description coverage is 0%, meaning the input schema provides no descriptions for the five parameters (to, from, limit, cursor, filters). The description does not mention any of them, leaving the agent completely uninformed about parameter meaning, format, or constraints. With no annotation or description support, this dimension fails to add value beyond the raw schema property names.

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

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

The description opens with 'Premium bulk address-tags export from ARCHIVE,' which clearly states the verb (export), resource (address-tags), and scope (bulk, from archive). This distinguishes it from the sibling get_address_tags (likely single-address retrieval) by emphasizing 'bulk' and 'export.' It is specific and unambiguous.

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

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

The description implies this tool is for bulk exports while get_address_tags likely handles single addresses, but it never explicitly says 'use this for multiple addresses' or directs to a sibling for single lookups. It does provide payment alternatives (prepaid credit vs x402 HTTP) but does not guide when to choose this tool over free alternatives. The guidance is implicit rather than explicit, so a mid-range score is warranted.

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

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

Annotations already carry readOnlyHint=true and destructiveHint=false, so the safety profile is covered and there is no contradiction. The description adds genuine context beyond the annotations: the premium/paywalled nature, the prepaid-credit pricing model, the signing dependency on orbitpay_info, and the alternative x402 HTTP route. That disclosed auth/payment behavior is valuable. But it omits details like pagination limits affecting cost and what happens on failed payment.

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 text is short with no filler and front-loads the primary purpose before payment details. However, it allocates roughly two-thirds of its scarce space to payment mechanics (USDT pricing, orbitpay_info signing, x402 route/URL) at the expense of tool semantics and parameters. It is compact but mis-prioritized for an agent that needs to know what the tool returns and how to call it.

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

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

For a premium, pay-per-row data tool with no output schema and no parameter descriptions, the description is materially incomplete. The agent knows the cost model but not what supply data is included, how the five parameters shape the query, what the response looks like, or what filters are available — all of which matter when the agent is paying real money per 100 rows. The payment focus leaves the core call semantics undocumented.

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% with 5 parameters (to, from, limit, cursor, filters), and the description explains none of them. There is no mention that to/from bound a date range, that limit is capped at 200, that cursor drives pagination, or — critically — what keys the nested 'filters' object accepts. The only oblique hint is 'per 100 rows', which gestures at limit/cost coupling. With zero schema coverage, the description was obligated to compensate and did 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?

The description states the resource ('token supply data') and flags it as premium/archival, giving a recognizable purpose. However, it is a noun phrase with no verb, and 'supply data' is vague — it never says whether this is current supply, historical series, per-token, or aggregate. It also fails to distinguish itself from several overlapping siblings (orbitpay_economics_series, get_token, list_tokens), so an agent cannot reliably tell this tool apart without opening schemas.

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

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

The description gives payment-process guidance — it instructs prepaid-credit agents to 'call orbitpay_info' for signing and offers a wallet-holders alternative via an x402 HTTP route. This is useful operational guidance, but it is payment guidance, not tool-selection guidance. There is no statement of when to choose this tool versus orbitpay_economics_series, orbitpay_tags_export, or get_token, and no exclusion criteria. With six orbitpay_* siblings, that absence is a real gap.

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 annotation, the description reveals valuable non-obvious behavior: the vault address is deterministic per wallet, fund arrive automatically after 12 confirmations, no WAN is needed, and no second transaction is required. These operational details inform the agent's expectations and are not present in annotations. There is no contradiction with annotations.

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

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

Two dense sentences with the primary purpose front-loaded. Every clause adds operational value — deterministic address, chain-agnostic bridging, confirmation threshold, and auth pointer. No filler or redundancy.

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

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

For a single-parameter tool with no output schema, the description covers purpose, funding workflow, determinism, confirmations, and where to find auth details. The main gap is that it doesn't explicitly state what the tool returns (e.g., an address string or an object with chain details), though 'get... vault address' strongly implies the return value. Overall quite complete for the tool's simplicity.

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

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

The schema provides only a parameter named 'beneficiary' with zero description coverage, so the description carries the burden. It partially compensates: 'the same address every time for a given wallet' implies beneficiary is the wallet identifier for which the vault is deterministic. However, it does not specify the expected format or type of the beneficiary value (e.g., a WAN address or an EVM address), leaving some ambiguity.

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

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

The description opens with a specific verb and resource: 'Get your dedicated OrbitPay deposit vault address.' It clearly states what the tool produces (a vault address) and the mechanism (bridge assets to it for prepaid credit). This distinguishes it from sibling tools like orbitpay_info (auth scheme) and orbitpay_crosschain_history (transaction history), so an agent can tell them apart.

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

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

The description explains how to use the result ('bridge wanUSDT or wanUSDC to it... set toAddress to the vault') and when credit lands, giving strong context for invocation. It points to orbitpay_info for the auth scheme and implies that checking credit requires a separate signed call. It doesn't explicitly state 'use this tool when X, not when Y,' but the usage context is clear enough.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the behavioral detail that it classifies and checks existence, but does not disclose what happens for invalid, malformed, or non-existent identifiers, nor what the output shape is.

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

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

The description is a single front-loaded sentence with no filler. It states the action, the accepted inputs, and the secondary behavior, so every word 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?

Given the tool's low complexity (one required string parameter), the description is reasonably complete: it defines the input space and the tool's core purpose. The lack of an output schema means return-value behavior is not documented, and the description could go further on error/not-found semantics, but for a simple resolver the essential calling information is present.

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

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

With 0% schema description coverage, the schema only provides type and length constraints. The description adds needed semantic meaning by enumerating accepted identifier forms: address, transaction hash, block number, and 4-byte selector. It does not specify exact formats such as 0x-prefix requirements, but it substantially 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?

The description uses a specific verb ('classifies') plus a concrete set of resource types ('address, transaction hash, block number, or 4-byte selector') and adds the existence-check behavior. It is clear and informative, though it does not explicitly distinguish itself from siblings like lookup_selector or get_transaction; it relies on the reader to infer the difference.

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 when to use the tool: when a caller has a Wanchain identifier of an ambiguous type and wants it classified or checked for existence. However, it does not state exclusions or point to alternatives, such as using lookup_selector specifically for selectors or get_transaction when transaction details are needed.

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