Fuse Network

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

With no annotations, the description discloses signing/submitting behavior and conditional return of deployed address, but omits details like gas costs, failure modes, or the fact that server signer requires prior setup.

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

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

Single sentence, directly conveys essential action (signs/submits) and key conditional return. 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?

Given no output schema, the description explains both return scenarios (hash only vs. hash+address). It does not explain potential errors or prerequisites, but for a straightforward deployment tool this is largely sufficient.

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

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

Schema coverage is 100%, so baseline is 3. The description does not add new meaning beyond the schema explanations for parameters like bytecode, abi, args, etc.

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 signs and submits a contract-deployment transaction, specifies return values (hash, conditional address), and distinguishes from sibling tools like read/write contract which operate on existing contracts.

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 alternatives such as fuse_send_native or fuse_write_contract. The description does not mention prerequisites, ideal scenarios, 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?

With no annotations, the description should disclose behavioral traits. It mentions POST routes but does not clarify side effects, authentication requirements, rate limits, or error handling. The 'generic dispatcher' nature lacks specific behavioral details.

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

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

Three sentences, front-loaded with core function, every sentence adds value. No redundancy or fluff.

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

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

No output schema, and description does not explain return values, pagination, or error responses. Given the complexity of covering 40+ endpoints, more context is needed for complete understanding.

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

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

Schema coverage is 100%, baseline 3. The description adds value by explaining module and action usage, that params omit module/action/apiKey, and body for POST actions, enhancing understanding beyond schema.

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

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

The description clearly states the tool is a generic dispatcher for the Fusebox Explorer API, listing specific endpoints and requiring module+action. This distinguishes it from sibling tools like fuse_get_balance which are specific.

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 on when to use this generic tool versus dedicated sibling tools. No when-not-to-use or alternatives mentioned, leaving the agent to infer.

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?

Although no annotations are provided, the description clearly states it is a read operation, specifies the exact information returned (deployment status, nonce, deposit balance), and discloses a limitation (paymaster eligibility not evaluated in v0.1). This provides behavioral context beyond the input 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 sentences delivering all essential information: what the tool reads and a caveat about what is excluded. No wasted words, front-loaded with the core functionality.

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 simplicity (2 parameters, no output schema), the description fully covers what the tool does, what it returns, and its limitations. No further explanation is needed for an agent to use it correctly.

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

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

Schema coverage is 100% with both parameters described. The description adds useful context: the smartAccountAddress can be counterfactual and the nonceKey defaults to 0. This extra information helps the agent understand parameter semantics beyond the schema alone.

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

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

Description explicitly states it reads ERC-4337 state for a smart account on Fuse, listing specific data (deployment status, nonce, deposit balance) and noting what is excluded (paymaster eligibility). This is a specific verb+resource that distinguishes it from siblings like fuse_smart_get_info, which likely targets smart wallet info rather than account abstraction.

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 vs alternatives. The description does not mention when to prefer this over, for example, fuse_smart_get_info or other query tools. The context of ERC-4337 vs smart wallets could be inferred but is not explicitly addressed.

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

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

No annotations, and description lacks behavioral details like idempotency, data freshness, or side effects. As a read query, it's safe, but the description does not compensate for missing 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?

Single sentence perfectly sized. No fluff, front-loads the core information.

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

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

For a simple balance retrieval tool with 2 params and no output schema, the description is adequate. It explains both variants and the condition.

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 provides full coverage with descriptions. The tool description adds that tokenAddress is optional and clarifies behavior when omitted, adding value beyond schema.

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

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

States exactly what it does: returns native FUSE or ERC-20 balance. Distinguishes from sibling tools like fuse_get_token_metadata by focusing on balance retrieval.

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?

Clear usage: provide address, optionally tokenAddress for ERC-20. Does not explicitly mention when to avoid or alternatives, but purpose is well-defined and self-evident.

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

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

With no annotations, the description carries the full burden. It transparently states the output includes wei, gwei, and EIP-1559 suggestions. However, it does not explicitly state it is a read-only operation or disclose any rate limits or prerequisites, though none are expected.

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, concise sentence that front-loads the main action and provides key details without 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?

The tool is simple with no output schema or parameters. The description covers the return values adequately but could mention that it is safe to call frequently or note any network-specific considerations.

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 schema coverage is 100% trivially. The description does not need to add parameter info, and it correctly omits any. Baseline for 0 parameters is 4.

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

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

The description clearly states the tool returns the current Fuse network gas price in wei and gwei, along with EIP-1559 fee suggestions. The verb 'returns' and resource 'Fuse network gas price' are specific. Among sibling tools, it uniquely provides gas price information.

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 the tool is for fetching current gas prices but does not explicitly state when to use it vs alternatives or when not to use it. Since there are no alternative gas price tools, this is a minor 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?

Discloses return values (status, gasUsed, logs) and null case for pending/unknown transactions. With no annotations, this adds useful behavioral context beyond the input 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?

Single sentence, no fluff, front-loaded with key information. 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?

Despite no output schema, description lists return fields and null case, providing sufficient context for a simple one-parameter tool. Slightly more detail on format would push to 5.

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

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

Schema has 100% coverage with description for `hash`. Tool description mentions hash format but does not add significant meaning beyond schema. Baseline 3 is appropriate.

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

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

Description clearly states verb 'Fetches' and resource 'receipt', lists specific fields (status, gasUsed, logs), and distinguishes from sibling like fuse_get_transaction by specifying it's for mined 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?

Implies usage for mined transactions by mentioning null return for pending/unknown, but does not explicitly state when to use this tool over alternatives like fuse_get_transaction.

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

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

No annotations are provided, so the description must fully disclose behavior. It describes the return value and purpose but does not mention any side effects, rate limits, permissions, or safety guarantees. For a read-only operation returning a configuration-level address, the description is adequate but lacks proactive disclosure of non-state-changing behavior.

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

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

The description is a single sentence that front-loads the primary outcome (returns the EOA address) followed by essential usage advice. Every word contributes meaning, and there is no redundancy. It is optimally concise for the tool's simplicity.

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 simplicity (no parameters, no output schema, no annotations), the description fully covers what the tool does and when to use it. The agent gains a complete understanding of its purpose and role without needing additional information.

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 with 100% schema coverage (empty object). The description adds value by confirming the tool requires no input and explaining its purpose. For a zero-parameter tool, a baseline of 4 is appropriate, and the usage context further justifies the score.

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 EOA address controlled by the server's FUSE_PRIVATE_KEY. It also specifies the resource (signer address) and verb (get), making the purpose unambiguous. No sibling tool performs the same function, so no confusion.

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 explicitly instructs to use this tool before any write tool to confirm the gas-paying account. This provides clear when-to guidance and explains the rationale, though it does not explicitly mention when not to use it. The context is sufficiently clear for agent decision-making.

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

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

No annotations are provided, so the description carries full burden. It discloses the return data but does not mention read-only nature, error cases (e.g., empty positions), prerequisites, or rate limits. More behavioral context is needed.

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 with clear front-loading of functionality. The second sentence about the SDK is slightly extraneous but not harmful. Could be more 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?

For a simple query tool with one parameter, the description is fairly complete. It covers what is returned. Lacks clarification on edge cases (empty results) but adequate given no output schema.

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

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

Schema coverage is 100% with a clear description of walletAddress. The description adds no additional parameter info beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states it returns active staking positions for a wallet, listing specific data: staked amount, USD value, earned rewards, and APR per position. It identifies the resource (staking positions) and action (returns), distinguishing it from action-oriented siblings like fuse_smart_stake_token or fuse_get_staking_options.

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

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

No explicit when/when-not or alternatives are provided. While the description implies usage for querying staking positions, it does not guide the agent on when to use this vs. fuse_get_staking_options or other related 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?

No annotations are provided, so the description carries the full burden. 'Lists' implies a read operation, but it does not explicitly state non-destructiveness, authorization requirements, or potential rate limits. It adds minor context ('Powered by Fusebox SDK StakingModule') but lacks behavioral details.

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

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

The description is two sentences long. The first sentence is informative and front-loaded with core functionality. The second sentence (implementation note) is slightly redundant but not wasteful. Every sentence serves a purpose.

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

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

Given no output schema, the description compensates by listing fields, but it does not specify the return format (e.g., array of objects), ordering, or any pagination. It is adequate but could be more complete for an agent to fully understand the expected response.

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 are zero parameters, and schema coverage is 100% (trivially). The description adds value by enumerating the returned fields (token, APR, TVL, expiry, unstake token), which is above the baseline of 3 for high schema coverage.

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 'Lists every staking option supported by Fuse' and specifies the fields: token, APR, TVL, expiry, and unstake token. This distinguishes it from sibling tools like fuse_get_staked_tokens (which lists user's staked tokens) and fuse_smart_stake_token (which performs staking).

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 viewing available staking opportunities but provides no explicit guidance on when to use this tool versus alternatives (e.g., fuse_get_staked_tokens for personal stakes). No when-not-to-use or context for filtering is 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?

No annotations provided. Description only states 'reads' but does not disclose any behavioral traits such as permission requirements, error conditions, or side effects. This is insufficient for a tool with no 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?

Single sentence with no fluff. Front-loaded with verb and resource. Every word is necessary.

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 tool with one parameter, the description adequately explains purpose and return fields. Lacks a note on potential errors or network dependencies, but sufficient given low complexity.

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 has 100% coverage with description for tokenAddress. Description adds value by listing the exact metadata fields returned (name, symbol, decimals, totalSupply), clarifying what the tool provides beyond the address 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?

Description clearly states the tool reads name, symbol, decimals, and totalSupply for an ERC-20 token on Fuse. The verb 'reads' and specific resource differentiate it from sibling tools like fuse_deploy_contract or fuse_get_balance.

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

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

No explicit guidance on when to use this tool versus alternatives. Usage is implied by the simple read nature, but lacks mention of 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?

Since no annotations are provided, the description carries full behavioral burden. It notes the tool is powered by Fusebox SDK TradeModule and implies a read-only operation with 'Returns'. However, it does not disclose potential side effects, authentication needs, rate limits, or what happens if the token is not tracked.

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 with no redundant information. The key purpose and a distinguishing detail (tracked tokens) are front-loaded. Every sentence earns its place.

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

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

For a simple read operation with one parameter and no output schema, the description covers the core purpose and a relevant constraint. However, it could be more complete by specifying the return value format (e.g., decimal, string) or clarifying that it returns the price in USD.

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 only parameter, tokenAddress, has a clear schema description. The description adds value by specifying that only tokens tracked by Fusebox are supported, which is extra context 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 clearly states the tool returns the current USD price for an ERC-20 token tracked by Fusebox. The verb 'Returns' and resource 'USD price for an ERC-20 token' are specific. It distinguishes from sibling tools like fuse_get_token_price_history and fuse_get_token_price_change, which deal with historical or change 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 provides no guidance on when to use this tool versus alternatives. It does not mention that it is only for current prices, nor does it reference sibling tools for history or changes. The user must infer usage context from the name alone.

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

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

With no annotations, the description must disclose behavioral traits. It only states the basic functionality and a powered-by note. It omits details like error handling for untracked tokens, rate limits, or that it's a read-only operation. For a simple data retrieval, this is insufficient.

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 with the key information in the first sentence. The second sentence about Fusebox SDK is slightly extraneous but not wasteful. It is efficiently structured but could be trimmed.

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 one parameter and no output schema, the description covers the basic purpose and input. However, it does not specify the return format (e.g., a number or string with percentage), leaving the agent uncertain about the output structure.

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

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

Schema description coverage is 100%, so the description adds no additional semantics for the tokenAddress parameter beyond what the schema already provides. The description's mention of 'ERC-20 token tracked by Fusebox' is only implicit context, not a parameter detail.

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 verb 'Returns' and specifies the resource: '24-hour percentage price change for an ERC-20 token tracked by Fusebox'. It effectively distinguishes from sibling tools like fuse_get_token_price (current price) and fuse_trade_price_change_over_duration (custom duration).

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 guidance on when to use this tool over siblings. It does not mention alternatives or constraints (e.g., token must be tracked by Fusebox). The agent lacks context for tool selection.

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

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

No annotations provided. Description lacks behavioral details such as rate limits, authentication requirements, error handling (e.g., invalid token address), or response format beyond OHLC. Only states it returns stats, not how the tool behaves.

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

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

Single sentence, no fluff. Could be improved by adding usage guidance without increasing length significantly. Efficient but missing some value.

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

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

No output schema, no annotations. Description does not explain return format (structure of OHLC data), data limits, or what happens if no data for token. Incomplete for a historical data tool.

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

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

Schema coverage is 100% with descriptions for both parameters. Description adds context that timeFrame values correspond to granularity/range and that data is from Fusebox SDK, but no additional syntax or constraints beyond schema. Baseline 3 is appropriate.

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

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

Description clearly states verb 'Returns', resource 'OHLC / interval price stats for an ERC-20 token', and scope 'over a week, month, or year'. Distinguishes from sibling tools like fuse_get_token_price (current price) and fuse_get_token_price_change (price change).

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?

Description does not explicitly state when to use this tool vs alternatives. It mentions 'Powered by the Fusebox SDK TradeModule' but no guidance on context or exclusions. Usage is implied through the resource name, but not 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool is read-only and powered by a SDK module, but lacks details on error handling, time sensitivity of quotes, or any required permissions. The level of transparency is adequate but not thorough.

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 extremely concise at two sentences, with no fluff. Key information (read-only, what it returns) is front-loaded, making it 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?

Given the lack of an output schema, the description only vaguely mentions expected output, route, and price impact. It does not detail the response structure, which limits completeness for an agent that needs to parse 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?

The input schema has 100% description coverage, so the schema already explains each parameter. The description does not add new meaning beyond the schema, maintaining the baseline score of 3.

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

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

The description uses the verb 'quotes' to clearly state the tool's core action on a 'token swap' resource, and specifies the returned information: expected output amount, route, and price impact. It distinguishes itself as read-only, separating it from submission tools like fuse_smart_swap_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 explicitly labels the tool as 'Read-only' and states it returns a quote without submitting a trade, which guides when to use it (for previewing a swap). However, it does not explicitly mention when not to use it or provide alternatives among the many sibling 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 it returns null if the transaction is not found, which is important behavioral information. Since no annotations are present, the description carries the full burden and handles it adequately for a read-only operation.

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

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

The description is a single, clear sentence that front-loads the verb and resource. There is no wasted 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 simple lookup tool with one parameter and no output schema, the description covers the core functionality and an important edge case (returning null). It is complete for its complexity level.

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

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

Schema coverage is 100% and the schema already describes the parameter well ('0x-prefixed, 32 bytes'). The description adds minimal extra meaning beyond 'by hash', so it meets the baseline but does not improve it.

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

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

The description clearly states the action (fetches) and the resource (transaction by hash). It distinguishes from siblings like fuse_get_balance or fuse_get_receipt, which serve different purposes.

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 when needing transaction details by hash, and distinguishes from other tools by the specific resource. However, it does not explicitly mention when not to use it or provide alternative tool names for similar queries.

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

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

No annotations are provided, so the description carries the full burden. It discloses that it returns history and uses a GraphQL service, but omits details on pagination, rate limits, authentication requirements, error handling, or whether the operation is read-only (implied but not stated). For an unannotated tool, more behavioral context is needed.

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, no fluff, and directly states the purpose and service. Every sentence adds value.

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

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

Given the simple input and no output schema, the description is mostly adequate. It explains the tool's purpose and the underlying service. However, it lacks information about the output structure, possible limits, and whether the history is paginated. This leaves some uncertainty for the agent.

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

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

Schema coverage is 100% for the single parameter 'sender', with a clear description in the schema. The tool description does not add meaning beyond what the schema already provides; it simply restates that it returns history. Baseline 3 is appropriate.

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

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

The description clearly states 'Returns the ERC-4337 UserOperation history for a smart account on Fuse', using a specific verb ('returns') and resource ('UserOperation history'). The title 'Get user operations' aligns well. Among many sibling tools, this is distinct as a query tool for user operations.

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 lacks guidance on when to use this tool versus alternatives. It mentions 'indexed via the Fusebox GraphQL service' but does not specify prerequisites, scenarios, or when to prefer other tools like fuse_get_receipt or fuse_smart_get_info. No exclusion criteria are provided.

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

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

No annotations are provided, so the description carries the full burden. It mentions being 'Powered by the Fusebox SDK TradeModule' but does not disclose whether authentication is required, rate limits exist, or what side effects (none expected) occur. For a read-only tool, minimal transparency is provided.

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 with no filler. The first sentence defines the core function and qualifiers; the second provides source context. 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 no parameters and no output schema, the description is brief. It does not specify the output format (e.g., list of token addresses, symbols), pagination, or whether authentication is needed. For a simple list tool, it is minimally adequate but could provide more detail on the return structure.

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 and schema coverage is 100%, so baseline is 4. The description adds context by explaining that the returned catalogue includes tokens that are 'tradable, indexed, priced', which adds meaning beyond the empty 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 clearly states 'Returns the catalogue of ERC-20 tokens tracked by Fusebox (tradable, indexed, priced).' It specifies the verb (returns) and resource (catalogue of ERC-20 tokens), with qualifiers that distinguish it from sibling tools like 'fuse_get_token_price' or 'fuse_list_wallet_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 obtaining a list of supported tokens but provides no explicit when-to-use guidance or alternatives. It does not differentiate from similar tools such as 'fuse_list_wallet_tokens' which lists user wallet tokens rather than the full catalogue.

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

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

No annotations provided. The description does not mention rate limits, authentication, pagination, or any behavioral nuances beyond listing. For a read operation, minimal disclosure.

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

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

Two sentences, no fluff, all essential info. Perfectly 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?

Given the simplicity of one parameter and no output schema, the description is adequate but lacks details like output format, pagination, or limitations. Could be more complete.

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

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

Schema coverage is 100%, and the description adds no extra meaning to the parameter 'walletAddress' beyond what the schema already provides. Baseline score is appropriate.

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

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

The description clearly states it lists NFTs (ERC-721/ERC-1155) owned by a wallet on Fuse. The title and name are consistent. However, it could better differentiate from sibling like fuse_list_wallet_tokens, which lists fungible 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?

No guidance on when to use this tool vs alternatives. No context about prerequisites or when not to use. The description only states what it does, not when or why.

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

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

No annotations are present, so the description carries the full burden. It correctly indicates a read-only operation listing tokens with metadata, but lacks details on authentication, rate limits, error handling, or output specifics beyond the mentioned fields.

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

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

The description is a single, well-structured sentence that front-loads the action and includes enrichment details and the source. 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 simple list tool with one parameter, the description is largely complete: it states the action, scope, and output enrichment. It could mention potential issues like invalid addresses or pagination, but is sufficient for typical use.

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

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

Schema coverage is 100% with a clear parameter description. The tool description adds value by explaining the enriched output but does not enhance parameter semantics further. Baseline 3 is appropriate.

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

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

The description clearly states the tool lists all ERC-20 tokens held by a wallet on Fuse, enriched with metadata. This distinguishes it from siblings like fuse_get_balance (single balance), fuse_list_supported_tokens (supported tokens list), and fuse_list_wallet_nfts (NFTs).

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 a wallet's full ERC-20 portfolio but does not explicitly state when to use vs alternatives or when not to use. No exclusions or context are provided.

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?

Only discloses the required API key. No information about idempotency, whether addresses are appended or overwritten, validation, rate limits, or side effects. With no annotations, the description should cover these aspects.

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 brief and front-loaded, but it omits crucial details like return value and behavior. It is concise but insufficient for full understanding.

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 few parameters and no output schema, the description is adequate but lacks context about prerequisites, error handling, and return value. Does not mention that the webhook must already exist.

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

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

Schema coverage is 100%, so baseline is 3. The description adds no additional meaning beyond the schema's parameter descriptions; it merely restates that addresses are added.

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

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

Description clearly states the action: adding EVM addresses to a webhook's listening scope. Uses a specific verb and resource, and distinguishes from sibling tools like remove_addresses and create_webhook.

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 vs alternatives. Does not mention prerequisites like having a webhook created first, nor does it explain when to use this instead of update_webhook or remove_addresses.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It usefully notes the dual authentication requirement (apiKey and API-SECRET). However, it does not mention any potential side effects, such as whether creating a webhook with an existing URL would overwrite or conflict, nor does it describe the creation result (e.g., webhook ID).

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, front-loaded with the primary function, and every sentence provides essential information. There is no wasted text.

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

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

The description covers the authentication context and the basic purpose. However, with no output schema, it would be helpful to mention what the tool returns (e.g., webhook ID, confirmation). It also does not specify prerequisites like project existence. Overall, it is mostly complete for a simple creation tool.

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

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

Schema coverage is 100%, so each parameter already has a detailed description in the schema (e.g., eventType enum with notes on ERC721 covering ERC1155). The description adds no further parameter-level meaning beyond what the schema already provides, so baseline score of 3 is appropriate.

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

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

The description clearly states the verb 'Create' and the resource 'Fusebox Notification webhook for a project', which exactly matches the tool's function. It distinguishes this creation tool from sibling tools like delete, get, update, and list webhooks.

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 specifies the required authentication secret, which is a key usage condition. It does not explicitly state when to use this tool over alternatives, but the action 'create' and the resource context are clear among sibling notification 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 explicitly states the tool is destructive ('Permanently delete', 'Destructive — the webhook stops receiving events') and requires an API key. Since no annotations are provided, the description fully conveys the irreversible behavior.

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

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

Two sentences, front-loaded with the core action, no extraneous words. Every sentence adds value: action, destructive consequence, and requirement.

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 one parameter and no output schema, the description covers the action, its destructive nature, and the required API key. No additional context is needed for complete understanding.

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 100% coverage with a single parameter webhookId, described as 'ID of the webhook to delete.' The description does not add extra semantics beyond what the schema already provides, so baseline 3 is appropriate.

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

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

The description clearly states the action (permanently delete) and the resource (Fusebox Notification webhook). It distinguishes itself from sibling tools like create, get, or update by specifying deletion.

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 usage for deleting a webhook but does not explicitly provide when to use versus alternatives or when not to use. The destructive nature is noted, but no alternative tools or contexts are mentioned.

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

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

Without annotations, the description carries the burden of behavioral disclosure. It states 'retrieve,' indicating a read operation, and notes the required API key. However, it does not disclose potential side effects, rate limits, or return format.

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

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

The description is extremely concise: two sentences front-loaded with the purpose and followed by an auth requirement. 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 simple retrieval tool with one parameter and no output schema, the description covers purpose and auth. It could be more helpful by mentioning the return structure or source of the webhook ID, but it is minimally adequate.

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 for the single parameter is 100%, and the schema description adequately explains 'Webhook ID to retrieve.' The tool description adds no additional meaning beyond what the schema provides.

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

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

The description clearly states the action (retrieve details) and the resource (a single webhook). It distinguishes itself from sibling tools like fuse_notification_list_project_webhooks by specifying 'single'.

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 guidance on when to use this tool versus alternatives, such as the list tool for multiple webhooks. It mentions a required API key but does not explain the context of use.

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

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

No annotations are provided, so the description carries full burden. It discloses the API key requirement but does not mention side effects, rate limits, or other behavioral traits. Minimal disclosure.

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

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

The description is a single sentence plus the API key requirement, with zero waste. It is front-loaded with the purpose.

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 is adequate for a simple list operation but lacks details about the return format or pagination. With no output schema, the description should ideally cover what is returned.

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

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

Schema description coverage is 100% for the single parameter 'webhookId'. The description does not add any additional meaning beyond what the schema already provides, so baseline score of 3 is appropriate.

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

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

The description clearly states the verb 'list' and the resource 'EVM addresses monitored by a given webhook'. It is specific and distinguishable from sibling tools like 'add_addresses' or 'remove_addresses'.

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

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

No explicit guidance on when to use this tool versus alternatives. The description mentions the required API key but lacks context about prerequisites, use cases, 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?

No annotations are provided, so the description carries full burden. It discloses authentication requirement (secret API key) and implies a read-only list operation, but lacks details on output format, error handling, or limitations.

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 wasted words. The purpose and prerequisite are front-loaded, making it efficient and easy to parse.

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 simplicity (one param, no output schema), the description covers the essential purpose, parameter, and auth. However, it leaves out return value format and potential errors, which could be helpful given no output schema.

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

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

Schema description coverage is 100% for the single parameter projectId. The description adds no additional meaning beyond what the schema already provides, meeting the baseline.

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

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

The description clearly states it lists every webhook for a given project, using specific verb ('list') and resource ('webhooks'). It distinguishes from sibling notification tools like get, create, delete by specifying '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?

The description indicates when to use (when needing a list of webhooks for a project) and includes prerequisite information (requires secret API key). However, it does not explicitly exclude alternatives or mention when not to use.

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

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

No annotations are provided, and the description only mentions an API key requirement. It does not disclose side effects, error cases, idempotency, or what happens if addresses are not monitored. This is insufficient for a modification operation.

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

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

The description is a single short sentence plus a requirement, no wasted words. It is concise and front-loaded with the main action.

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 two required parameters and no output schema, the description is adequate. It states what it does and a key requirement, though some behavioral details (e.g., preconditions) are missing.

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

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

Schema coverage is 100%, so the schema already describes both parameters. The description adds no additional meaning beyond what is in the schema, so baseline 3 is appropriate.

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

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

The description clearly states the action 'Remove EVM addresses' from the resource 'webhook's listening scope'. It uses a specific verb and resource, and distinguishes from sibling 'fuse_notification_add_addresses' by the opposite 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?

The description includes a prerequisite (requires API key) and implies usage for removing addresses, contrasting with add_addresses. However, it does not explicitly state when not to use this tool or provide direct 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?

The description mentions the required authentication key ('Requires FUSEBOX_SECRET_API_KEY'), which is useful. However, it does not disclose other behavioral details such as whether the update is partial or full replacement, side effects, or error conditions. With no annotations, this is a moderate disclosure.

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

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

Two concise sentences, front-loaded with the main action. The second sentence adds necessary authentication context. 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?

The description covers purpose and authentication but lacks details on behavior (e.g., whether the update is incremental) and response information. Given no output schema and no annotations, this is adequate but has clear gaps.

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

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

Schema coverage is 100% with each parameter having a description. The description adds 'URL or event type' but the schema requires both parameters, creating a slight mismatch. No additional parameter-level context is provided 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 clearly states the action ('Update'), the resource ('a Fusebox Notification webhook'), and the specific updatable fields ('URL or event type'). This distinguishes it from sibling tools like create, delete, or get webhooks.

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 explicitly states when to use the tool (to update a webhook's URL or event type). While it doesn't explicitly mention when not to use it or provide alternatives, the sibling tools naturally cover other operations, making usage context 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?

Describes the read-only nature (view/pure) and the auto-fetching behavior for ABI. Lacks details on error handling if ABI not found or network failures, but covers key behavioral aspects.

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 efficient sentences with no redundancy, front-loading the core purpose.

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?

Sufficient for a read tool; lacks mention of return values but this is often implicit for view functions. No output schema exists, so description could slightly expand on expected 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?

Adds meaningful context for the 'abi' parameter (optional, auto-fetched), which is beyond the schema description. Other parameters are straightforward and schema covers them.

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 calls view/pure functions on Fuse contracts, with auto-fetched ABI. It distinguishes from write actions and other read tools.

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

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

Usage is implied for custom view/pure function calls, but no explicit guidance on when to use versus alternative read tools or when not to use.

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

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

No annotations provided, so description carries full burden. It discloses that ENS resolution depends on Ethereum mainnet access via a configurable RPC URL, and that plain addresses are returned unchanged. This reveals key behaviors beyond the basic action.

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 main action, followed by essential context. No wasted words. Every sentence earns its place.

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

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

For a simple resolution tool with one parameter and no output schema, the description covers the key aspects: action, prerequisite (ENS_RPC_URL), and edge case (pass-through). Could mention return format, but it's implied.

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

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

Schema coverage is 100% with a good parameter description. The description adds minimal extra meaning beyond the schema, noting that plain addresses are passed through. This meets the baseline but does not significantly enhance understanding.

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 clearly states 'Resolves an ENS name to its EVM address', using a specific verb and resource. It distinguishes from all sibling tools (none are for ENS resolution), making the purpose unambiguous.

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

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

Provides explicit context: ENS not deployed on Fuse, requires external ENS_RPC_URL configuration, and plain hex addresses pass through. While it doesn't explicitly state when not to use the tool, this information sufficiently guides the agent on appropriate usage.

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

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

With no annotations provided, the description bears full burden for behavioral disclosure. It reveals that the transaction is submitted from the server's signer (a key behavior) and that decimals are auto-fetched. It does not detail potential failure modes (e.g., insufficient balance) or return behavior, but the disclosed traits are significant and accurate.

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, front-loading the core purpose and mechanism in the first sentence, and then immediately providing actionable parameter guidance in the second. Every clause earns its place, with no redundant or vague phrasing.

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

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

Given the moderate complexity (4 parameters, no output schema), the description covers the essential aspects: action, signing party, token decimals, and unit option. It lacks details on return value (transaction hash? receipt?) which might be relevant for an outputless tool, but overall it is sufficiently complete for an agent to invoke 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?

The input schema covers 75% of parameters with descriptions (to, amount, tokenAddress). The description adds value by explaining the auto-decimal feature and the effect of the unit parameter ('skip scaling'), which supplements the schema's description of amount and unit. This added semantic context helps agents understand scaling 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 clearly states the tool submits a signed ERC20.transfer from the server's signer, specifying the exact operation and actor. This distinguishes it from sibling tools like fuse_send_native (native token) and fuse_smart_transfer_token (smart wallet), making the purpose 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 provides clear context for using the unit parameter ('use unit: base to skip scaling'), guiding the agent on when to adjust units. However, it does not explicitly mention when to use this tool over alternatives like fuse_send_native or fuse_smart_transfer_token, so it lacks explicit exclusions or alternative references.

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 the tool submits a signed transaction (implying irreversible transfer) and returns a transaction hash. No annotations exist, so the description carries the transparency burden. It does not mention auth requirements, rate limits, or the need for the server signer to have sufficient balance.

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 clear sentence plus a helpful follow-up instruction. It is concise, front-loaded with the action, and contains 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 simple transaction tool with fully documented parameters, the description covers the main purpose, return value, and next steps. Could briefly note that the server signer must have sufficient funds, but overall it's 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?

Input schema has 100% coverage, so parameters are already well-documented. The description adds minimal extra value by restating default unit behavior. Baseline 3 is appropriate.

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

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

The description clearly states the verb (submits a signed transaction), resource (native FUSE), and action (transferring to a recipient). It distinguishes from siblings like fuse_send_erc20 and fuse_get_receipt, which handle different operations.

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 specifies when to use the tool (to send native FUSE) and provides a post-action recommendation (use fuse_get_receipt to confirm inclusion). However, it does not explicitly mention when NOT to use it or suggest alternative tools for different scenarios.

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

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

With no annotations, the description carries full burden. It discloses server-side signing, EIP-191 format, output as 65-byte hex, and that no transaction occurs. It does not discuss idempotency, rate limits, or authentication, but these are reasonable for a signing tool. The transparency is strong but not exhaustive.

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

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

Three sentences, front-loaded with purpose, no unnecessary words. Every sentence adds value: action, output format, and key behavioral note.

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

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

Given two parameters with full schema coverage, no output schema, and no annotations, the description is complete. It explains input encoding, output format, and side-effect (no transaction), which is all the agent needs to select and invoke correctly.

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

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

Schema coverage is 100%, but the description adds meaningful context: it clarifies that message is UTF-8 by default and provides the hex encoding option for raw bytes with the expected format ('0x-prefixed'), going beyond the schema's brief descriptions.

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

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

The description clearly states the verb 'sign', the resource 'message', and the standard 'EIP-191 (personal_sign)', distinguishing it from sibling tools like fuse_sign_typed_data and fuse_send_native (which submit transactions). It also specifies the output format (65-byte hex signature).

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 explicitly states 'No on-chain transaction is submitted', implying it is for off-chain signing. It does not explicitly mention when not to use it or suggest alternatives like fuse_sign_typed_data for typed data signing, leaving the agent to infer from sibling names.

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

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

No annotations are provided, so the description carries the burden. It only mentions the return format and that no on-chain transaction is submitted. It lacks disclosure of authorization needs, signer identity, or potential side effects beyond what is stated.

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 wasted words. The most critical information is front-loaded: the action, the return format, and a key behavioral note. Every sentence earns its place.

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

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

Given 4 required parameters with nested objects and no output schema, the description adequately explains the return value (65-byte hex signature). However, it does not cover prerequisites (e.g., server signer configuration) or error conditions, leaving some gaps for a complex 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?

All 4 parameters have schema descriptions (100% coverage). The description adds extra value by clarifying that the `EIP712Domain` entry should be excluded from the types map as it is derived from `domain`. This goes beyond the schema definitions.

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 clearly states the tool signs EIP-712 typed data with the server's signer and returns a 65-byte hex signature. It distinguishes itself from other signing tools like fuse_sign_message by specifying the structured payload and noting no on-chain transaction is submitted.

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 off-chain signing but does not explicitly compare with alternatives or provide when-not-to-use criteria. The mention of no on-chain transaction helps, but guidance is minimal.

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

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

No annotations are provided, so the description must fully disclose behavior. It states 'atomically' implying single-transaction execution but lacks details on failure handling, permissions (requires configured smart wallet), or side effects beyond the approval and call.

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

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

The description is a single sentence that conveys the core functionality without superfluous words. It is well-structured and to the point.

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 moderate complexity (atomic multi-step with 5 parameters, no output schema). The description omits details about the return value, error scenarios, and prerequisites beyond 'configured smart wallet.' This leaves gaps for the agent.

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 80% (4 of 5 parameters have descriptions). The description adds the context that the call is invoked on the spender after approval, but individual parameter descriptions are already clear. The missing 'unit' parameter has no description, but the description does not compensate.

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 specific verbs ('approves' and 'invokes') and identifies the resource ('token' and 'spender'), clearly distinguishing it from siblings like fuse_smart_approve_token (approval only) and fuse_smart_call_contract (call only).

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 mentions 'Common DeFi pattern' which implies a typical use case, but does not explicitly state when to use this tool versus alternatives or provide exclusion criteria.

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

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

No annotations are present, so the description must fully disclose behavior. It mentions 'submits a UserOperation' and 'from the configured smart wallet', implying gas costs and wallet setup. However, it does not detail side effects (state change), error cases, or the need for wallet deployment.

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, focused sentence of 20 words. No redundant or unnecessary information. Every word contributes to understanding the tool's core action.

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 approval tool, the description covers the action and context well. It is missing information about return values (no output schema) and post-submission steps like checking transaction receipts or handling approvals in subsequent operations.

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

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

Schema coverage is 100% with parameter descriptions. The tool description adds value by specifying the underlying function signature 'approve(spender, tokenId)' and the NFT contract context, which helps understand the role of nftContractAddress beyond schema definitions.

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 submits an ERC-4337 UserOperation calling 'approve' on an NFT contract from a smart wallet. It uses specific verbs and resources, distinguishing it from siblings like fuse_smart_approve_token (for ERC20) and fuse_smart_transfer_nft (for transfers).

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 alternatives such as fuse_smart_approve_token or fuse_smart_approve_and_call. The description does not mention prerequisites, success criteria, or when not to use it.

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

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

The description reveals that it submits a UserOperation, implying a transaction that requires gas and is submitted to the blockchain. However, it does not disclose that authentication via the smart wallet is needed or that this is a write operation. Without annotations, more detail would be helpful.

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 efficiently conveys the core action and mechanism. No unnecessary words, front-loaded with the purpose.

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 4-parameter tool with no output schema, the description is mostly complete. It lacks details about the return value (likely a UserOp hash) and prerequisites (wallet authentication), but the core function is well covered.

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

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

With 75% schema description coverage, the schema already explains amount, spender, and tokenAddress. The description adds context about the smart wallet, but the value 'above schema' is minimal. The 'unit' parameter is not described in the schema, and the description does not clarify it.

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

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

The description clearly states the action: submitting a UserOperation to call ERC20.approve on a smart wallet. It distinguishes from siblings like fuse_smart_approve_nft and fuse_smart_approve_and_call.

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

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

No guidance on when to use this tool versus alternatives (e.g., fuse_smart_approve_and_call, fuse_smart_approve_nft). The description does not mention prerequisites or typical usage scenarios.

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

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

With no annotations, the description carries the full burden. It only states 'submits a UserOperation' and mentions the smart wallet, but lacks details on side effects, return values, prerequisites, or gas implications. This is insufficient for an agent to fully anticipate behavior.

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

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

Two sentences, no fluff. The action is stated first, then the usage guidance. 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?

The tool submits a complex UserOperation but omits key context: what is returned (e.g., UserOp hash), prerequisites (smart wallet configuration status), and failure behavior. Given the lack of output schema and annotations, the description should provide more 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 100% with each parameter already described (to, data, valueWei). The description adds no additional meaning beyond 'arbitrary calldata' and 'full control', so the baseline of 3 is appropriate.

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

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

The description clearly states the tool submits an ERC-4337 UserOperation to call a contract with arbitrary calldata. It distinguishes itself from siblings like fuse_read_contract and fuse_smart_execute_batch by emphasizing full control over the encoded call and the use of the smart wallet.

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 advises using this tool when full control over the encoded call is needed, which implies it's suitable for raw calldata scenarios. However, it does not explicitly mention when to avoid it or compare to alternatives like fuse_smart_approve_and_call.

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

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

With no annotations, the description carries full burden. It discloses atomicity and revert-on-failure behavior, which is valuable. However, it omits important behavioral traits such as authentication requirements, gas costs, and failure modes beyond revert.

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 key purpose, no wasted words. Highly efficient.

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

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

Despite having one parameter and no output schema, the description fails to mention return value (e.g., UserOp hash) or error conditions. Given the complexity of ERC-4337 operations, this is a significant gap.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds no extra meaning beyond the schema; it just restates the atomic batch context. No additional clarification on parameter usage or constraints.

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 submits a single ERC-4337 UserOperation to execute a sequence of contract calls atomically. It distinguishes from siblings like fuse_smart_call_contract by emphasizing batch execution and atomicity.

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 atomic batch execution but does not explicitly state when to use versus alternatives (e.g., single call). No mention of preconditions or when not to use, providing minimal 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?

No annotations are provided. The description discloses the return values but does not explicitly state that the tool is read-only, nor does it mention prerequisites like needing a configured signer or any other behavioral constraints.

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, concise sentence that is front-loaded and contains no unnecessary words. Every part adds value.

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

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

Given zero parameters and no output schema, the description covers the essential purpose. However, it could be slightly more complete by hinting at the return format (e.g., boolean for paymaster).

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 are zero parameters and schema coverage is 100%, so the description does not need to add parameter meaning. Baseline 4 is appropriate.

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

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

The description clearly states it returns the ERC-4337 smart-wallet address and paymaster status, using specific verb 'Returns' and distinct resource. It differentiates from sibling tools like fuse_smart_wallet_get_actions and fuse_smart_wallet_authenticate.

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 when the smart-wallet address or paymaster status is needed, but does not explicitly state when to use this tool versus alternatives like fuse_get_signer_address or fuse_smart_wallet_get_actions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It indicates the tool submits an on-chain UserOperation (a write action) but does not detail gas requirements, reversibility, or side effects beyond staking.

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 efficient sentences. The first sentence states core functionality, the second adds a critical prerequisite. No wasted words; the description is front-loaded and easily parsable.

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 lacks an output schema, and the description does not mention what the return value is (e.g., UserOperation hash). While it covers the action and prerequisites, it omits expected response details, which could affect an agent's follow-up actions.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds value by specifying that `tokenAddress` must match a `fuse_get_staking_options` entry and clarifying that `tokenAmount` is in base units (wei). This goes 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 explicitly states it submits an ERC-4337 UserOperation to stake a token using Fuse's staking module. It clearly distinguishes the action (stake vs. unstack) and resource, making it distinct from sibling tools.

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

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

The description advises listing staking options first with `fuse_get_staking_options`, providing a clear prerequisite. However, it does not mention when to avoid using this tool or alternatives, which would be helpful.

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

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

No annotations are present, so the description carries the full burden. It states it submits a UserOperation, implying an on-chain write, but does not disclose that it is a state-changing mutation, requires authentication (e.g., smart wallet), has gas costs, or may fail. Critical behavioral details are missing for a transaction 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?

The description is extremely concise, consisting of two sentences that efficiently convey the tool's action and a prerequisite. Every sentence earns its place with 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?

Given the tool's complexity (swap via UserOperation, no output schema), the description lacks details about prerequisites (e.g., approved tokens, smart wallet existence), what the response contains, and potential failure modes. It is minimally adequate but leaves gaps.

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

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

Schema coverage is 100%, so the input schema already describes each parameter adequately. The description adds no additional parameter meaning beyond what the schema provides. Baseline score of 3 is appropriate.

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

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

The description clearly states it submits an ERC-4337 UserOperation to execute a swap via the Fusebox engine. It distinguishes itself from the quoting tool and other swap-related tools by specifying the execution 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?

The description explicitly instructs users to first quote a swap with 'fuse_get_trade_quote' before using this tool, providing clear guidance on when to use it. However, it does not exclude alternative tools or mention conditions when not to use it.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It notes the tool submits a UserOperation, but fails to mention important traits like required approvals, gas costs, reversibility, or success conditions. The minimal detail leaves significant gaps for an agent.

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

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

The description is a single, front-loaded sentence that states the action, mechanism, and target. Every word serves a purpose with no redundancy. Efficient and clear.

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 moderate complexity (smart account, user ops) and simple schema without output schema, the description is adequate but misses details about prerequisites (e.g., approval), return value (likely userOp hash), and smart wallet configuration. It provides the core function but lacks completeness.

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

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

Schema covers 100% of parameters, each with descriptions. The tool description does not add additional meaning beyond what the schema already provides. Per rubric, baseline is 3 when coverage is high, and the description does not enhance parameter understanding.

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 specific verb 'submits' and resource 'NFT', clearly indicating it transfers NFTs (ERC-721/ERC-1155) via ERC-4337 UserOperation from the smart wallet to a recipient. It distinguishes well from sibling tools like fuse_smart_transfer_token (ERC20) and fuse_send_native.

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 clear context for transferring an NFT from a smart wallet, but does not explicitly state when to use this tool versus alternatives like fuse_smart_approve_nft or fuse_smart_call_contract. No exclusions or prerequisites are mentioned, leaving the agent to infer usage.

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

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

With no annotations, the description provides some behavioral insight: it submits a UserOperation, transfers tokens, and can be gasless. However, it lacks details on auth requirements, prerequisites (wallet deployment), error conditions, and behavior when paymaster is disabled.

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 with a conditional clause, extremely concise and front-loaded with the core action ('Submits an ERC-4337 UserOperation'). 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?

While the description covers the basic action and gasless option, it omits prerequisites (wallet deployment), what happens without paymaster, return format, and authentication requirements. Given the tool's complexity (ERC-4337, smart wallet), more context is needed.

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 has 75% description coverage (3 of 4 params described). The description adds value by clarifying the unit parameter's default behavior and the sentinel address for native tokens. The unit parameter lacks schema description, but the description doesn't explain its enum choices.

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 submits an ERC-4337 UserOperation to transfer tokens (native FUSE or ERC-20) from a configured smart wallet. It distinguishes from siblings like fuse_send_erc20 and fuse_send_native which handle direct transfers.

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 smart wallet token transfers and mentions gasless capability with paymaster, but does not explicitly state when to use this over siblings or when not to use it. No alternative tools are mentioned.

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

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

No annotations are provided, so the description carries full burden. It states the tool submits a UserOperation, implying an on-chain transaction, but does not disclose side effects (e.g., gas costs, asynchronous nature, requirement for prior approvals, or what happens to receipt tokens). The behavioral impact is under-communicated.

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 efficiently conveys the core action. It is not verbose, but could have included slightly more context (e.g., what the return value is) without becoming wordy. Structured well with no extraneous information.

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

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

No output schema exists, yet the description does not explain the return value (likely a transaction hash or userOp hash). Lacks information on required preconditions, such as needing a smart wallet or having staked tokens. For a 3-parameter tool with simple purpose, the description is incomplete in providing operational context.

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

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

Schema description coverage is 100%, and the schema already defines parameters clearly (e.g., 'Amount to unstake, in base units'). The description adds no additional meaning beyond what the schema provides, meeting the baseline for high coverage.

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 clearly states the action ('submits an ERC-4337 UserOperation that unstakes a token') and differentiates from siblings like fuse_smart_stake_token. It specifies the mechanism ('via Fuse's staking module') and uses a specific verb+resource combination.

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 alternatives, such as fuse_smart_stake_token or other staking operations. No prerequisites or conditions (e.g., need to have staked tokens, being the smart account owner) are mentioned. The description assumes the agent knows the 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?

The description discloses that the tool exchanges a signature for a JWT and that signing is not performed by the tool, which is a key behavioral trait. However, it does not detail error handling (e.g., invalid signature) or state whether the JWT is returned directly or stored, which would help the agent anticipate behavior. Since no annotations are provided, the description carries full burden for transparency.

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 purpose and action, followed by a clarifying statement on client-side signing. Every sentence adds value, 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?

For a tool with 4 parameters, full schema coverage, no output schema, and a clear authentication procedure, the description sufficiently explains the overall process and output (JWT for Bearer auth). It also references a sibling tool to contextualize use, making it complete for the task.

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

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

Schema coverage is 100% with clear parameter descriptions already present. The description adds minimal context beyond the schema, mostly repeating that signing is client-side and that ownerAddress refers to the EOA owner. Baseline of 3 is appropriate given high schema coverage.

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's purpose: exchanging an EIP-191 signature for a JWT for Bearer authentication on Smart Wallet API calls. It explicitly mentions a use case (fuse_smart_wallet_get_actions) and distinguishes the tool from other smart wallet tools by focusing on authentication.

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 that signing happens client-side and this tool only submits the signed payload, implying the user must already have a signature. However, it does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions or prerequisites like needing a deployed smart wallet.

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

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

With no annotations, the description carries the full burden. It discloses that the tool lists paginated history of transfers and contract calls, and requires a valid JWT. However, it doesn't mention if the operation is read-only or any side effects, though read-only is implied. It lacks details on pagination behavior like total count or error handling.

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 core purpose. Every word is meaningful—no fluff, no repetition. It efficiently conveys the tool's function and a key prerequisite.

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 lack of an output schema, the description hints at the content (action history, transfers, contract calls) and mentions pagination and authentication. It covers the essential context for usage. However, it could be more complete by describing the return format (e.g., list with pagination metadata) or potential errors.

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

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

Schema description coverage is 100%, with all four parameters described in detail. The description adds context that the JWT comes from a specific authentication tool and that the list is paginated, but these are already clear from the schema. It does not significantly enhance understanding beyond what the schema provides.

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

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

The description clearly states the tool lists paginated action history (transfers, contract calls) of an authenticated smart wallet. This is a specific verb-resource combination, and it distinguishes from siblings like fuse_send_erc20 or fuse_smart_transfer_token, which perform actions rather than list history.

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 indicates the JWT must come from `fuse_smart_wallet_authenticate`, providing a clear prerequisite. It also implies usage for retrieving history with pagination. However, it does not explicitly exclude when not to use or list alternatives like other tools that might return similar data.

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

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

No annotations are provided, so the description must carry full weight. It only states that the tool returns a price and route, with no information about side effects, authentication needs, rate limits, or behavior on errors. This is insufficient for a 15-parameter 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?

Two sentences, first states purpose, second adds a crucial constraint. No redundant information. Front-loaded and efficient.

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 15 parameters, no output schema, and no annotations, the description is far from complete. It does not explain the output format, error conditions, or how to interpret the route. Leaves too much to domain knowledge.

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 covers 60% of parameters with descriptions. The description adds the key constraint that sellAmount/buyAmount are mutually exclusive and one must be provided, but it does not elaborate on other optional parameters or their interplay. Overall, marginal added value beyond schema.

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

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

The description clearly states it returns an indicative price and route for a swap on Fuse using 0x-style. It specifies the resource and action, and distinguishes from siblings like fuse_get_trade_quote by mentioning '0x-style response'. However, it does not explicitly differentiate from other trade tools.

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

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

The description gives one usage constraint ('One of sellAmount/buyAmount must be provided') but provides no guidance on when to use this tool versus alternatives like fuse_get_trade_quote or when not to use it.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only says 'returns' which implies a read operation, but it does not mention authentication needs, rate limits, or any side effects. The description is too minimal to convey important 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?

The description is a single sentence that efficiently communicates the tool's purpose. It is front-loaded with the action and resource, and includes examples for clarity, with 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?

Given that the tool has no parameters and no output schema, the description is adequate for a simple list tool. It could be improved by specifying the return format (e.g., array of strings) or clarifying that the list is for the current user/chain configuration, but it is not incomplete.

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 100% because the schema is empty. The description does not need to add parameter details, but it could provide more context about the output format or the nature of the liquidity sources list. It adds basic value by naming example sources.

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

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

The description explicitly states it 'returns the liquidity sources currently enabled for Fuse-chain trades' and provides examples like voltage.finance and sub-pools. This clearly distinguishes it from sibling tools that deal with trading, prices, or contract deployment.

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 on when to use this tool versus alternatives. Among siblings, there are related trade tools (e.g., fuse_get_trade_quote, fuse_trade_indicative_price), but the description does not explain when to prefer this one or when not to use it.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only mentions the return format but does not state that it is a read-only operation, any side effects, or prerequisites like network requirements. The description does not compensate for missing 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 sentence that front-loads the purpose and includes the return format. No unnecessary details; 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?

For a simple tool with two parameters and no output schema, the description is nearly complete. It could mention that days must be a positive integer (already in schema) but lacks potential error conditions. Overall adequate.

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

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

Schema description coverage is 100%, so the schema already documents both parameters fully. The description adds the context of 'custom day-count window' but does not provide additional meaning beyond what the schema offers. Baseline score of 3 is appropriate.

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

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

Clearly states it returns a token's price change over a custom day-count window. The verb 'returns' and resource 'token's price change' are specific. However, it does not explicitly differentiate from similar siblings like fuse_get_token_price_change, which may have a similar purpose.

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 alternatives like fuse_get_token_price_change or fuse_get_token_price_history. The description lacks any context about appropriate usage scenarios.

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

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

No annotations provided, so description carries full burden. It discloses state-mutation, server signer usage, auto-ABI fetch, and return of transaction hash. However, it omits important traits like gas estimation, potential failure modes, signer fund requirements, or reversibility. This is insufficient for a mutation tool.

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

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

The description is two sentences, with the core action front-loaded and a secondary detail about ABI fetching. No wasted words; every sentence is 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?

Given 5 parameters all described, no output schema, and sibling tools, the description covers the core purpose and return value. However, it lacks explicit differentiation from smart wallet write tools (fuse_smart_call_contract) which could cause confusion. Mostly complete.

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

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

Schema coverage is 100% with all parameters described. The description adds value by explaining the optional ABI override behavior ('If omitted, the verified ABI is fetched from the Fuse explorer'). This goes beyond the schema but does not address all parameters in depth, maintaining baseline 3.

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

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

The description clearly states 'Signs and submits a state-mutating contract call from the server's signer.' This distinguishes it from read-only tools like fuse_read_contract and other write tools like fuse_send_erc20.

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

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

Usage context is implied (state-mutating calls) but no explicit guidance on when to use this tool versus alternatives like fuse_smart_call_contract or fuse_send_native. No exclusions or when-not-to-use are mentioned.

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