flarewatch

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

Even with readOnlyHint=true, the description adds valuable behavioral details beyond annotations: rows are returned in the supplied order with no re-ranking, Flare and Songbird rows expose different fields, and missing addresses return found=false with null fields. No contradiction with annotations.

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

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

Three tightly packed sentences: purpose and scope, ordering guarantee, and per-network/missing-address behavior. Every sentence adds information, and the main action is front-loaded.

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

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

For a read-only comparison tool with no output schema, the description covers what is needed: the selection criteria, the provider limit, the per-network returned fields, row ordering behavior, and the error representation for missing addresses. No critical calling context is missing.

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

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

Schema description coverage is 0%, so the description carries the burden. It explains that 'network' selects Flare or Songbird and that 'addresses' are provider addresses with a 10-item limit. It also adds missing-address behavior. The address pattern and requiredness are left to the schema, which is acceptable.

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

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

The description opens with a specific verb and resource: 'Side-by-side comparison of up to 10 FTSO providers on Flare or Songbird.' It clearly distinguishes this from sibling list tools like get_ftso_providers by emphasizing comparison and the 10-provider limit.

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

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

The intended use case is implied clearly: comparing specific FTSO providers side-by-side. However, it does not explicitly state when not to use it or name alternatives such as get_ftso_providers or get_ftso_provider_metrics, leaving the routing decision partially 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?

The description adds valuable behavioral specifics beyond the readOnlyHint and openWorldHint annotations: row order follows the supplied input, no re-ranking occurs, and missing NodeIDs yield found=false with null fields. This helps the agent predict output behavior without overclaiming.

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

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

Three focused sentences deliver the purpose, input expectation, output fields, and edge-case behavior without redundancy. The most important detail (up to 10 validators by NodeID) is front-loaded.

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

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

Given a single-parameter tool with no output schema, the description covers the key invocation and response semantics: input type, size limit, output row fields, ordering, and missing-ID behavior. Minor omissions like explicit error handling or wrapper format are acceptable at this complexity level.

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

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

With schema_description_coverage at 0%, the description compensates by explaining that the parameter identifies validators by NodeID, supports up to 10 entries, and defines behavior for missing IDs. It does not restate the schema pattern or min/max, but the added meaning is sufficient for correct invocation.

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'), resource ('Flare validators'), and identifier ('NodeID'), making the tool's purpose unmistakable. It also differentiates itself from sibling tools like get_flarewatch_validator and get_validator_score by emphasizing side-by-side comparison of up to 10 validators.

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

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

The description makes the usage context clear: use this tool when you need to compare multiple specific validators by NodeID. It does not explicitly name alternatives or exclusion conditions, but the intended scenario is evident from the resource and parameter 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?

The annotations already indicate read-only and open-world behavior, so the description does not need to restate safety. It adds valuable context beyond annotations by disclosing the data source ('hourly signed snapshot') and the availability semantics ('available=false when unavailable'), plus clarifying deterministic vs agentic recovery counts.

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

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

The description is a single dense sentence that front-loads the primary purpose and then packs in the metric list and caveats. It is efficient, though the phrase 'available=false when unavailable' is slightly tautological and several metric names could be more concise.

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

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

Given there is no output schema and no parameters, the description does a good job of enumerating what the agent should expect in the result. It covers the metric families and the availability edge case, making the tool callable without additional info. It does not define some internal terms like 'agent-owned surfaces', but this is a minor 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?

The tool has zero parameters and 100% schema coverage, so there are no parameter semantics to explain. The description focuses entirely on the output, which is appropriate for a parameterless read-only 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 uses a specific verb and resource ('Return the FlareWatch agent's capability surface') and itemizes the exact metrics returned, including playbook counts, autonomous fraction, drill correctness, defects caught, and recovery counts. This clearly distinguishes it from sibling tools like get_agent_status or get_recent_agent_actions even without naming 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 explicit guidance on when to use this tool versus any of the many sibling tools. The description implies its usage through its content, but it does not state conditions or alternatives, leaving the agent to infer that this is the right choice for capability-surface metrics.

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

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

Annotations already declare readOnlyHint=true, lowering the burden. The description adds meaningful behavior context: data comes from an hourly signed snapshot, recovery counts use a 30-day window, and deterministic vs agentic recovery are clarified. The final 'available=false when unavailable' line is somewhat tautological but still indicates a response 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 front-loaded with the main action, but the rest is one dense sentence with nested parentheticals and a long list of metrics. The final 'available=false when unavailable' sentence is redundant and does not earn its place, making the structure harder to parse than necessary.

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

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

For a parameterless, read-only tool with no output schema, the description is largely complete: it names the major metrics, the time window, and the data source. Minor ambiguity remains about the response shape and the exact semantics of 'available', but an agent can invoke the tool correctly without more information.

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

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

There are zero parameters and schema coverage is trivially 100%, so the baseline is 4. The description compensates by defining domain-specific terms and data partitions, though there are no actual parameters to document.

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

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

The description identifies a specific resource ('FlareWatch agent's reliability scorecard') and opens with a concrete verb ('Return'), then enumerates the metrics included. It does not explicitly differentiate itself from sibling tools like get_agent_capabilities or get_recent_agent_actions, so it stops short of maximum clarity.

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 mention of alternatives. An agent would have to infer from the name and metric list that this is the right tool for agent reliability status, but the description itself does not help choose between it and related agent tools.

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

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

Annotations already declare readOnlyHint and openWorldHint, and the description adds meaningful behavioral context beyond that: the data source is a 'live block sample plus explorer stats,' and nulls are returned when a leg is unavailable. This helps the agent interpret data quality and availability without contradicting the annotations.

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

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

The description is tight and efficiently structured: it opens with the core purpose, lists the returned data points, then states the source and a null-handling caveat. Every sentence earns its place and there is no filler.

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

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

For a zero-parameter read-only tool with no output schema, the description is complete: it names all observable return values, states the data source, and discloses unavailable-data behavior. An agent can decide to call it and correctly interpret the result without additional information.

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

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

The input schema has zero parameters and the description has no parameter documentation to add, so the baseline of 4 applies. The description instead usefully clarifies what the returned metrics mean, which is appropriate for a parameterless 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 clearly states a specific verb ('Return') and resource ('live Flare C-chain activity') and enumerates the exact metrics provided. It does not explicitly name a sibling to differentiate from, so it falls just short of a 5, especially given the presence of related status tools like get_network_status.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives such as get_network_status or get_network_economics. The intended use is implied by the 'live activity' wording, but there is no stated context or exclusions, so the agent must infer when this tool is the right choice.

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

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

Beyond the readOnlyHint annotation, the description discloses the data source ('on-chain reads valued at current prices') and the failure/edge-case behavior ('available=false / total null when the price-dependent TVL read is unavailable'). This is exactly the kind of behavioral context that helps an agent interpret unexpected responses.

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

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

Two succinct sentences. The first states the purpose and output fields; the second adds data source and an edge-case behavior. No filler or repetition of annotation data.

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 no-parameter, read-only tool, the description covers the output breakdown, units, data source, and unavailability behavior. Even without an output schema, an agent has enough to call this tool and interpret its result.

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

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

The tool has zero parameters and the schema coverage is 100%, so parameter explanation is unnecessary. The description still adds value by previewing the result shape and the condition under which the total is null, giving the agent context beyond the empty schema.

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

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

The description opens with a specific verb and resource: 'Return total value locked (USD) across the Flare DeFi ecosystem with a per-protocol breakdown.' It names the exact output fields (protocol name, TVL, token count) and distinguishes this from price or validator-related sibling tools.

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

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

The description makes clear this is the tool for DeFi TVL inquiries by stating the exact metric and scope. It does not explicitly name alternatives or exclusions, but no sibling tool covers the same deliverable, so the usage context is clear.

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

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

Annotations already mark the operation read-only and open-world, and the description adds meaningful behavioral detail: the data source is on-chain totalSupply reads priced at current values, and available=false is returned when the read fails or no assets are minted. This helps the agent interpret unexpected results, exceeding the annotation baseline.

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

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

The description is compact and front-loaded: the main purpose appears in the first clause, followed by a field list, source methodology, and failure behavior. Every sentence carries distinct information and there is no redundancy.

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

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

With no output schema and no parameters, the description fulfills the explanatory burden entirely. It specifies all returned fields, the aggregation, the valuation method, and the available=false failure case, leaving no missing information an agent needs to invoke or interpret the 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 has zero parameters, so no parameter documentation burden exists. The schema and description agree completely, and the description's explanation of the computed TVL formula compensates for the lack of input context.

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

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

The description opens with a specific verb and resource: 'Return FAssets status on Flare.' It then enumerates the exact output fields (symbol, underlying asset, minted amount, USD TVL, total_tvl_usd) and gives an example asset (FXRP), making the tool's purpose unmistakable and distinct from all sibling tools, which address validators, FTSO, agents, and portfolios.

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 clearly identifies the tool as the FAssets status endpoint for Flare, giving an agent enough context to select it when FAsset metrics are needed. It does not explicitly state when not to use it or name alternatives, but no sibling appears to cover FAssets, so exclusions are less necessary.

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

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

Annotations already indicate readOnlyHint and openWorldHint. The description adds meaningful behavioral context beyond these: it explains that each asset may use a different source (ftso oracle or coingecko fallback) and that degraded=true only triggers on a whole upstream failure, not on per-asset fallback or missing fx rates. It also clarifies the fx rate calculation. This goes beyond the basic read-only hint and is valuable.

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

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

The description is compact and front-loaded with the core purpose. It packs essential nuances (source variation, degraded flag semantics, fx rate formula) into three sentences without unnecessary verbosity. Every sentence contributes information an agent needs to interpret results 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?

For a tool with one optional parameter and no output schema, the description covers the key aspects an agent needs: what prices are returned, that sources may vary per asset, when degraded is set, and how fx rates work. It could be more explicit about the response structure, but given the low complexity, it is largely complete for correct invocation and interpretation.

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 single parameter 'currencies' is well-defined in the schema with enums and a default list, making its semantics clear without description support. The description does not explicitly explain the parameter, but it mentions the major fiats which map to the enum values. Given the parameter is optional and self-explanatory, the description adds little beyond schema, but does not leave gaps.

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

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

The description clearly states the tool retrieves latest prices for FLR, SGB, and XRP in USD and major fiats. It names the exact resources and assets, and is distinguishable from sibling tools like get_ftso_providers which focus on providers rather than prices.

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

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

The description implies the tool is used when you need current prices for these specific assets, but it does not explicitly state when to use it versus alternatives or provide any exclusions. There is no mention of alternative tools or conditions under which it should not be used, leaving some inference to 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?

Annotations already declare readOnlyHint and openWorldHint, so safety is covered. The description adds useful behavioral context: 'Pure on-chain + computed data; no editorial ranking' signals the absence of editorial bias, and 'limit caps at 100' discloses a hard ceiling on results. It does not elaborate on response shape, but that is a minor gap for a simple read-only list.

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

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

Four short, dense sentences front-load the core purpose and then add sorting, data provenance, and limit behavior. Every sentence contributes distinct, useful information with no redundancy or vague filler.

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

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

For a read-only list tool with only two optional parameters and no output schema, the description is nearly complete: it names the returned data fields, sorting options, defaults, data source, and cap. It lacks explicit response-shape/pagination details, but those are not essential given the simple nature of the operation and the presence of a 100-item cap.

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

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

Schema description coverage is 0%, so the description must compensate. It explains that sort_by accepts score, stake, or apy and that score is the default, and it mentions the limit cap of 100. It does not mention the default limit of 25, but that default is present in the schema, so the description covers the essential param meanings.

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: 'List Flare P-Chain validators' with a concrete set of returned attributes (FlareWatch composite Score, stake, fee, uptime, capacity). Also clarifies it is plural/all validators, which distinguishes it from singular or comparison siblings like get_flarewatch_validator and compare_validators.

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

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

Provides clear context: data is pure on-chain + computed, no editorial ranking, with sorting defaults and a limit cap. It does not explicitly name alternatives or state when not to use this tool, but the context is enough for an agent to decide it is for list-style validator data rather than comparisons or single-validator details.

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

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

The annotations already declare readOnlyHint=true, and the description adds valuable behavioral context: data is sourced directly from on-chain contracts and reflects live stats. It also discloses the unconfigured edge case via configured=false, which is useful behavior beyond the schema and annotations.

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

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

Two tight sentences deliver the full scope, the data source, and the unconfigured state indicator with no filler. The most important information is front-loaded.

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

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

For a no-parameter, read-only tool, the description fully equips an agent: it names the returned data fields, identifies the on-chain source, and explains the configured=false caveat. No output schema is present, but the listed metrics are enough to understand the response 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?

The tool has zero parameters, so parameter semantics are essentially not applicable. The baseline of 4 applies because there is nothing about parameters that the description needs to clarify.

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

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

The description opens with a specific verb ('Return'), a precise resource ('FlareWatch's Songbird FTSO entity'), and a concrete list of live on-chain stats. The specificity clearly separates this tool from siblings like get_flarewatch_validator or get_ftso_provider_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?

The intended use is clear from context: call this when you need FlareWatch's SGB FTSO entity vote power, balance, fee, or reward rate. It does not explicitly name alternatives or provide when-not-to-use conditions, but the scope is unambiguous enough to route a correctly described request.

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

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

The description adds useful behavioral context beyond the readOnlyHint/openWorldHint annotations, especially the disclosure that is_live=false indicates a 'cold-load fallback (RPC down or no match yet)'. It also clarifies the fairness of the scoring algorithm, which helps an agent interpret the data correctly.

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

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

Three sentences with no filler. The main purpose is front-loaded, followed by the return shape and then a critical edge-case flag. Every sentence earns its place.

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

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

With no input parameters, read-only annotations, and no output schema, the description sufficiently equips an agent to call the tool correctly. It names the key returned fields and explains the one non-obvious behavioral case (is_live=false).

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

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

There are zero parameters, so the schema carries no burden. The baseline for zero-parameter tools is 4, and the description provides enough context about what the returned rows contain without needing to explain parameter semantics.

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: 'Return FlareWatch's own Flare P-Chain validator stats'. It also distinguishes this tool from generic validator tools by noting the scoring algorithm is the same as every other validator with 'no promotional weighting'.

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

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

The intended use is implied through the subject matter — you call this to get FlareWatch-operated node stats — but no explicit when-to-use or when-not-to-use guidance is given, nor are alternative tools like get_flare_validators or get_validator_score named.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds valuable behavioral context: it reveals the output includes a 'found=false' case when the provider isn't in the tracked window, and specifies that results are newest-first. This goes beyond the annotations, though it doesn't detail the exact structure of each epoch entry.

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

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

Two sentences with zero filler. The first sentence front-loads the core purpose and scope; the second adds usage guidance and input validation. Every clause earns its place.

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

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

For a simple read-only tool with two parameters and no output schema, the description is complete. It covers purpose, usage, expected output traits (trend, ordering, found=false), and prerequisites. An agent can confidently select and invoke this tool without additional clarification.

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

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

Schema description coverage is 0%, so the description must compensate. It explains that 'address must be a 0x EVM address' (matching the schema pattern) and that the tool returns 'up to 30, newest first' epochs, implicitly defining the 'limit' parameter's effect. It adds semantic meaning (trend, ordering) beyond the bare schema, though it doesn't explicitly name the 'limit' parameter.

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

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

The description states a specific verb ('Return'), a specific resource ('per-epoch reward-rate and composite-score trend'), and a clear scope ('one Flare FTSO provider', 'most recent tracked reward epochs'). It explicitly names the sibling tool it complements (get_ftso_provider_metrics), making the purpose unambiguous and distinct.

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

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

It explicitly instructs when to use this tool versus the alternative: 'Use this for performance trend over time; use get_ftso_provider_metrics for the current snapshot.' It also states the required address format, eliminating ambiguity about input prerequisites.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, and the description adds meaningful return-content context: fee, reward rate, uptime, vote power, delegator count, Flare-specific score, and rank/percentile details. It also clarifies the denominator for rankings ('provider_count is the denominator'), providing behavior beyond the structured annotations.

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

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

The description is a single front-loaded sentence that begins with the action and resource before listing specifics. It is dense but not bloated; the parenthetical about the denominator is important and earns its place. Slightly long due to the metric enumeration, but no word is wasted.

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

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

With no output schema, the description compensates by enumerating the returned metrics and clarifying rank/percentile semantics. It also provides the needed address-format constraint. It does not cover edge cases like availability of FlareWatch Score on Songbird, but the parenthetical '(Flare)' alerts the agent to that distinction.

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

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

Schema description coverage is 0%, so the description carries the burden. It explains that 'address' is a lowercase 0x EVM address and that the provider is 'on Flare or Songbird', which effectively defines the network parameter. It could have explicitly named the network values, but the schema pattern and plain-language context make the semantics clear enough.

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 ('Return'), resource ('detailed metrics for one FTSO data provider'), and scope ('on Flare or Songbird'), with an explicit list of returned metrics. The singular 'one provider' and emphasis on rank/percentile distinguish it from siblings like get_ftso_providers and compare_ftso_providers.

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 clearly implies use for a single provider's detailed metrics, but it does not explicitly state when to prefer this tool over siblings such as get_ftso_provider_history or compare_ftso_providers. No exclusions or alternative conditions are provided, leaving the agent to infer the intended use case.

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

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

Annotations declare readOnlyHint=true and openWorldHint=true, and the description adds value beyond these by explaining network-specific return fields and the default sort order (score for FLR, vote power for SGB). It also notes that SGB lacks a score 'by design,' which is a behavioral nuance not in the annotations. No contradiction with the read-only hint.

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 three sentences with no redundancy. It front-loads the primary action and resource, then adds network-specific details, default sort, and the limit cap. Every sentence earns its place, and the information is well structured.

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

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

For a simple read-only list tool with only two parameters and no output schema, the description covers the key aspects: what it lists, per-network field differences, default sort, and the limit constraint. It does not delve into what a 'score' means or error handling, but those are likely out of scope for a basic list operation. The mention of return fields provides sufficient context for an agent to 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 0%, so the description must compensate. However, it only mentions 'limit caps at 100' (which is already the maximum in the schema) and implies the network parameter through the phrase 'on Flare or Songbird.' It does not explain that limit controls the number of results or that network selects the chain, beyond what the schema's type/pattern already imply. This is insufficient given zero coverage.

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

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

The description opens with a specific verb and resource: 'List FTSO data providers on Flare or Songbird.' It clearly distinguishes from sibling tools like compare_ftso_providers (comparison) and get_ftso_provider_history/metrics (history/metrics) by focusing on the listing itself. The network-specific differences are also articulated, making the scope precise.

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

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

The description provides clear context on what the tool returns for each network (Flare has Composite Score, Songbird has vote power/fee/last-epoch reward rate), which implicitly guides when to use it. It does not explicitly name alternatives or state when not to use it, but the context is sufficient for selecting this tool over siblings like compare_ftso_providers.

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

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

Annotations already mark readOnlyHint and openWorldHint, so the description adds meaningful behavioral context by disclosing the wallet:read OAuth requirement and the null-return behavior for FLR-side reward streams. It goes beyond the structured annotations without contradicting them.

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

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

Three sentences, all of which earn their place: the core return value, the current network coverage limitation, and the authentication requirement. The most important information is front-loaded.

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

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

With no input parameters and no output schema, the description supplies sufficient context for selection and invocation: what is returned, which networks/reward streams are included now, what returns null, and what auth scope is needed. An agent can decide correctly.

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

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

The tool has zero parameters and the schema coverage is 100%, so there is no parameter documentation burden on the description. The baseline of 4 applies because there are no parameters to explain.

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: 'Return claimable rewards across networks for the calling wallet.' It also clearly scopes current behavior to SGB FTSO claimable and explains that FLR-side streams return null, which distinguishes it from the other get_my_* sibling tools.

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

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

Provides clear context about when FLR-side data is unavailable and requires OAuth scope wallet:read as a prerequisite. It does not explicitly name sibling alternatives, but the limitation 'return null until then' effectively tells an agent when not to expect FTSO/MIRROR/FlareDrop/validation rewards.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds valuable behavioral context beyond annotations: it states the OAuth requirement and that no input argument accepts a wallet address, which clarifies the tool's security and tenancy boundaries. These additions are consistent with the annotations and enhance the agent's understanding.

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 three concise sentences with no redundancy. The primary purpose is front-loaded, followed by auth requirements and scope clarification. Every sentence carries essential information without waste.

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

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

For a simple read-only tool with no parameters and no output schema, the description covers the essential aspects: what it returns, the required OAuth scope, and the tenancy isolation. It does not detail the output structure, but given the tool's simplicity and the presence of sibling tools with similar patterns, this is an acceptable 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?

The tool has zero parameters, and the input schema is empty. The description explicitly notes that no wallet address argument is accepted because the wallet comes from the OAuth token, which clarifies the absence of parameters. With 100% schema coverage and a clear explanation of why there are no inputs, this 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 ('Return') and a precise resource ('the calling wallet's WFLR FTSO delegations and P-chain validator delegations'), which clearly distinguishes it from sibling get_my_* tools like get_my_claimable or get_my_rewards_history. The scope is unambiguous.

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

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

The description provides clear context: it requires OAuth scope wallet:read and clarifies that the wallet is resolved from the token, not an address argument (cross-tenancy isolation). This implies usage is limited to the calling wallet, effectively excluding use for other wallets, but it does not explicitly name alternative tools or say 'use this when...'.

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

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

Annotations already declare readOnlyHint=true, and the description adds meaningful behavioral context: it reports native and wrapped balances separately, wrapped balances roll into USD values and the total, and OAuth scope wallet:read is required. This goes beyond the structured annotations without contradicting them.

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 three concise sentences with no filler. The core purpose is front-loaded, followed by relevant token-rollup behavior and the auth requirement.

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

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

For a parameterless read-only tool with no output schema, the description fully covers what is returned, how wrapped balances are treated, and what authentication is needed. Nothing essential is missing for an agent to select and 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 tool has zero parameters, so the baseline is 4. The description appropriately focuses on authentication scope and return semantics rather than parameter details, since no parameters exist.

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

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

The description uses a specific verb ('Return') with a clearly defined resource: the calling wallet's FLR and SGB balances and their USD valuations. It further distinguishes itself from related 'my' tools by describing the portfolio scope and the native/wrapped breakdown.

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

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

It clearly states that this tool operates on the calling wallet's balances and requires the wallet:read OAuth scope, giving an agent a clear context for when to use it. It does not explicitly name sibling exclusions, but the unique resource makes the intended use obvious.

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

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

Annotations already include readOnlyHint=true, and the description reinforces with 'Read-only on-chain query.' It adds behavioral context: requires OAuth scope, mentions burn mechanism and days until burn. No contradiction with annotations.

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

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

Three sentences, front-loaded with the core purpose, then prerequisites and exclusions. No fluff; each sentence adds value.

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

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

For a zero-parameter read-only query, the description covers purpose, prerequisites, output fields, and scope limitations. The 'see notes' reference is slightly ambiguous but not critical. Complete enough for selection and 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?

No parameters exist (0 params), so baseline is 4. The description doesn't need to explain parameters; it correctly focuses on output.

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 (return) and resource (calling wallet's cumulative staking/VRM reward state) with detailed fields. Clearly distinguishes itself from siblings by noting it does not include a full per-epoch timeline, implying 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?

Provides a prerequisite (OAuth scope wallet:read) and notes it is read-only, but does not explicitly name an alternative tool for per-epoch timeline. The exclusion is mentioned but vague ('see notes'), so guidance is partial.

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

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

Annotations declare readOnlyHint=true and openWorldHint=true, which the description aligns with by saying 'Return'. It adds critical behavioral context beyond annotations: the 'Phase 3 ships the shape; full record assembly lands in a follow-on phase' limitation, and the requirement for OAuth scope personal:read. This is honest about incomplete output and access prerequisites.

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 main purpose is front-loaded in the first sentence. The subsequent disclaimers and phase note each add meaningful context, though 'NOT professional advice' and 'consult a CPA' are somewhat redundant. Overall it is efficient without being bloated.

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

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

For a single-parameter read tool with no output schema, the description covers the key elements: what data is returned, which wallet it applies to, the year parameter, auth requirements, and the current phase limitation. It does not detail the response format, but none is expected given no output schema; the disclosure of the phased implementation makes it sufficiently complete.

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

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

Schema description coverage is 0%, so the description must clarify the sole parameter. It says 'for a given year,' which identifies year as the tax-year filter. The schema supplies the valid range (2020-2099) and required status, so the parameter semantics are sufficiently compensated for such a simple case.

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 directly states the tool returns structured tax line items (FTSO/MIRROR claims, FlareDrop, validation rewards) for the calling wallet and a given year, using a specific verb and resource. It clearly distinguishes this tax-specific tool from sibling wallet tools like get_my_rewards_history and get_my_claimable. The 'NOT a tax calculator' line further clarifies scope.

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

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

Clear context is provided: the tool is for the calling wallet's tax line items for a specific year, with a required OAuth scope. The description explicitly excludes using it as a tax calculator or professional advice. However, it does not name alternative tools for related queries (e.g., get_my_rewards_history), leaving some routing 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?

The description discloses that the data comes from on-chain reads plus a live block sample, explicitly notes that the burn rate is an estimate, and specifies a null-not-zero failure policy for failed reads. This meaningfully extends the readOnlyHint and openWorldHint annotations by explaining data provenance and error behavior.

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

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

The description front-loads the action and resource, then gives a dense but informative metric list followed by two concise clarifying sentences. It is slightly list-heavy, but every element adds value and there is no redundancy.

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

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

For a zero-parameter, read-only tool with no output schema, the description fully covers scope, data sources, estimation behavior, and null handling. An agent has everything it needs to decide when to call it and how to 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?

The tool has zero parameters and the input schema fully documents this, so the description has no parameter details to add. The baseline of 4 applies because there is nothing left undocumented.

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

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

The description starts with the specific verb 'Return' and names the exact resource, Flare's monetary metrics, followed by a detailed list of included metrics. This makes the tool's purpose unambiguous and clearly distinguishes it from sibling tools like get_defi_tvl or get_network_status, which cover different domains.

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

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

The description provides clear context for when the tool applies (supply, staking, inflation, burn queries) but does not explicitly state when to use it over alternatives or list exclusions. Usage is implied through the specific metric list rather than explicitly guided.

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

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

The description adds behavioral context beyond the readOnlyHint and openWorldHint annotations by disclosing the data source ('FlareSystemsManager on-chain reads') and the failure mode ('Nulls returned when on-chain read fails'). This is valuable, though it does not mention caching, latency, or whether reads are live versus batched.

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

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

The description is compact and front-loaded. The first sentence states the purpose and return fields, and the second and third sentences add source and failure behavior. Every sentence 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?

Given the tool's low complexity, one optional parameter, and read-only annotations, the description is nearly complete. It covers the return fields, default network, source, and null-failure behavior. The only minor gap is that it does not specify units or types for fields like 'seconds remain' or 'how far into the epoch,' but the absence of an output schema makes this acceptable.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It does mention 'Flare (default) or Songbird,' which reinforces the network parameter's allowed values. However, this largely duplicates the schema's default and pattern, and no extra semantics such as validation behavior or edge-case handling are provided.

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

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

The description uses a specific verb ('Return') and identifies a precise resource: 'FTSO reward-epoch state' for Flare or Songbird. It lists the exact fields returned, making its purpose unmistakable and clearly distinct from sibling getter tools like get_network_economics or get_chain_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 implies when to use the tool: when the agent needs current FTSO reward-epoch state such as epoch ID, start time, progress, and seconds remaining. However, it does not explicitly state when not to use it or name alternative tools for related but different network status queries.

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

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

Annotations already provide readOnlyHint=true and openWorldHint=true, and the description consistently aligns with those. It adds useful behavioral context beyond annotations: compute units never expire, the response includes deposit address/credit rate/balance URL, and provisioned=false indicates deposit rails are closed. This is meaningful supplemental information.

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

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

The description is compact and well-structured: it states the core purpose, lists key output contents, and adds an essential caveat about provisioned=false. Every sentence earns its place without redundancy.

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

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

For a zero-parameter, read-only tool with no output schema, the description provides all needed operational context: what is returned, the meaning of the key status field, and the payment flow. An agent can confidently invoke this tool and interpret the response correctly.

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

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

The tool has zero input parameters, so schema coverage is trivially 100% and there is no parameter meaning to clarify. The description correctly focuses on output semantics instead. A baseline of 4 is appropriate for a zero-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 ('Return'), a clear resource ('payment options for paid FlareWatch capacity'), and key mechanics (deposit USDT0, credit compute units). This is immediately distinguishable from sibling get_* tools and leaves no ambiguity about what the tool does.

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 clear context for when this tool applies: when payment options for paid FlareWatch capacity are needed. It also clarifies the meaning of provisioned=false, which helps agents know the current deposit availability. It does not explicitly name alternatives or state when not to use it, but none are needed given the tool's unique scope.

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

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

Annotations only declare readOnlyHint and openWorldHint; the description adds substantial non-redundant behavioral detail: the feed comes from an hourly signed snapshot, is verifiable via chain_verify_url, available=false when the snapshot is unavailable, and validator entries are proposals only. This goes well beyond the structured hints and helps an agent interpret results safely.

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

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

Three tight sentences with no filler; each sentence adds an essential fact. The main output fields are front-loaded, followed by the validator caveat and source/availability details, so an agent gets the key information 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?

The description covers the response fields, data source, verifiability, availability behavior, and validator semantics, which is strong for a read-only tool. However, there is no output schema and no parameter documentation, leaving since_ts_minute ambiguous and slightly reducing overall completeness.

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

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

Schema description coverage is 0%, and the description does not explain either parameter. 'limit' is partially inferable from its name and schema constraints, but 'since_ts_minute' is completely opaque — an agent cannot know what format or timezone to provide. The description provides zero compensation for the missing schema descriptions.

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

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

The description names a specific verb ('Return'), a specific resource ('FlareWatch agent's recent action feed'), and enumerates the feed's contents: surface, action kind, outcome, and detect-to-remediate latency. It also adds a distinguishing caveat that validator-surface entries are proposals only, so it is clearly distinct from sibling tools like get_agent_status or get_agent_capabilities.

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

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

The intended use is implied by the description ('recent action feed') and clarified with agent-recovery context, but it does not explicitly state when to choose this tool over siblings, nor when not to use it. It gives useful context but no direct alternatives or exclusions.

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

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

Annotations already establish this is a read-only operation. The description adds valuable response-level detail: per-dimension raw score, max, detail string, an illustrative outage example, and a methodology link. This goes beyond the annotations without contradicting them.

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

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

Three tight sentences with no filler. The core outcome is front-loaded, and the example detail string makes the abstract breakdown concrete without adding unnecessary length.

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

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

For a one-parameter read tool with no output schema, the description adequately covers what the agent should expect: composite score, dimension-level details, and methodology link. It does not mention handling of invalid or unknown NodeIDs, but that is a minor gap given the simplicity of the call.

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

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

The sole parameter node_id is given meaning as the validator's NodeID, but the description adds little beyond the schema's property name and pattern. With 0% schema-description coverage, this is minimal compensation, though the single obvious parameter limits the risk.

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

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

States the specific verb 'Return' and the exact resource: the FlareWatch composite Score plus a full per-dimension breakdown for one Flare validator. This is clearly distinguishable from sibling listing tools by its focus on a single validator score.

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?

Makes clear this is for one Flare validator addressed by NodeID, which is actionable context. However, it does not explicitly name alternative tools or state when not to use them, so it stops short of full routing guidance.

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

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

Annotations already carry readOnlyHint and openWorldHint, so no safety disclosure is needed, and the description does not contradict them. It adds output context (risk tier definitions and the feed-symbol vs live-price distinction) but does not disclose behaviors like how limit affects results, data freshness, 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?

Three short sentences front-load the core action and resource, use examples to disambiguate symbols, and end with the routing note. Every sentence earns its place and there is no boilerplate.

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

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

With no output schema, the description covers what is returned (feed symbols with risk tiers), the optional filter, and the most relevant sibling alternative. It is less explicit about the limit parameter's behavior, but that is a minor gap for a simple read-only list.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It clarifies the risk filter and explains the enum values (low/medium/high/new = volatility + liquidity), but limit is never described beyond its name/default in the schema, leaving a partial compensation 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 an explicit verb ('List'), a specific resource (FTSO block-latency price feeds), and the returned attribute (Flare's published risk tier). The examples and final sentence distinguish this from get_flare_prices, so an agent can separate it from 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?

Tells the agent these are the symbols the on-chain oracle prices and explicitly directs live FLR/SGB/XRP values to get_flare_prices. This gives a clear when-to-use/alternative signal without requiring schema inspection.

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

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

Annotations already mark this as read-only and open-world, and the description adds meaningful behavioral context: it is a projection rather than a guarantee, it annualizes the latest realized per-epoch rate using ~104.29 epochs/year, and it can return found=false for uncached providers. These details go well beyond the annotations without contradicting them.

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

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

Four dense sentences, each earning its place: what it does, how it annualizes, what it returns, and its caveats. The most defining constraints are front-loaded, and there is no filler.

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

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

Given there is no output schema, the description appropriately explains the return values (APR, annual/monthly reward in FLR) and the found=false fallback. It also covers limitations and scope. Minor gaps remain around precise input-unit clarification and provider_address validation semantics, but overall it is sufficient 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 0%, so the description must compensate. It conveys the general semantics of 'an amount' and a 'provider' with a default of FlareWatch, but it doesn't explicitly tie these to the parameter names amount_flr and provider_address, nor does it clearly state the input unit for amount_flr or the provider address format. This is adequate but leaves the agent to infer some parameter details.

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

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

The description uses a specific verb ('Estimate') and resource ('annual WFLR FTSO-delegation rewards'), and immediately distinguishes this from actual reward history and P-chain staking. It clearly positions the tool as a projection, which separates it from the sibling read/history tools.

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

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

The description gives clear context: this is for simulating/a projecting FTSO delegation rewards, not P-chain staking, and it notes what happens when the provider isn't cached (found=false). However, it doesn't explicitly name alternative tools for actual rewards or historical metrics, leaving some routing 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?

The description discloses the HMAC verification mechanism and the success condition ('Returns valid=true when the HMAC matches'), adding behavioral detail beyond the readOnlyHint/openWorldHint annotations. It does not describe failure behavior, but the core behavior is transparent.

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

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

Two sentences front-load the purpose, then give precise usage instructions and the return condition. Every clause adds value, with no repetition of schema data or annotation 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?

The description covers what to pass and what result to expect, which is adequate given no output schema. It could explicitly state the behavior when the signature does not match, but for a simple verification tool the provided information is nearly complete.

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

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

The schema provides no descriptions and payload is an untyped empty schema, yet the description fully specifies the semantics: payload must be the envelope without verification_signature and signature is the received signature. This fully compensates for the 0% schema description coverage.

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

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

The description states a specific verb ('Verify') and resource ('previously-served FlareWatch MCP response') and clearly differentiates this tool from sibling data-retrieval tools. It establishes that this tool authenticates the origin of a response rather than fetching or comparing data.

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

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

It provides a concrete use case ('cross-AI citation verification') and explains the exact input format required. It does not explicitly list when-not-to-use or alternative tools, but since no sibling performs verification, the contextual guidance is sufficient.

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