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 does not state that this is a read-only/non-mutating operation, what metrics 'distribution and concentration' resolve to, whether it covers on-chain holders only, or any rate/scope limits, leaving significant behavioral gaps.

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

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

A single front-loaded sentence that states the action and object with no filler or redundancy. It is concise, though its brevity contributes to the missing behavioral and usage context noted elsewhere.

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

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

This is an analysis tool with no output schema and no annotations, so the description should convey what the analysis yields (concentration metrics, top-holder breakdowns, etc.) and any caveats. It fails to do so, leaving the agent without enough context to call it correctly or interpret results.

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

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

Schema description coverage is 100% and there is a single documented parameter ('symbol' as 'Fan token symbol'), so the schema already covers semantics. The description adds no syntax, format, or constraint detail beyond what the schema provides, making the baseline 3 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 states a specific verb ('Analyze') and resource ('token holder distribution and concentration'), which is clear enough for an agent to know what it does. However, it provides no differentiation from closely related siblings like get_token_holders or compare_token_distributions, so the agent cannot tell when this is preferred over those.

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

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

There is no when-to-use guidance, no prerequisites (e.g., whether the symbol must be a known fan token), and no mention of alternatives such as get_token_holders or compare_token_distributions. The agent is left to infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose whether the tool is read-only, how correlation is computed, what the return format looks like, or any auth/rate-limit behavior.

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

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

A single front-loaded sentence with no filler or repetition. It is structurally clean, though arguably too terse for a multi-parameter analytical tool.

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

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

With no output schema, no annotations, and only 50% parameter coverage, the description omits what 'team performance' means, the correlation method, period behavior, and return shape. It is materially incomplete for an analysis 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 50%: token has no description and period only says 'Days to analyze'. The description mentions token price but does not explain the token parameter's format or the period's default/range, so it fails to compensate for the undocumented 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?

States a specific verb 'analyze' and a specific resource 'correlation between team performance and token price', which is clearer than a generic analytics sibling. However, it does not differentiate itself from related tools like query_fan_token_analytics or get_market_sentiment, and 'team performance' remains ambiguous.

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

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

The description gives no when-to-use guidance, no prerequisites, and no alternatives. It is a bare purpose statement with no routing information for the agent.

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 behavioral burden. It never states that this is a state-changing on-chain transaction that costs gas, is irreversible, requires a signing wallet, or that the granted allowance can later be spent by the spender — all critical facts 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?

A single front-loaded sentence with no wasted words. It is efficient, though the terseness is part of what leaves the behavioral and parameter gaps unfilled.

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

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

For a three-parameter write operation with no annotations, no output schema, and only one-third of parameters described, the definition omits far too much: gas/auth requirements, irreversibility, allowance semantics, and the meaning of two parameters.

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

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

Schema description coverage is only 33%: only 'spender' is documented. The description adds nothing about 'token' (address vs symbol) or 'amount' (why it is a string — base units vs decimal string), so with low coverage it fails to compensate for the schema gap.

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

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

The description names a specific verb and resource ('Approve token spending') with a clear scope ('for a contract'), which maps cleanly onto the ERC-20 approve operation. It does not differentiate itself from same-domain siblings like send_tokens, swap_tokens, or deploy_custom_contract, so it stops short of a 5.

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

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

There is no guidance on when to choose this over send_tokens or swap_tokens, nor any prerequisite (connected wallet, existing token balance, gas availability). The agent must infer that this grants an allowance rather than moving funds.

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 behavioral burden. It does not disclose that this is a read-only calculation (as opposed to actually staking/sending CHZ), nor what 'optimal' optimizes for, nor the return format. For a no-annotation tool this is a meaningful gap.

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

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

A single front-loaded sentence with zero filler, which is appropriately sized. It is terse rather than padded, though it could have used the space to add routing or behavioral context.

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 100% parameter coverage and no output schema, the parameter side is complete. But with no annotations and no explanation of what the calculation optimizes or returns, the definition is only minimally sufficient for an agent to call it correctly.

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

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

Schema description coverage is 100%, so the schema already documents amount, duration, and riskTolerance (including the enum and defaults). The description adds no meaning beyond the schema, so the baseline 3 applies.

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

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

States a specific verb ('calculate') and resource ('optimal stake distribution across validators'), so the agent can tell it is an analysis/routing tool rather than a data fetch. However, it does not differentiate itself from close siblings like compare_validators, calculate_staking_rewards, or get_validator_risks, so an agent must infer which validator-analysis tool applies.

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

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

The description gives no when-to-use context, no prerequisites, and no alternatives. It never says whether this should follow get_validator_risks or compare_validators, nor when to prefer it over calculate_staking_rewards, leaving selection entirely to inference.

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

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

No annotations provided, so the description carries full behavioral burden. It mentions no side effects, but as a read calculation, it's implied safe. However, no details on input validation, error conditions, or computational aspects are given.

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, concise, and front-loaded with the core purpose. No unnecessary information.

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

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

With no output schema and no annotations, the description is minimal. It tells what the tool does but not what it returns (e.g., price impact percentage, slippage) or any caveats. For a calculation tool, more context about output would help, but the schema covers parameters adequately.

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 parameter meanings are fully documented in the schema. The description adds no additional semantic details about the parameters, which is acceptable given the 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?

States a specific verb ('Calculate') and resource ('price impact for a swap on KAYEN'). It's clear what the tool does, though it doesn't differentiate from siblings like find_best_swap_route or detect_arbitrage, which also relate to swaps and pricing.

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 or why to use this tool versus alternatives. It doesn't mention prerequisites like the pool needing to exist or sufficient liquidity, nor does it contrast with swap_tokens or find_best_swap_route.

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 behavioral burden but says almost nothing. It does not clarify that this is a pure read-only projection (no transaction sent), whether it uses live validator APY or a fixed rate, or how the optional validatorAddress changes the result — all material for a staking calculation.

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

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

It is a single front-loaded sentence with no filler, which is efficient. The brevity borders on under-specification rather than excess, but nothing needs to be cut.

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 3-parameter calculation tool with no output schema and no annotations, the description is too thin. It should at minimum indicate what the projection depends on and that it returns a computed estimate rather than executing a stake.

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 three parameters documented (days, amount in CHZ, optional validatorAddress), so the baseline is 3. The description adds no additional semantic detail such as default behavior (30 days) or the effect of omitting a validator.

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?

"Calculate staking rewards projection" does state a clear verb (calculate) and resource (staking rewards projection), so the core purpose is legible. However, it offers no differentiation from closely related siblings such as calculate_optimal_stake, get_pool_apy, or compare_validators, leaving an agent to guess which calculation tool applies.

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

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

The description gives no when-to-use guidance, no prerequisites, and does not point to any alternative sibling. An agent gets no signal about whether this is a preferred tool over calculate_optimal_stake or get_pool_apy.

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, and it says nothing beyond the metric names: no indication of input edge cases (unknown token), computation window semantics, or whether results are cached/current. It does not contradict anything, but it discloses essentially nothing.

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

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

One short, front-loaded sentence with no wasted words, but its brevity reflects under-specification rather than disciplined editing.

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

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

With two parameters, no output schema, and no annotations, the description should explain what the metrics mean and what 'period' scopes the calculation to; it does neither, leaving an agent with insufficient information to invoke it confidently.

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

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

Schema coverage is 50%: 'period' is documented as days but 'token' has no description, and the description does not clarify whether 'token' expects an address, symbol, or ID. The description adds no parameter meaning beyond the schema, so it fails to compensate for the coverage gap.

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

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

The verb+resource are stated (calculate token velocity/turnover metrics), so the purpose is intelligible. However, a near-identical sibling, get_token_velocity_metrics, exists and the description does nothing to distinguish this tool from it, leaving the agent unable to choose correctly between them.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the obvious alternative get_token_velocity_metrics. The agent must infer usage entirely from the name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states what the tool does but omits whether the operation is read-only, what permissions are required, whether there are rate limits, and what the output looks like.

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

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

The description is a single front-loaded sentence with no wasted words. It is appropriately sized for a simple one-parameter tool.

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

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

For a low-complexity tool with full schema coverage, the description provides enough information to invoke the tool correctly with an array of token symbols. However, without annotations or an output schema, it leaves behavioral and return-format expectations underspecified.

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

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

Schema description coverage is 100%, and the single parameter is fully documented in the schema. The description adds no additional semantics beyond restating the multi-token scope, 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 states a specific verb ('Compare') and resource ('holder distributions') with a clear scope ('across multiple tokens'). It distinguishes the tool from single-token siblings like analyze_holder_distribution, though it does not explicitly name an alternative.

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

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

Usage is implied by the comparison framing and multi-token scope, but there is no explicit when-to-use guidance, no conditions, and no named alternatives to help an agent choose between this and tools like analyze_holder_distribution or get_token_holders.

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 behavioral burden and largely fails to: it never states this is a read-only operation, what fields or metrics are returned, or whether results are ranked. 'By performance and metrics' is the only hint about output shape.

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

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

A single tight sentence with the action front-loaded and no filler. It is efficient but extremely sparse, so it stops short of earning a 5.

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

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

For a tool with no annotations, no output schema, and 0% parameter documentation, the description should disclose the return shape and how limit/sortBy affect results. It omits all of this, leaving an agent to guess what comparison output looks like.

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

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

Schema description coverage is 0% and the description never mentions the limit or sortBy parameters. The sortBy enum values (apy, uptime, reputation, total_staked) are self-explanatory, but the description adds no meaning beyond them and leaves limit semantics (max validators returned?) undefined.

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

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

States a specific verb (compare) and resource (Chiliz validators) plus the axes (performance/metrics), which is enough to distinguish it from read-only siblings like get_validator_performance. However, it does not explicitly name which sibling answers a different question, so sibling differentiation is only implied.

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

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

There is no when-to-use guidance, no condition for choosing this over get_validator_performance or get_validator_risks, and no prerequisites. The comparison framing only weakly implies 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 carries the full behavioral burden and delivers almost none of it. It does not say the operation is an irreversible on-chain write, that it consumes gas, that credentials/funding are required, or whether it returns the deployed address (no output schema exists to compensate).

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

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

A single front-loaded sentence with no filler, which is efficient. It is arguably too terse for a deployment operation, but every word does work.

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 state-changing deployment tool with no annotations, no output schema, and no indication of cost, irreversibility, or return value, the definition is materially incomplete. An agent knows what the tool is called but not what invoking it commits to.

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

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

Schema description coverage is 100%, so all three parameters (sourceCode, contractName, constructorArgs) are already documented in the schema. The description adds no format or usage detail beyond that, so the baseline of 3 applies.

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

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

States a specific verb (deploy), a specific resource (custom Solidity smart contract), and the target network (Chiliz). The word 'custom' implicitly separates it from the preset deploy_erc20_token / deploy_nft_collection siblings, but it never names or contrasts them explicitly, so the agent must infer the distinction.

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 statement of when to use this tool versus the two closely related deployment siblings, and no prerequisites (deployer key, funded account, gas). The agent is left to infer routing 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure for a write/on-chain operation. It says the tool deploys a token but does not state that this is a state-changing, irreversible, gas-consuming transaction, nor mention authorization or confirmation requirements.

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

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

A single, front-loaded sentence with no filler. It is efficient, though terse enough that it leaves important behavioral context unstated.

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 deployment tool with three required params, no annotations, and no output schema, the description is incomplete. It omits what happens after deployment (address returned, where the token lives, whether deployment is permanent) and any authorization or cost context an agent needs.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters, including the important 'not wei' unit clarification for initialSupply. The description adds no parameter detail beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific verb (Deploy) and resource (custom ERC-20 token) plus the target chain (Chiliz), clearly distinguishing it from sibling tools like deploy_nft_collection and deploy_custom_contract. It is not a tautology and gives an agent enough to know what the tool produces.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor any prerequisites (e.g., wallet connection, gas funds, confirmation requirements). In a sibling set containing deploy_nft_collection and deploy_custom_contract, the absence of routing guidance is a real gap.

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

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

No annotations are provided, so the description carries the full behavioral burden. For a deployment operation it omits critical traits: that it is an irreversible write, that it costs gas, what wallet/auth is required, and what happens on success. Only the contract standard and chain are disclosed.

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

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

A single front-loaded sentence with zero filler. It is efficient, though it is arguably undersized for a high-stakes deployment tool, keeping it just below a full mark.

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

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

For a mutation tool with no annotations and no output schema, the description is too thin: it lacks prerequisites, gas/permission implications, irreversibility, and any note about the deployment result. The agent is left to infer the operational consequences.

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

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

Schema description coverage is 100%, so each of the four required parameters is already documented with examples in the schema. The description adds no parameter-level meaning beyond that, so the baseline 3 applies.

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

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

States a specific verb (Deploy), a precise resource (ERC-721 NFT collection), and the target chain (Chiliz). This cleanly separates it from siblings deploy_erc20_token and deploy_custom_contract without opening any schema.

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

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

The description offers no when-to-use or when-not-to-use guidance, and does not mention the obvious alternatives (deploy_erc20_token, deploy_custom_contract). Nothing tells the agent why to pick this deploy over another deploy sibling.

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 never states whether this is read-only analysis or executes trades, whether it queries live pools, what latency/cost it incurs, or what happens with the default thresholds. For a tool that could plausibly be action-oriented, that is a real gap.

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

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

A single efficient sentence with the scope front-loaded and no filler. It is terse but not padded; the only cost is that brevity leaves the behavioral questions unanswered.

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

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

No output schema and no annotations, so the description should describe the shape of the result (a list of opportunities? route pairs? profit estimates?) and whether anything is executed. It does neither, leaving an agent unable to predict the return value.

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

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

Schema description coverage is 100%, so both parameters (maxPriceImpact, minProfitPercentage) are already documented with defaults. The description adds nothing about how the thresholds interact or how they affect detection, so the baseline 3 applies.

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

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

States a specific verb ('Detect') and resource ('arbitrage opportunities') and bounds the scope to KAYEN vs other DEXs. It does not distinguish itself from siblings like find_best_swap_route or get_multiple_prices, so it stops short of a 5.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as find_best_swap_route or get_multiple_prices. The agent must infer that this is for opportunity scanning rather than route-finding or price lookup.

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, yet it says nothing about whether this is a read-only detection, how results are returned, what chain/scope it covers, or any thresholds beyond the loosely named parameters. Two params (blockRange, minValueUSD) hint at behavior but are not explained.

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

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

It is a single short phrase, so not bloated, but it is under-specified rather than concise. Nothing is front-loaded beyond the basic purpose, and the parenthetical synonym adds little.

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, 0% param coverage, and a crowded sibling space mean the description should do far more. The agent lacks enough to call this correctly or know how it differs from track_whale_movements.

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

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

Schema description coverage is 0%, and the description adds no meaning for blockRange or minValueUSD. It doesn't state units, defaults, or what 'blockRange' scans over, so the parameters remain fully undocumented. For a 2-param tool at 0% coverage, this is a serious gap.

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

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

States a clear verb+resource: 'Detect large transactions,' with 'whale trades' as a synonym. However, it does not distinguish this from the close sibling track_whale_movements or identify_unusual_patterns, leaving the agent unsure which whale-related tool to pick.

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

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

There is no when-to-use guidance and no mention of alternatives. With siblings like track_whale_movements sharing the whale-tracking space, this omission forces the agent to infer which tool is appropriate 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 carries the full behavioral burden, yet it says nothing about whether this is a read-only quote versus an executable operation, auth/allowance requirements, rate limits, or freshness of the quoted route. 'Optimal' is asserted without explaining the optimization criteria.

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

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

A single front-loaded sentence with zero waste. It is arguably under-specified rather than verbose, but as a conciseness measure it is 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?

No output schema and no annotations, so the description must convey return shape and safety profile; it does neither. An agent cannot tell what a 'route' response contains (hops, pools, expected output, price impact) or whether calling it has side effects, leaving a meaningful gap for a swap-routing tool.

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

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

Schema description coverage is 100%, so all three parameters (tokenIn, amountIn, tokenOut) are already documented in the schema. The description adds no extra meaning such as amount format/decimals, address-vs-symbol handling, or slippage expectations, so baseline 3 applies.

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

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

States a specific verb ('Find optimal swap route') and resource, and names the protocol (KAYEN). However, it does not distinguish itself from the sibling swap_tokens or from route-analysis tools like calculate_price_impact and detect_arbitrage, so an agent must infer that this is a routing/quote lookup rather than a swap execution.

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

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

There is no guidance on when to call this versus swap_tokens or the many price/analytics siblings. No prerequisites, no ordering hints (e.g., 'call before executing a swap'), and no exclusions.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: not whether the call is read-only, whether it hits a live node or cache, latency, or what fields come back. For a chain-state query with no output schema, this leaves the agent guessing about the response.

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 short sentence, front-loaded with the verb and resource, with no filler. It is efficient, though its brevity is partly a symptom of under-specification rather than disciplined concision.

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

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

With no output schema, no annotations, and no parameter docs, the description is the only source of truth and it does not say what 'information' means or what shape the response takes. For a zero-arg chain-info tool an agent needs at least a hint of the returned fields.

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

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

The schema declares zero parameters, so per the baseline there is nothing for the description to document. The absence of parameter text is appropriate here rather than a gap.

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

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

States a verb (Get) and a resource (Chiliz blockchain information), which is clear enough as a purpose, but 'information' is unspecified and does nothing to separate it from siblings such as get_recent_blocks or compare_validators. An agent cannot tell what class of data this returns from the description alone.

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

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

There is no when-to-use guidance, no conditions, and no mention of alternatives. With roughly 50 sibling tools, the description gives no basis for choosing this one over get_recent_blocks or get_websocket_status.

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 behavioral disclosure burden. It states it returns price and market data but does not describe what 'market data' includes, whether it's real-time or delayed, rate limits, or data freshness. For a read-only price tool this is a noticeable gap, though not critical.

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

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

The description is a single, front-loaded sentence with zero waste. It is appropriately sized for a simple one-parameter read tool.

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

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

Given the tool's simplicity (one required parameter, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks details on output format, data freshness, and how it differs from similar siblings, which would be helpful for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents the single parameter 'symbol' with examples. The description adds no additional meaning beyond what the schema provides, which aligns with the baseline of 3 when schema coverage is high.

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

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

The description states a clear verb and resource: retrieving current price and market data for a fan token. It identifies the resource specifically as a fan token, which is more specific than general price tools. However, it does not differentiate itself from siblings like get_multiple_prices or get_historical_price_data, leaving the agent to infer the scope from the name alone.

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

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

There is no explicit guidance on when to use this tool versus alternatives. With siblings such as get_multiple_prices, get_historical_price_data, and get_market_chart, the description provides no context, exclusions, or alternative suggestions. The agent must guess based on the name.

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

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

No annotations are provided, so the description carries the full burden. It implies a read operation but gives no details on authentication needs, rate limits, response format, pagination, or whether the list is static or dynamic. Only the bare purpose is disclosed.

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

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

A single, front-loaded sentence with no wasted words. Perfectly sized for a zero-parameter list tool.

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

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

Given the tool has no parameters, no output schema, and no annotations, the description is minimally adequate: it states what is returned. However, it does not compensate for the lack of structured metadata by explaining the list's format, source, or any behavioral caveats.

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

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

The tool takes zero parameters, so the baseline of 4 applies. No parameter semantics are needed or missing.

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

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

States a specific verb ('Get') and resource ('list of all supported fan tokens') with scope ('all supported'). It is clear what the tool does but does not explicitly differentiate from siblings like get_fan_token_price or query_fan_token_analytics.

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. The description only states what it does; it does not say when an agent should call it, when not to, or which sibling to prefer for related tasks.

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. 'Get' implies a safe read, but the description says nothing about pagination, default limit behavior, result ordering, or what the history contains. For a tool with zero annotation coverage, this is a notable gap.

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

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

A single compact sentence with the resource front-loaded and no filler. It is efficiently structured, though its brevity reflects under-specification rather than disciplined editing.

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

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

With no annotations, no output schema, and a schema that leaves limit undocumented, the description is too thin for the agent to invoke or interpret results confidently. It never states what a governance history record contains or how many results to expect.

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 67%: symbol and status are documented in the schema, while limit is only a bare number with a default. The description adds no parameter meaning at all beyond restating that a token is involved, so it does not compensate for the undocumented limit parameter or clarify status filtering.

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

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

The description names a specific verb (Get) and a specific resource (governance proposal and voting history) scoped to a token. It is unambiguous and clearly distinct from all siblings, none of which cover governance data. It loses a point only because it doesn't articulate scope details such as timeframe or proposal set.

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

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

There is no when-to-use, when-not-to-use, or alternative guidance. Nothing tells the agent whether this complements query_fan_token_analytics or how to choose between the related analytics siblings.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the data source (The Graph subgraph) and implies a read operation via 'Get', but omits any details about permissions, rate limits, return format, or data freshness, leaving significant gaps.

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

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

The description is a single, front-loaded sentence with zero waste. It efficiently communicates the core action and source.

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 (3 parameters, 1 enum, no annotations, no output schema), the description is too sparse. It lacks usage guidance, behavioral context, and any indication of the return values, leaving the agent to rely entirely on the 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%, so the schema already documents all three parameters. The description adds no additional meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description states a specific verb and resource ('Get historical price data') and names the data source ('from The Graph subgraph'). However, it does not differentiate this tool from similar siblings like 'get_market_chart' or 'get_fan_token_price', so the agent must infer the unique scope from the schema.

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

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

There is no guidance on when to use this tool versus alternatives. With many siblings that also retrieve price data, the description offers no conditions, exclusions, or routing cues.

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 says nothing about data source, recency, permissions, rate limits, return format, or whether this is a read-only or monitoring 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, front-loaded sentence with no wasted words. Its brevity, however, reflects under-specification rather than useful conciseness, and there is no structure beyond the phrase.

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 data-retrieval tool with two parameters, no annotations, no output schema, and 0% schema description coverage, the description is far too sparse. An agent would lack the information needed to call it correctly and interpret its results.

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

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

Schema description coverage is 0%, and the description does not mention either parameter. The required 'token' parameter and the optional 'minFollowers' parameter are left entirely undocumented, so the description fails to compensate for the schema gap.

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

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

States a verb ('Track') and a resource ('influencer mentions and activity'), so the general purpose is inferable. However, it is broad and does not distinguish this tool from sibling social-tracking tools such as track_social_momentum or get_social_sentiment.

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

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

No when-to-use guidance, prerequisites, or alternatives are provided. The description only implies that this tool is for tracking influencer activity, without saying when an agent should choose it over 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 full behavioral burden. It doesn't state whether results are cached, how current the standings are, whether it requires authentication, or what format the standings come in (positions, points, etc.).

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, front-loaded with the main action. No wasted words, though it could be slightly more 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?

With no output schema and no annotations, the description is incomplete. It doesn't describe return values, sorting, or what 'standings' includes, leaving significant gaps for an agent to call it correctly.

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

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

Schema coverage is 100%, and the parameter description already gives examples (Ligue1, LaLiga). The description adds no additional meaning beyond the schema, so baseline 3 applies.

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

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

States a specific verb (Get) and resource (league standings) with scope qualifier (for a specific league). Clear purpose, though it doesn't differentiate from siblings like analyze_team_performance or get_upcoming_matches, which are related sports-data 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?

No guidance on when to use this tool versus alternatives. The description doesn't mention when to prefer this over analyze_team_performance or other league-related tools, leaving the agent to guess.

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 behavioral burden. It says nothing about granularity/interval, response shape, whether 'days' caps are enforced, or rate limits, and omits the fact that the sibling get_historical_price_data may return the same underlying series.

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

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

A single short, front-loaded sentence with no filler or repetition. It is efficient, though its brevity borders on under-specification rather than true conciseness.

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

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

For a two-parameter tool with no annotations and no output schema, the description is too thin: it neither routes the agent away from overlapping price siblings nor explains the semantics of the required 'symbol' argument or what the chart data contains.

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

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

Schema coverage is only 50%: the 'days' parameter is documented in the schema, but 'symbol' has no description at all. The description says 'for a token' but never clarifies that 'symbol' is the token identifier or what format it takes, so it does not compensate for the coverage gap.

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

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

States a clear verb ('Get') and resource ('historical price chart data for a token'), so an agent knows the general operation. However, it fails to distinguish itself from the near-identical sibling get_historical_price_data (and get_fan_token_price, get_multiple_prices), leaving ambiguity about which price tool to pick.

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

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

No when-to-use guidance, no prerequisites, and no alternatives named despite several overlapping price siblings. The agent must infer entirely from the name that this is the charting variant rather than the raw historical data variant.

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 only implies a read operation via 'Get' but says nothing about authentication requirements, data sources, rate limits, or what the analysis returns. This is minimal transparency for a tool with zero annotation coverage.

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

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

The description is a single, front-loaded sentence with no wasted words, which is structurally sound. However, it is so terse that it underspecifies the tool's behavior and parameters, making it inadequately sized for the information an agent needs to invoke it correctly.

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 there are no annotations, no output schema, and the single parameter is undocumented, the description should do more to explain what 'market sentiment' means, what the token represents, and what the analysis returns. It leaves critical invocation details unaddressed, though the tool's low complexity (one parameter, no nested objects) limits the severity.

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

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

Schema description coverage is 0% and there is one required parameter ('token') with no description. The tool description does not mention the parameter at all, so it fails to compensate for the complete lack of schema documentation. The agent receives no semantic guidance on what 'token' should be.

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

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

The description states a verb and resource ('Get overall market sentiment analysis'), making the general purpose inferable. However, it largely restates the tool name, does not clarify the scope (which market or token), and fails to distinguish it from sibling tools like get_social_sentiment. This is a vague purpose rather than a specific one.

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

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

The description provides no guidance on when to use this tool, when not to use it, or what alternatives exist. It does not mention the required token parameter or any context that would help an agent choose this over get_social_sentiment. This falls under 'no guidance' (score 2).

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 behavioral burden. It conveys only that this is a read (implied by 'Get'); it says nothing about return shape/ordering, behavior on invalid symbols, pagination, or rate limits, which matters for a batched lookup.

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

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

A single front-loaded sentence with zero filler; the key distinction (multiple/batch) is placed immediately after the verb and resource.

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

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

With no output schema and no annotations, the description is thin for a batched query tool: it does not describe the return format (per-symbol mapping, ordering, or missing-symbol behavior). It is minimally sufficient 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 description coverage is 100%, so the single 'symbols' array parameter is already documented in the schema. The description adds no format details (e.g., symbol casing, max batch size), so the baseline 3 applies.

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

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

States a specific verb (Get) and resource (prices) plus scope (multiple fan tokens at once), which implicitly distinguishes it from the singular sibling get_fan_token_price. It stops short of naming the sibling directly, so the differentiation must be inferred.

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

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

The phrase 'at once' implies batching and thus when to prefer this over get_fan_token_price, but no explicit condition, prerequisite, or alternative is stated. Usage is only implied.

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

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

With no annotations, the description must carry the behavioral burden, and it does disclose one meaningful non-schema trait: the tool reads from a configured wallet and requires the PRIVATE_KEY env var, which implies credential-dependent behavior. It says nothing about read-only semantics, which chain/network is queried, or failure behavior when the key is absent.

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

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

A single sentence with the action front-loaded and the prerequisite appended as a compact parenthetical. Every clause earns its place with no filler.

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

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

With no annotations and no output schema, the description should ideally indicate the return shape (balance units, token vs. native currency) and default-network behavior. It is minimally adequate but leaves the agent guessing about the response format for a zero-arg tool.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline is 4. The parenthetical env requirement is context rather than a parameter, and it is appropriately placed.

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

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

States a specific verb ('Get') and resource ('balance of configured wallet'), and the qualifier 'configured wallet' implicitly distinguishes it from the sibling get_wallet_balance. It does not explicitly name that sibling or clarify how they differ, so it stops short of a 5.

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

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

There is no guidance on when to use this versus the nearby get_wallet_balance, nor any stated preconditions beyond the parenthetical env requirement. The agent must infer the distinction (configured/default wallet vs. an addressed wallet) from the qualifier 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?

No annotations, so the description carries the full behavioral burden. It only says the tool gets APY, without explaining whether data is live/on-chain, calculation source, permission needs, or result format. The schema's period default adds a little, but the description itself is thin.

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

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

Single front-loaded sentence with no filler. It is appropriately sized for a simple lookup and 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 low-complexity read tool with full schema coverage, the description is minimally viable but not complete: it doesn't answer what APY variant is returned, the data source, or how to interpret the result, and no output schema exists to cover return semantics.

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%; both parameters are documented in the schema, including the period's default and unit. The description adds no parameter semantics beyond the schema's own poolAddress and period descriptions, so baseline 3 applies.

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

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

States a specific verb ('Get') and resource ('APY for a KAYEN liquidity pool'). The pool type and protocol reference make it distinguishable from sibling price/balance/analytics tools, though it doesn't explicitly name an alternative.

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

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

No when-to-use guidance, no exclusions, no mention of alternatives. An agent must infer from the name that this is for APY queries only, with no indication of when another tool is preferable.

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 behavioral burden. 'From monitoring history' hints that this is a read over previously captured data rather than a live query, but there is no disclosure of ordering, whether results are capped by the monitoring buffer, or what happens when no monitoring session exists.

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 short sentence with no padding, so nothing is wasted, but the brevity comes at the cost of under-specification rather than being tight and complete.

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

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

For a tool with no annotations, no output schema, and an undocumented parameter, the description should at minimum state the monitoring prerequisite and what is returned. The one piece of genuinely useful context, that results come from a prior monitoring session, is only hinted at.

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

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

There is one parameter ('limit', default 10) with 0% schema description coverage, and the description says nothing about it. An agent cannot tell whether limit caps block count, is required, or how the default interacts with available history.

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

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

States a verb and resource ('Get recent blocks') with a scope qualifier ('from monitoring history'), which does distinguish it from get_blockchain_info at a high level. However, 'monitoring history' is never defined, and the description doesn't clarify how this differs from get_recent_logs or get_recent_pending_transactions, which follow the identical naming pattern.

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

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

No when-to-use guidance is given. Critically, the description implies a dependency on a monitoring session being active but never states that start_block_monitoring must be run first, nor does it name any alternative for raw block 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 carries the full behavioral burden. 'Get' implies a safe read, but it omits whether monitoring must be running, whether logs are paginated or bounded, and how far back 'recent' reaches — all material for a log-retrieval tool.

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

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

A single tight sentence with no filler and the key scope word ('recent') front-loaded. It is efficient, though the brevity is partly the cause of the missing guidance.

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

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

With no annotations, no output schema, and only partial parameter coverage, the description leaves out return shape, ordering, and the dependency on an active log monitor. For a tool whose usefulness hinges on monitoring state, 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 coverage is 67% and the description explains none of the three parameters. It does not clarify what 'recent' means relative to the limit default of 50, nor how address and filterId interact when combined.

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

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

The description states a specific verb ('Get') and resource ('recent contract logs from monitoring history'), which is clear enough to distinguish it from write operations like start_log_monitoring. However, it does not name a sibling or clarify scope boundaries (e.g., vs. get_recent_blocks or start_log_monitoring), so it stops short of 5.

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

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

There is no when-to-use guidance, no prerequisites, and no alternatives mentioned. The one indirect hint is the schema's filterId referencing start_log_monitoring, but the description itself says nothing about needing an active monitoring session.

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 but only says 'from monitoring' – it doesn't explain whether this queries a live monitor, requires an active monitoring session, or what 'recent' means (time window). No behavioral details about freshness, ordering, or prerequisites are given.

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, which is concise, but it is under-specified rather than efficiently informative. 'from monitoring' is vague filler that doesn't earn 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 tool with 2 parameters (one undocumented), no annotations, no output schema, and a confusing parameter description mismatch, the description is completely inadequate. It doesn't explain what 'recent' means, the monitoring dependency, or how to use the filters.

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 50%: 'limit' has no description, and 'minValueETH' says 'Filter by minimum CHZ value' which is confusing since the parameter name references ETH but the description says CHZ. The tool description adds no parameter meaning at all, leaving the 'limit' parameter and the ETH/CHZ discrepancy unexplained.

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

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

The description states a specific verb+resource ('Get recent pending transactions') but adds the vague qualifier 'from monitoring' which doesn't clarify scope or distinguish it from sibling tools like 'get_recent_logs' or 'get_recent_blocks'. It's understandable but lacks the sibling differentiation found in higher-scoring definitions.

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

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

There is no guidance on when to use this tool versus alternatives such as 'start_pending_tx_monitoring' or other transaction retrieval tools. No exclusions, prerequisites, 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?

No annotations are provided, so the description carries the full behavioral burden. It does not disclose what platforms are analyzed by default, whether this is a read-only operation, rate limits, or what form the sentiment output takes.

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

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

It is a single short sentence with no waste, but it is under-specified rather than concise in a helpful way.

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

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

With no annotations, no output schema, zero schema description coverage, and no usage guidance, the description is far too thin for an agent to invoke this tool confidently.

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

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

Schema description coverage is 0%, so the description must compensate but does not. It mentions 'token' implicitly but says nothing about the 'platforms' parameter, its default value, or valid platform values.

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

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

States a specific verb ('Analyze') and resource ('social media sentiment for a token'), so the basic purpose is clear. However, it provides no differentiation from closely related siblings like get_market_sentiment or track_social_momentum, leaving the agent to guess which one to call.

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

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

The description gives no guidance on when to use this tool versus alternatives such as get_market_sentiment or track_social_momentum. There are no prerequisites or exclusions stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only retrieval but omits authentication needs, ordering, pagination, rate limits, and whether any side effects occur.

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

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

A single front-loaded sentence with no wasted words. It is appropriately brief for a simple lookup, though the brevity leaves important gaps elsewhere.

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

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

With no output schema and no annotations, the description should clarify return shape and limit behavior. It omits both, so an agent cannot know what the result contains or how to control result size.

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

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

Schema description coverage is 0%, so the description must compensate. It only implies that symbol identifies a fan token and never explains the limit parameter, its default of 10, ordering, or what 'top' means.

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

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

States a specific verb and resource: 'Get top holders of a specific fan token'. This distinguishes it from generic balance or token-list tools, though it does not explicitly contrast with sibling tools such as analyze_holder_distribution.

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

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

Provides no when-to-use guidance, prerequisites, or alternatives. It does not explain when to choose this tool over related siblings like analyze_holder_distribution or compare_token_distributions.

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 the full behavioral burden. It implies a read-only data fetch, but does not disclose authentication requirements, rate limits, data freshness, caching, or the shape of the returned metrics. This is a significant gap for a tool with zero annotation coverage.

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

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

The description is a single, front-loaded sentence with no wasted words. It states the action and resource immediately, which is appropriate for a simple two-parameter data retrieval tool.

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

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

With no annotations, no output schema, and only a terse description, the definition is incomplete. An agent cannot tell what metrics are returned, how they are formatted, whether the data is live or historical, or what the 'days' parameter affects beyond the schema's 'Period in days' note.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema. The description adds no parameter-level detail beyond what the schema provides, so the baseline score of 3 applies.

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

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

The description states a specific verb ('Get') and a specific resource ('token velocity and turnover metrics') with a data source ('from The Graph'). It is clearer than a bare name, but it does not explicitly distinguish itself from the sibling 'calculate_token_velocity', leaving some ambiguity about the difference between getting versus calculating velocity metrics.

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

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

There is no guidance on when to use this tool versus alternatives such as calculate_token_velocity, query_fan_token_analytics, or other analytics tools. The only contextual hint is the data source, which is not enough to route the agent correctly.

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

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

With no annotations, the description carries the full behavioral burden, yet it only says 'get details.' It does not state that this is a read-only lookup, what happens when the hash is unknown (empty result vs error), whether it requires a live node connection, or any rate limits.

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

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

A single, front-loaded sentence with no filler. It is efficient, though slightly under-specified for its length rather than verbose.

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

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

The tool is simple (one required string parameter, no nested objects), which limits how much is needed. However, with no output schema, the description should clarify what 'details' actually contains (status, value, gas, logs, confirmations) or what an unknown hash yields; that gap keeps it at minimum viable.

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 txHash parameter, so the schema already explains the input. The description adds nothing beyond that, which is the expected baseline for a fully documented one-parameter tool.

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

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

The description states a specific verb and resource: retrieve details for one transaction, keyed by hash. It is clearly distinct from the bulk/list siblings such as get_recent_pending_transactions or get_recent_blocks, though it never names an alternative explicitly.

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

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

There is no guidance on when to reach for this tool versus get_blockchain_info, get_recent_logs, or the pending-transaction monitors. The agent must infer the single-transaction scope entirely from the name and description.

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

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

With no annotations, the description carries the full burden, yet it discloses nothing beyond the one-line purpose. It does not say whether this is a read-only lookup, how the day window is applied, whether results are ordered or capped, or what the response contains.

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

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

A single front-loaded sentence with no filler, which is appropriate sizing for a simple lookup tool. It is efficient, though its brevity is partly the source of the other gaps.

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

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

For a 2-parameter tool with no annotations, no output schema, and an undocumented 'days' parameter, the description is too thin. Nothing tells the agent what a result row is, how the default 7-day window behaves, or what happens when 'tokens' is omitted.

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

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

Schema coverage is only 50%: 'tokens' has a description ('Token symbols to check') but 'days' has none, leaving the time-window semantics undefined. The description's phrase 'for fan token teams' loosely hints at the tokens parameter but adds no meaning for the days parameter or how the two interact.

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

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

States a specific verb and resource ('Get upcoming matches') scoped to 'fan token teams', which distinguishes it from fixtures-adjacent siblings like get_league_standings and analyze_team_performance. It stops short of naming any sibling explicitly, so it is clear but not maximally differentiated.

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

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

No guidance on when to call this versus alternatives such as get_fan_token_price, get_league_standings, or analyze_team_performance, and no prerequisites or exclusions. The agent must infer the use case 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 carries the full burden and discloses almost nothing behavioral: not whether it is a read-only call, what metrics are returned, how a bad validatorAddress is handled, or whether results are cached. 'Detailed performance metrics' is left entirely undefined.

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

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

A single front-loaded sentence with zero padding or wasted words. It is efficient, though the brevity is partly under-specification rather than disciplined conciseness.

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

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

For a two-parameter read tool the description is minimally adequate, but with no annotations and no output schema it should at least indicate what 'performance metrics' comprises (uptime, missed blocks, APR) so an agent knows the response shape.

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

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

Schema description coverage is 100%, so both parameters (validatorAddress and days with default 30) are already documented in the schema. The description adds no extra meaning about the time window or address format, but the baseline of 3 applies when the schema does the work.

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

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

States a specific verb and resource: retrieving performance metrics for a validator. It is distinguishable from siblings like compare_validators and get_validator_risks, though it never names them explicitly to draw the boundary.

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 versus compare_validators (multi-validator) or get_validator_risks (risk-focused). The agent must infer the distinction from the tool names 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?

No annotations are provided, so the description carries the full behavioral burden, yet it only restates the operation. It does not disclose what risk factors are evaluated, whether the call is read-only, whether it requires any permissions, or what the response contains.

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

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

A single short, front-loaded sentence with no wasted words. It is efficient, though its brevity reflects under-specification rather than disciplined conciseness.

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

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

With no annotations and no output schema, the description is the only source of behavioral information, but it says nothing about what 'risks' means, what is returned, or how it relates to the many sibling validator tools. It is inadequate for a tool in a dense validator/staking tool cluster.

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 there is a single required parameter, so the schema already documents validatorAddress. The description adds only the word 'specific' and the staking context, which is minimal marginal value; 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 states a specific verb+resource ('Assess risks of staking with a specific validator'), so an agent can tell it evaluates validator staking risk. However, it does not differentiate from close siblings such as compare_validators, get_validator_performance, get_validator_performance, or monitor_slashing_events.

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

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

There is no when-to-use guidance, no exclusions, and no mention of alternatives. The agent must infer that this differs from compare_validators or get_validator_performance purely from the name, with no supporting text.

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

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

With no annotations, the description carries the full burden but only states what is retrieved. It does not disclose whether the operation is read-only, what permissions are required, address format expectations, rate limits, or any error behavior. 'Get' implies a read, but nothing beyond that is made explicit.

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

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

The description is a single, front-loaded sentence with no wasted words. It earns its place by naming the exact resource and the required target.

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

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

For a simple one-parameter read tool with no output schema, the description adequately states what is returned (CHZ and fan token balances) and the required input. It is nearly complete, though it could mention address format or whether balances are returned in a particular unit.

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

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

Schema description coverage is 100%, so the single 'address' parameter is already fully documented in the schema. The description adds no additional meaning or syntax beyond what the schema provides, meriting the baseline 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 states a specific verb ('Get'), resource ('CHZ and fan token balances'), and target ('for a wallet address'). It implicitly distinguishes itself from the sibling get_my_balance by requiring an address, but it never names or explicitly contrasts with that alternative.

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

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

There is no guidance on when to use this tool versus alternatives like get_my_balance or get_multiple_prices, nor any exclusions or prerequisites. Usage is only implied by the tool name and description.

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

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

No annotations are provided, so the description carries the full burden. It doesn't state whether this is read-only, what the status includes, or how it interacts with the monitoring tools. Only the bare verb 'Get' implies a read, with no permission or return-shape 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?

A single, efficient sentence with no preamble or filler. It is appropriately sized, though it is a bit terse and could front-load slightly more scope.

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 status tool with no annotations, no output schema, and no parameters, the description is under-specified. It doesn't explain what 'WebSocket connection and monitoring status' returns or what monitoring state it reflects, which is essential context for correct invocation in a crowded monitoring toolset.

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

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

The tool takes zero parameters, so the description needn't explain them. Baseline for 0 params is 4, and there's nothing the description omits on this dimension.

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

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

States a clear verb (Get) and resource (WebSocket connection and monitoring status). It's distinguishable from siblings like start_block_monitoring or stop_all_monitoring since it's a status read, though the description doesn't explicitly differentiate from those monitoring siblings.

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

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

No guidance on when to use this versus the monitoring start/stop tools or other status getters. The agent must infer 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: it does not say what counts as 'unusual', which statistical or heuristic method is applied, what data window is analyzed, or what the result looks like. For an analysis tool with zero structured behavioral coverage this is a significant gap.

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

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

It is a single, front-loaded sentence with no wasted words, so it is structurally clean. But the brevity stems from under-specification rather than efficiency, which limits the credit.

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

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

With two parameters, no annotations, and no output schema, the description is the only source of context and it is nearly empty. An agent cannot tell what data scope, method, or output it will get, so the definition is incomplete for correct invocation.

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

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

Schema description coverage is only 50%: 'threshold' documents itself as standard deviations, but the required 'token' parameter has no description at all. The description adds no meaning about either parameter (e.g., token format, what threshold values imply), so it fails to compensate for the coverage gap.

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

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

The description names a verb ('Identify') and a resource ('unusual trading patterns'), so the general intent is graspable. However, it does not differentiate this tool from several close siblings such as detect_whale_trades, detect_arbitrage, or calculate_token_velocity, and 'unusual' is never defined.

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

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

There is no when-to-use guidance, no prerequisites, and no indication of when an agent should prefer this over the many adjacent analysis tools. The agent must infer the use case entirely from the name.

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

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

With no annotations, the description carries the full behavioral burden. It only hints at 'real-time' behavior but omits critical details such as whether it starts a persistent subscription, blocks execution, returns a stream or handles, requires WebSocket connectivity, or how it is stopped (e.g., via stop_all_monitoring).

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

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

The description is a single, front-loaded sentence with zero wasted words. It communicates the core action immediately and efficiently.

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

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

For a real-time monitoring tool with no annotations and no output schema, the description is insufficient. It does not explain what the tool returns, whether it runs indefinitely, how to stop it, or how it interacts with the existing stop_all_monitoring sibling.

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

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

Schema description coverage is 100%, so the schema already fully documents both tokenAddress and tokenSymbol. The description adds no extra meaning beyond what the input schema provides, making the baseline score of 3 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 states a specific verb ('monitor') and a clear resource ('real-time transfers of a specific fan token'). It does not, however, differentiate this tool from other monitoring siblings such as start_log_monitoring or detect_whale_trades, leaving the agent to infer the distinction.

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

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

There is no explicit guidance on when to use this tool versus alternatives like start_block_monitoring, start_log_monitoring, or detect_whale_trades. The description provides only an implied use case, not when-not-to-use or prerequisite conditions.

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

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

No annotations are provided, so the description carries full burden. It doesn't disclose whether this is a read-only query or a live subscription, whether it requires auth, what the return shape looks like, or how 'recent' relates to the hours parameter. For a monitoring-named tool with zero annotation coverage, this is a significant gap.

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

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

A single efficient sentence with no waste, though it is perhaps too terse given the absence of behavioral context.

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, and a description that omits critical context: whether this is a live monitor (like its start_* siblings) or a historical query, and what fields the events contain. The name 'monitor' actively creates ambiguity that the description does not resolve.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema ('Look back period in hours', 'Filter by severity'). The description adds nothing beyond the schema, but full coverage justifies a baseline 3.

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

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

States a specific verb+resource ('Monitor slashing events') which is clear enough, but 'recent' is vague and the description doesn't distinguish this from validator-related siblings like get_validator_risks or compare_validators. An agent could reasonably confuse it with other monitoring tools in the set.

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 versus alternatives like get_validator_risks (which also concerns slashing risk) or the start_*_monitoring tools. The word 'monitor' also implies ongoing streaming, but no clarification is given about whether this is a one-shot query or a subscription.

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 mentions The Graph protocol but does not describe read-only behavior, authentication needs, rate limits, data freshness, or any other behavioral trait an agent would need.

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 with no filler and is front-loaded with the core action. Every part of the sentence is relevant, even if the content is thin overall.

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

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

With no output schema and no annotations, the description should explain what analytics are returned and give usage context. It does neither, leaving the agent unable to predict the return shape or when this tool is appropriate.

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

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

Schema description coverage is 100%, so both parameters (symbol and days) are already documented in the input schema. The description adds no additional meaning about parameter format, defaults, or constraints 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?

States a verb and resource ('Query detailed fan token analytics'), but 'analytics' is vague and does not distinguish this tool from many analytics-oriented siblings like get_market_sentiment, calculate_token_velocity, or get_fan_token_price. An agent cannot confidently tell what specific analytics this tool provides versus those alternatives.

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

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

Provides no guidance on when to use this tool versus the many sibling tools available. The description only mentions the data source ('via The Graph protocol') and gives no conditions, exclusions, or alternative 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?

With no annotations, the description carries the full behavioral burden, and it does disclose one genuinely useful, non-obvious fact: PRIVATE_KEY must be set in the environment. However, for an irreversible value-transfer operation it says nothing about irreversibility, gas cost, or which chain/network the send occurs on.

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?

Extremely short and front-loaded, with both clauses carrying information (the token scope and the env requirement). It is efficient rather than padded, though 'Send CHZ or fan tokens' is close to restating the name.

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

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

This is a financial mutation tool with no annotations and no output schema, so the description must cover behavior and safety. It omits irreversibility, gas/network context, whether a tx hash is returned, and any preconditions beyond the env variable, leaving real gaps for an agent about to move funds.

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

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

Schema description coverage is 100%, so all three parameters (to, token, amount) are already documented in the schema. The description adds no format or constraint detail beyond the schema (e.g. amount units, address format, valid token symbols), so the baseline 3 applies.

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

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

States a specific verb and resource ('Send CHZ or fan tokens'), so an agent knows this moves tokens rather than swaps or approves them. It does not explicitly distinguish itself from nearby siblings like swap_tokens or approve_token, keeping it short of a 5.

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

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

There is no when-to-use guidance, no prerequisites (e.g. balance, network, gas), and no routing to alternatives such as swap_tokens or approve_token. Usage can only be inferred from the tool name.

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

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

With no annotations, the description carries the full behavioral burden, yet it only says monitoring is 'real-time'. It omits whether this opens a persistent websocket/subscription, whether it can be run concurrently, how events are delivered, and whether a stop tool is required to end it — all critical for a stateful start-monitoring 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?

A single front-loaded sentence with zero filler; the action and target are clear immediately.

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

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

For a one-parameter start command with no output schema this is minimally adequate, but a tool with side effects in a suite containing stop_all_monitoring should at least hint at lifecycle behavior. It is serviceable but leaves notable 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?

The schema already documents storeHistory at 100% coverage ('Store recent blocks in memory'), so the description need not repeat it. It adds nothing about the default or memory implications, matching the baseline 3 for high-coverage schemas.

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

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

States a specific verb and resource ('Start real-time monitoring of new blocks') and implicitly distinguishes itself from start_log_monitoring and start_pending_tx_monitoring by naming the block resource. It does not explicitly name sibling tools or clarify the relationship to get_recent_blocks, so it stops short of a 5.

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

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

No guidance on when to start this versus polling get_recent_blocks, nor any mention of prerequisites or how monitoring is terminated (stop_all_monitoring). The agent must infer usage entirely from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says monitoring is real-time but omits authentication needs, duration, resource impact, how to stop monitoring, what storeHistory does, and any return or lifecycle 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 front-loaded sentence with no wasted words. Its brevity is efficient, though it contributes to gaps covered in other dimensions.

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 monitoring-start tool with no annotations, no output schema, and an undocumented boolean parameter, the description is too sparse. It omits lifecycle, stopping, and storage context that an agent would need to invoke 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?

The schema documents topics and address but leaves storeHistory completely undocumented, and the description adds no parameter meaning beyond 'contract events/logs'. With 67% schema coverage and one undocumented boolean, the definition does not adequately clarify parameter usage.

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

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

States a specific verb 'start monitoring' and resource 'contract events/logs' with the qualifier 'real-time'. However, it does not differentiate from sibling tools such as start_block_monitoring or start_pending_tx_monitoring, so an agent must infer the distinction from the resource name.

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

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

The description provides no when-to-use or when-not-to-use guidance and does not mention alternatives or prerequisites. Usage is only implied by the tool name and sibling 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?

No annotations are provided, so the description carries the full behavioral burden. It says only that monitoring starts, without explaining whether monitoring persists, how to stop it, what events are emitted, permissions required, or how results are retrieved.

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

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

The description is a single front-loaded sentence with no filler. It is structurally clean, though its brevity reflects under-specification rather than deliberate concision.

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

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

With no annotations, no output schema, and incomplete parameter documentation, the description is too thin for a monitoring tool. It omits how to stop monitoring, what the monitoring yields, and how the three parameters affect behavior.

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

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

Schema description coverage is only 33%: minValueETH is documented, but storeHistory and filterLargeTransactions have no descriptions. The tool description adds no parameter meaning, leaving two of three parameters undocumented for the agent.

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

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

The description gives a specific verb and resource: 'Start monitoring pending transactions in the mempool.' This distinguishes it from siblings like start_block_monitoring and start_log_monitoring, though it does not explicitly name or contrast those alternatives.

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

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

There is no when-to-use or when-not-to-use guidance. The agent is not told how this differs from get_recent_pending_transactions or other monitoring tools, nor when this tool should be selected over them.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does reveal the behavioral effect ('disconnect') beyond the name, but says nothing about idempotency, whether it errors when nothing is running, whether it affects only this session/client, or whether it is reversible.

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

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

A single front-loaded sentence with no filler, though it is terse enough that the 'disconnect' clause is the only elaboration an agent gets.

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

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

For a zero-parameter teardown tool with no output schema and no annotations, the description covers the essential action and side effect. The main missing piece is what state the caller is left in afterwards and whether the stop is global across all sessions.

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

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

The tool takes zero parameters, so there are no parameter semantics to explain; the baseline for a parameterless tool 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?

States a specific verb (Stop) with the resource (all WebSocket monitoring) and its side effect (disconnect), and the scope word 'all' distinguishes it from the sibling start_block_monitoring / start_log_monitoring / start_pending_tx_monitoring 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 — call this to tear down monitoring started by the start_* siblings — but there is no explicit when/when-not statement, no note on whether it must be called before re-subscribing, and no alternative named (e.g. get_websocket_status for inspection only).

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 but only offers '(DEX integration)' as a hint. It omits critical behavioral traits like whether it requires token approval, gas implications, irreversibility, or slippage handling for this financial mutation.

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 concise and front-loaded in a single sentence. However, it is under-specified for the tool's complexity, and the parenthetical '(DEX integration)' adds minimal value without structure.

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

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

Given a financial swap tool with four parameters, no output schema, and no annotations, the description is severely incomplete. It fails to explain token format, amount units, slippage behavior, return values, or any operational details needed by an 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 description coverage is 0%, and the description provides no information about any of the four parameters (fromToken, toToken, amount, slippage). It does not compensate for the missing schema annotations at all.

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

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

States a clear verb 'swap' and resource 'tokens', providing a specific action. However, it does not differentiate from sibling tools like find_best_swap_route or calculate_price_impact, leaving ambiguity about whether it executes the swap or just finds a route.

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 find_best_swap_route. The description provides no context, 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?

No annotations are provided, so the description carries the full behavioral burden. It does not state whether this is a read-only query or a subscription/monitoring operation (contrast the start_* monitoring siblings), nor does it disclose return format, polling behavior, or rate limits.

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

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

A single short sentence that front-loads the action and scope with zero filler. It is efficient, though its brevity is partly under-specification rather than disciplined concision.

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

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

There is no output schema, so the description should clarify what 'liquidity changes' returns (net inflows/outflows, reserve deltas, timestamps) and whether 'track' means a one-shot pull or ongoing monitoring. For a tool with no annotations and no output schema, this leaves the agent guessing.

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

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

Schema description coverage is 100%, with both poolAddress and the defaulted hours window documented in the schema itself. The description adds no syntax, format, or default-override guidance beyond what the schema already provides, so baseline 3 applies.

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

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

The description gives a specific verb (track) and resource (liquidity changes) scoped to KAYEN pools, which is more precise than a generic tracking tool. It does not, however, differentiate itself from sibling tracking tools such as track_whale_movements or track_social_momentum beyond the resource noun.

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

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

There is no guidance on when to use this tool versus alternatives like get_pool_apy, get_historical_price_data, or detect_arbitrage. No prerequisites, no mention of what a 'liquidity change' event constitutes, and no exclusions are stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It says 'track changes' but does not explain what data sources are used, whether the operation is read-only, how often data updates, or what the return format looks like.

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

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

The description is a single front-loaded sentence with no wasted words. It is appropriately sized for a short definition, even though it is underspecified.

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 tracking tool with two parameters, one required and undocumented, no output schema, and no annotations, the description is incomplete. It lacks key details about the token parameter, timeframe behavior, and how it relates to sibling analytics tools.

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

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

Schema description coverage is only 50%, and the required 'token' parameter has no description at all. The description does not add meaning beyond the schema, leaving the token parameter's purpose and the timeframe's effect unclear.

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

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

The description states a verb ('track') and a resource ('social media activity'), giving a general idea of the tool. However, it is vague about what changes are tracked and does not distinguish this tool from siblings like get_social_sentiment or get_influencer_activity.

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

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

The description provides no guidance on when to use this tool versus alternatives such as get_social_sentiment or get_influencer_activity. There is no mention of context, 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?

No annotations are provided, so the description carries the full behavioral burden. It names the underlying data source (The Graph), which is modestly useful, but says nothing about whether results are real-time or historical, latency, rate limits, or cost of the query. For a monitoring-style tool with zero annotation coverage this is a significant gap.

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

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

A single tight sentence with no filler and the core action front-loaded. It is efficient, though arguably under-specified rather than optimally 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?

With no annotations, no output schema, and no return-value or behavior description, an agent lacks what it needs to call this confidently. The description does not explain what a 'movement' record looks like or how the time window interacts with minAmount.

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 symbol, hours, and minAmount are already documented in the schema. The description adds no format, unit, or filtering nuance beyond the 'whale' interpretation of minAmount, so the baseline of 3 applies.

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

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

The description states a clear verb+resource ('Track large holder (whale) movements') and a data source ('via The Graph'), but it does not differentiate itself from close siblings such as detect_whale_trades, monitor_fan_token_transfers, or get_token_holders. An agent cannot tell from the text alone which of these overlapping tools it should pick.

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

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

There is no statement of when to use this tool, when not to, or which sibling to prefer for adjacent tasks like trade detection or transfer monitoring. The only implicit cue is the 'minAmount' concept, which is left for the caller to infer.

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