Avalanche AVAX MCP

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It mentions returning structured fields and filtering, but does not include details about pagination (despite the limit parameter), default behavior, ordering, or error conditions. The read-only nature is implied but not explicitly stated.

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

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

The description is a single, well-structured sentence that states the core function and optional filters. It is concise, front-loaded, and free of unnecessary words, earning a top score for 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?

For a simple list tool, the description covers the core function and main filters. However, there is no output schema, and the description does not elaborate on the 'structured fields' or mention the limit parameter and pagination behavior. This leaves notable gaps in 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?

The input schema has 100% description coverage for all three parameters, including enums for status and track. The description lists status and track values in prose, which is redundant with the schema, and adds no new information about the limit parameter or defaults. This meets the baseline expected when the schema is comprehensive.

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

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

The description uses the specific verb 'List' and identifies the resource 'Avalanche Community Proposals' with optional filters, making its purpose clear. It names the object and action unambiguously, though it does not explicitly distinguish from sibling tools like acp_lookup or info_acps.

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

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

The description implies usage for listing ACPs, optionally filtered by status or track, and lists filter values. It does not state when to prefer this tool over alternatives or provide exclusions, so guidance is implicit rather than explicit.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It reveals that a number triggers a structured record with specific fields, which is helpful. However, it does not describe the return format for title/topic queries or behavior when no parameters are given. Despite these gaps, it adds meaningful transparency beyond a generic '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?

The description is two sentences, front-loaded with the main purpose, and every sentence adds value. No wasted words.

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

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

The description adequately covers the number path (returns structured ACP record with listed fields) but leaves the title/topic query behavior unclear, such as whether it returns a list and what fields are included. Since no output schema exists, this gap makes the description only partially complete for a simple lookup tool.

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

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

Schema coverage is 100%, with each parameter already described. The tool description only slightly reinforces the 'number' parameter by explaining the structured record output, but it does not add semantic detail beyond what the schema provides. 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 clearly states the verb 'Look up' and resource 'Avalanche Community Proposals' with search dimensions (number, title, topic). It distinguishes from the sibling acp_list which presumably lists all proposals, while this tool targets specific lookups.

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

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

The description implies usage: use when needing to find a specific ACP by number, title, or topic. It gives clear context by explaining that providing a number returns a structured record, but it does not explicitly name alternatives like acp_list or state when not to use this tool.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only mentions the alias status and does not disclose any operational behavior such as side effects, return format, or safety traits. The actual behavior remains opaque without knowledge of docs_fetch.

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

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

The description is a single sentence, 8 words, with no wasted language. It is front-loaded with the core message and achieves its purpose of redirecting to docs_fetch 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?

Despite the low complexity (1 parameter, no output schema), the description is incomplete. It does not explain what the tool does, its return value, or any behavioral traits. It merely points to docs_fetch, leaving the agent without sufficient context unless it separately looks up docs_fetch.

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 description covers 100% of the single parameter 'url', fully explaining its meaning with an example. The tool description adds no extra parameter semantics, but the schema is sufficient, so a 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 it is a 'Compatibility alias for docs_fetch', which implies it provides the same functionality as docs_fetch, but it does not explicitly state what the tool does (e.g., fetch documentation content). It is not a tautology, but the purpose is vague and relies on the reader knowing what docs_fetch 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 explicitly instructs to 'Prefer docs_fetch for new clients', clearly indicating when not to use this tool and naming the preferred alternative. This is strong usage guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the tool is a compatibility alias, implying identical behavior to docs_list_sections, but gives no details about what that behavior involves (e.g., return values, auth needs, side effects). The alias relationship is insufficient without describing the actual functionality.

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

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

The description is two short sentences, each with a specific purpose: stating what the tool is and giving usage direction. It is front-loaded and contains no wasted words.

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

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

For a simple alias with no parameters, no annotations, and no output schema, the description is sufficient to guide an agent to the preferred docs_list_sections tool. It doesn't need to explain return values or behavior since the underlying tool is available as a sibling, but it could have added a one-line note about what the aliased tool actually does.

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 adds no parameter information, but with no parameters, the baseline for parameter semantics is 4, indicating no further explanation is necessary.

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

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

The description clearly identifies the tool as a compatibility alias for docs_list_sections, which differentiates it from the preferred sibling. It does not explicitly state the underlying functionality (listing documentation sections) but the name conveys that. This is clear but could be more specific about actual behavior.

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

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

The description explicitly says 'Prefer docs_list_sections for new clients,' giving a clear when-to-use and when-not-to-use directive. This is exactly the kind of alternative-based guidance expected, with the preferred tool 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?

No annotations are provided, and the description gives no behavioral details such as return format, pagination, or read/write safety. 'Compatibility alias' implies identical behavior to docs_search but does not explain what that behavior is, leaving a significant transparency 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?

Two concise sentences with the key guidance front-loaded. Both sentences earn their place: the alias status and the preference for docs_search. No wasted words.

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

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

For a tool with no output schema and no annotations, the description should at least state the function. It only labels the tool as a compatibility alias and directs users away without explaining what the tool does. The documented schema helps but does not compensate for the missing functional description.

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 already describes all three parameters with full coverage, so the baseline is 3. The description adds nothing about parameter meaning beyond what the schema provides.

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

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

The description only says 'Compatibility alias for docs_search' without stating that the tool searches documentation. It relies on the name and sibling tool for inferred purpose, making it vague rather than a specific verb+resource statement.

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

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

Explicitly advises 'Prefer docs_search for new clients,' clearly indicating when not to use this tool and directing to the preferred alternative. This satisfies the when/when-not requirement with an explicit alternative.

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

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

No annotations are provided, so the description carries the burden. It discloses that this is a compatibility alias and that onchain_lookup should be preferred, which is useful contextual behavior. However, it does not mention other behavioral aspects like return format, error handling, or read-only nature, though the name and schema imply a simple 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?

The description is a single sentence that packs purpose and usage guidance efficiently. Every word earns its place, and the most important information (prefer onchain_lookup) 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?

This is a simple metadata lookup tool with a well-documented schema. The description tells the user it is a compatibility alias, points to the preferred tool, and the schema covers parameters. While it does not explain return values or limitations, the low complexity and alias nature make it reasonably 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 100% with both 'address' and 'chainId' described clearly. The description adds no parameter-specific information, but the schema already fully documents each parameter, 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 identifies the tool as a compatibility alias for onchain_lookup contract metadata, making it clear that it retrieves contract information. It does not use an explicit verb like 'get', but the phrase 'contract metadata' combined with the tool name conveys the function. It distinguishes from siblings by naming the preferred alternative, onchain_lookup.

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

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

The description explicitly says 'Prefer onchain_lookup for new clients', giving clear when-not-to-use guidance and naming the alternative. This is exactly the kind of actionable directive that helps an agent choose between this tool and its 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?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It offers only the alias/deprecation context and 'address balances,' but no details on safety, permissions, rate limits, or operational side effects. This is minimal for a tool with zero annotation support.

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

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

Two short sentences, no wasted words. The first sentence states the tool's nature, and the second provides actionable directional advice. Perfectly front-loaded and concise.

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

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

For a simple compatibility alias with full schema coverage, the description effectively communicates purpose and replacement. It doesn't explain return formats, but the explicit pointer to onchain_lookup and the absence of an output schema mitigate this gap.

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

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

Schema description coverage is 100%, with both address and chainId already described. The description adds no parameter-specific information beyond referencing balances, 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 identifies the tool as a compatibility alias for onchain_lookup address balances, clearly indicating it retrieves balances. It distinguishes from siblings by pointing to the preferred onchain_lookup tool, though the exact verb 'get' is implied rather than explicitly stated.

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

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

Explicitly states 'Prefer onchain_lookup for new clients,' giving clear when-to-use guidance and naming the alternative tool. This leaves no ambiguity about the intended usage and deprecation 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?

With no annotations, the description must disclose behavior. It only states it is an alias, without explaining what the behavior actually is, whether it is read-only, or what response to expect. The mention of 'address details' is vague and does not enrich the agent's understanding beyond the tool name.

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

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

The description is two sentences, tightly packed with the essential message: it is an alias and the preferred alternative is onchain_lookup. No wasted words or redundant 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 tool is a simple alias with full schema coverage, but the description does not explain what 'address details' entail, leaving the agent to infer or search for onchain_lookup. Given the tool's simplicity, this is adequate but not rich; the deprecation guidance is useful but the actual behavior is under-specified.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no parameter-specific information, but the schema already fully documents both parameters (address and chainId), so the description does not need to compensate.

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

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

The description states it is a 'Compatibility alias for onchain_lookup address details', which clearly identifies the tool as an alias for address detail lookups. It distinguishes from siblings by naming the preferred alternative, though it does not use a strong verb like 'retrieves' or 'looks up'.

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

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

The description explicitly provides usage guidance: 'Prefer onchain_lookup for new clients.' This tells the agent when to use this tool versus the alternative, fulfilling the when/when-not requirement clearly.

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. It implies a read-only operation ('Look up') and adds useful context about the return fields (name, VM type, subnet). However, it does not disclose behavior for invalid IDs, network selection effects, or error handling, leaving some behavioral ambiguity.

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

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

The description is a single sentence that is front-loaded with the action ('Look up') and immediately specifies the resource and output. Every word is information-dense, with no filler or repetition.

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 two-parameter lookup tool with no output schema, the description adequately covers the core behavior and return data. It lacks details about the network parameter and potential errors, but these are minor gaps given the tool's simplicity. The description is sufficient for an agent to understand what the tool does and what it returns.

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 chainId as 'The blockchain ID,' and the description merely restates 'by its ID,' adding no new meaning. The network parameter is not mentioned in the description at all, leaving its purpose to the schema's enum and default. With schema coverage at 50%, the description fails to compensate for the undocumented network parameter.

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

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

The description clearly states the tool's function: 'Look up a blockchain by its ID' and specifies the exact information returned — 'name, VM type, and subnet.' This distinguishes it from sibling tools like blockchain_lookup_address or blockchain_lookup_subnet by explicitly targeting chain ID lookups.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention that this tool is specifically for chain ID lookups while other tools handle addresses, subnets, or transactions, nor does it note any conditions or prerequisites. The description only states what the tool does, not when to choose it.

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

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

No annotations are provided, and the description only states the lookup target and output categories. It does not disclose safety, permissions, default network behavior, possible edge cases (e.g., unknown ID), or response format, placing the full burden on the description and falling short.

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

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

The description is a single sentence with clear, front-loaded structure. It avoids extra words and communicates the core purpose 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 two-parameter lookup tool, the description provides the essential purpose and return categories, but lacks details on default network, error behavior, and response structure. Given the absence of annotations and output schema, the description is minimally adequate but not fully complete.

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

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

Schema coverage is 50%, with only subnetId having a description (and that description is trivial). The description does not explain the network parameter at all; it only refers to 'by its ID,' which adds no meaning beyond the schema. The enum values are present but not semantically explained.

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 ('Look up') and resource ('Subnet / L1') by ID, and lists the returned data ('validators, chains, and configuration'). This clearly distinguishes it from sibling tools like blockchain_lookup_chain or blockchain_lookup_validator.

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

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

The description implies usage when you have a Subnet ID and need details, but it does not explicitly state when to use this tool over alternatives, nor does it mention relevant siblings such as platform_get_subnets or blockchain_lookup_chain. The context is clear but lacks explicit guidance.

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

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

No annotations are provided, so the description carries the full burden. It discloses the supported chains and hash formats, which is useful behavioral context. However, it does not mention return format, error behavior, or explicitly confirm this is a read-only operation. The description adds some context beyond the schema but lacks depth for a fully transparent view.

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

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

The description is two sentences, front-loaded with the primary action, and contains no filler. Every phrase earns its place, making it highly efficient and 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 lookup tool with fully documented parameters and no output schema, the description provides the essential context: what is looked up and on which chains. It could be improved by mentioning the return value or potential errors, but it is otherwise complete for the tool's apparent simplicity.

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

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

Schema coverage is 100%, so the schema already documents both txHash and network. The description repeats the 0x/CB58 format detail already present in the schema, adding no new parameter semantics. Baseline 3 is appropriate because the schema does the heavy lifting.

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

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

The description clearly states the tool's function: 'Look up a transaction by hash on Avalanche (C-Chain, P-Chain, or X-Chain).' It uses a specific verb ('look up'), a specific resource ('transaction by hash'), and distinguishes from sibling tools like blockchain_lookup_address and blockchain_lookup_chain by focusing on transactions and hash formats.

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

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

The description implies usage when you have a transaction hash and need to look it up on Avalanche networks. However, it does not explicitly state when to prefer this tool over alternatives like platform_get_tx or when not to use it. The guidance is mostly implied from the name and the supported chain/format 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It only lists the output categories (stake, uptime, delegation info) but does not mention return format, error handling, rate limits, network/Subnet behavior, or any side effects. This is insufficient for a tool with no annotation safety profile.

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. Every word earns its place, and the em-dash efficiently introduces the output focus. It is appropriately sized for the tool's simplicity.

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

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

Given no annotations, no output schema, and three parameters, the description is incomplete. It does not mention what happens for invalid node IDs, whether network-specific data affects results, or how delegation info is structured. Comparable tools in the calibration set with similar complexity receive higher scores only when they add operational context.

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

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

The schema description coverage is 67% (nodeId and subnetId have descriptions, network does not). The description adds only general output categories and does not clarify the meaning of the network or subnetId parameters. It does not compensate for the missing network parameter description, so the added value beyond schema is minimal.

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

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

The description uses the specific verb 'Look up' and clearly identifies the resource as 'a validator by node ID', while also listing the information categories (stake, uptime, delegation info). It distinguishes itself from sibling lookup tools (address, chain, subnet, transaction) by focusing on validator lookup, so no ambiguity remains.

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

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

No guidance is provided regarding when to use this tool versus alternatives such as platform_get_current_validators or platform_get_validators_at. The description implies the use case (lookup by node ID) but does not explicitly state exclusions or comparisons with sibling tools.

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

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

No annotations are provided, so the description bears full responsibility. It declares 'Read-only: never signs' clearly, but does not elaborate on potential side effects or dependencies. The behavioral trait is well-captured, but lacks depth.

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 dense single paragraph containing all instructions. While every sentence adds value, it could be better structured (e.g., bullet points) to improve readability for agents.

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

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

Given the tool's complexity (19 parameters, 6 operations, no output schema), the description covers usage context, parameter grouping, and important caveats. However, it does not describe the return format or contents of the runbook.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by grouping parameters per operation and clarifying usage (e.g., 'transfer: destination address'). It enriches context beyond 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 clearly states the tool generates step-by-step runbooks for specific Avalanche operations, distinguishing itself by listing the covered operations and explicitly directing cross-chain work to 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 explicitly states when to use each operation, provides alternatives like ictt or interchain-kit for cross-chain tasks, and notes the tool is read-only (never signs).

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 burden. It discloses that sources/warnings are in the response and advises against presenting flagged values as exact. It also notes that C-Chain gasUsed is stable due to regulation, setting accurate expectations.

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

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

The description is moderately long but front-loaded with purpose. Every sentence adds value: targets, parameter limits, behavioral caveats. Minor redundancy (e.g., mentioning max values) is acceptable for clarity.

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

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

Given 8 parameters and no output schema, the description covers the three targets, parameter usage, critical behavioral notes (warnings, gas stability), and edge cases. It lacks explicit output structure, but the purpose is well-served.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning by explaining how parameters interact (e.g., 'target=contract uses days, max 365') and clarifies default windows. This goes beyond the schema's individual descriptions.

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

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

The description clearly states the tool provides on-chain statistics via a query gateway and details three distinct targets (chain, contract, network) with specific metrics for each. It differentiates between recent aggregate and time-series windows, making the purpose unambiguous.

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

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

The description explains when to use each target (e.g., contract for activity beyond 30 days) and provides limits (max hours/days). It does not explicitly list when not to use or compare to siblings, but the context signals show many siblings; the description sufficiently guides selection.

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

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

With no annotations available, the description takes on the burden of disclosure. It states the return type ('Returns cited command references and task docs'), which is helpful, but it does not mention read-only nature, potential errors, or other behavioral aspects. This leaves some gaps in transparency.

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

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

The description is a single concise sentence (18 words) that front-loads the action and purpose. It contains no redundancy or extraneous information, making it highly efficient.

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

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

For a simple lookup tool with three parameters and no output schema, the description adequately covers the core purpose and return value. It could add more detail about the source or citation format, but the schema handles parameter specifics, making it sufficiently complete for the tool's complexity.

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

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

The input schema already provides descriptions for all three parameters (100% coverage), so the baseline is 3. The description adds minimal parameter-specific value, merely mentioning the CLI surfaces that correspond to the 'cli' enum, which does not go beyond the schema.

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

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

The description clearly states the tool's function: 'Look up Avalanche CLI, Platform CLI, and tmpnet command guidance in the docs.' It identifies a specific resource (CLI documentation) and distinguishes itself from sibling docs search tools by focusing on CLI command references and cited returns.

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

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

The description provides clear context for when to use the tool: when seeking CLI command guidance for Avalanche CLI, Platform CLI, or tmpnet. However, it does not explicitly mention alternative tools or when not to use it, so it lacks exclusions but remains unambiguous.

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 details the behavior of both invocation modes, including the content of the output (ordered steps, CLI equivalents, transaction signing indicator, deep-links). Since no annotations are provided, the description fully communicates the tool's effect. It does not mention whether the tool makes network calls or modifies state, but the output descriptions imply it is a read-only knowledge 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?

The description is two sentences, with the first sentence front-loading the key behavioral distinction and output specifics, and the second sentence listing the flow keys. Every word adds value, and the structure is easy to parse.

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

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

The tool has a simple interface (one optional parameter) and no output schema. The description adequately conveys what the agent can expect from each invocation mode, including the type of information (summaries, deep-links, steps, CLI, etc.). It does not specify the exact output format (e.g., plain text vs JSON), but the level of detail is sufficient for an agent to decide when to use this 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 input schema already has a high coverage (100%) with a description for the flow parameter. The tool description adds contextual meaning by explaining the differences between omitting and including the parameter, and by listing the supported flow keys. It also provides details about the output content for each mode, which goes beyond the schema's parameter description.

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

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

The description clearly specifies two distinct operations: listing all flows with summaries and deep-links, and explaining a specific flow with ordered steps, CLI equivalent, transaction signing info, and deep-link. It lists all valid flow keys, making the tool's domain concrete. The tool is distinct from sibling tools, which focus on blockchain data retrieval.

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

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

The description explicitly states when to omit the flow parameter (to list) and when to include it (to explain). This provides clear usage guidance for both modes. However, it does not mention any scenarios where this tool should not be used, but given the context, alternatives are not 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?

No annotations provided, so description bears full burden. It states return type (deep-link) and special case for mainnet faucet, but does not describe format of the link or any side effects.

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

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

Single sentence with parenthetical addition. Front-loaded with main purpose, no superfluous words.

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

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

No output schema, description does not specify return format (e.g., URL string, object). For a simple tool, it covers essential behavior but could be more explicit about output.

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

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

Schema coverage is 100%, baseline 3. Description adds context: list of flows, notes that network only affects faucet, and validatorManager variant. Adds value beyond enum names.

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

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

Clear verb 'Return a deep-link' with specific resource 'Builder Console flow' and lists all valid flows. Distinct from sibling tools which are info/lookup.

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?

Explicitly lists valid flows and special behavior for faucet on mainnet. No explicit comparison to alternatives, but context suggests no direct sibling is similar.

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 burden. It only states the basic action and markdown output, without disclosing error handling, rate limits, redirect behavior, or any constraints. This lack of behavioral detail is a significant gap for a tool with no other safety indicators.

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 efficiently conveys the core action, resource, and output format.

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 tool, the description is nearly complete: it states the action, resource, and return format (markdown), and the schema covers the parameter. However, it lacks any note about URL scope (e.g., whether only internal paths are valid) or relationship to similar sibling tools like avalanche_docs_fetch.

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 describes the url parameter with a clear example, and the description adds no extra parameter context. With 100% schema description coverage, a baseline score of 3 is appropriate.

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

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

The description clearly states the tool fetches a specific documentation page as markdown, using a specific verb and resource. It distinguishes from siblings like docs_search and docs_list_sections by focusing on direct retrieval of a specific page.

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

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

The description implies usage when you have a specific page URL path, but it does not explicitly mention when to use this tool versus alternatives like docs_search or avalanche_docs_fetch. No exclusions or comparisons are provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It clearly implies a read-only listing operation and mentions page counts, but it does not elaborate on response structure, ordering, or any potential caveats, which would add more depth.

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

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

The description is a single, concise sentence that front-loads the action verb and states the resource and output. It contains no filler or redundant information.

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

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

For a simple 0-parameter listing tool with no output schema, the description adequately conveys the return value (sections with page counts). It could be slightly more explicit about the exact response format, but it is sufficient for an agent to select and invoke 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?

With zero parameters and full schema coverage, the baseline is 4. The description correctly implies no inputs are required; no additional parameter explanation is needed.

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

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

Description uses the specific verb 'List' with the clear resource 'available documentation sections' and adds 'their page counts'. This effectively distinguishes it from sibling tools like docs_fetch and docs_search, which focus on retrieving content.

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: use this tool to enumerate documentation sections. However, it does not explicitly mention alternatives or exclusion criteria (e.g., 'for content, use docs_fetch'), so it falls short of a perfect score.

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. It discloses that the tool returns source citations and matching excerpts, which is helpful. However, it does not explicitly state read-only behavior, pagination, or any other potential side effects, though none are expected for a search tool.

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

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

The description is two sentences, front-loaded with the primary action and followed by the output. Every word contributes, making it concise and 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?

The description covers the core functionality and return type, which is sufficient for a search tool without an output schema. However, given the large sibling list and the presence of a similar tool (avalanche_docs_search), a note on differentiation or typical use cases would improve 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?

The input schema has 100% coverage for all three parameters (query, limit, source), including clear descriptions. The tool description adds minimal value beyond the schema, only mentioning the sources in a general way. The baseline of 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states the tool's function: searching body-level chunks across specific documentation sources and returning citations and excerpts. However, it does not explicitly differentiate from the sibling tool 'avalanche_docs_search', which appears to have a similar purpose.

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

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

No guidance is provided on when to use this tool versus alternatives like docs_fetch or avalanche_docs_search. The description implies usage for searching but does not state exclusions or preferred scenarios, leaving the agent without clear selection criteria.

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

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

With no annotations, the description carries full behavioral burden. It only states it 'gets information,' implying a read operation, but does not disclose return format, whether it returns all ACPs or a single one, or any other behavioral traits. This is insufficient for a tool with no structured annotation support.

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

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

The description is a single, concise sentence that is front-loaded with the key purpose. Every word contributes value, with no redundancy or wasted detail.

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

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

This is a simple tool with one optional parameter and no output schema. The description covers the basic purpose but lacks details about return values or how this relates to sibling ACP tools. For its low complexity, it is minimally adequate but has room for improvement.

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

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

The input schema has 100% coverage for the sole parameter 'network', including enum values and default. The description adds no additional parameter semantics, but since the schema is complete, baseline 3 is appropriate.

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

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

The description clearly states the verb 'Get information' and the resource 'Avalanche Community Proposals (ACPs),' with specifics on what info is returned (status and vote counts). This is distinct from generic 'info' tools, though it doesn't explicitly differentiate from sibling tools like acp_list or acp_lookup.

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. It does not mention acp_list or acp_lookup, nor any context for when this tool is preferred. The description provides no exclusions or alternative recommendations.

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 the operation ('Get') and output encoding, but does not mention read-only guarantees, error behavior, network default, authentication requirements, or any side effects. This leaves the agent uninformed about important operational traits.

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 immediately states the action and object, and the parenthetical examples make the input format clear without extra prose.

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

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

For a simple read-only getter with a 2-parameter schema fully described, the description plus schema is sufficient to understand the tool's core behavior. It explains the return type (CB58-encoded blockchain ID) and the schema covers parameter defaults and enums. Minor gaps like error cases prevent a perfect score.

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

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

Schema description coverage is 100% with detailed descriptions for both 'alias' and 'network', including examples and enum values. The description adds only marginal context (the CB58 output encoding) and does not deepen the meaning of the parameters beyond the schema, 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 uses a specific verb ('Get') and resource ('CB58-encoded blockchain ID') with concrete alias examples ('X', 'P', 'C'). This clearly identifies the tool's function and distinguishes it from sibling tools like info_get_network_id or blockchain_lookup_chain.

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

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

The description implies that the tool should be used when you have a blockchain alias and need its CB58-encoded ID, but it does not explicitly state when to use it versus alternative tools or mention any exclusions/prerequisites. Sibling tools such as blockchain_lookup_chain might overlap, and no guidance is given for choosing between 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It clearly indicates a read operation ('Get') and specifies the scope ('this node is participating in'), which is helpful. However, it does not disclose return format, potential error conditions, or the effect of the optional network parameter.

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

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

The description is a single, concise sentence that is front-loaded with the verb and resource. It contains no unnecessary words or repetition, earning a top score.

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

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

For a simple tool with one optional parameter and no output schema, the description is sufficiently complete: it states what is returned (numeric ID) and the context (the node's network). It could mention the default network, but the schema already covers that parameter.

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 only parameter (network) is fully documented in the schema with an enum and default. The description adds no additional parameter semantics beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the verb 'Get' and the resource 'numeric ID of the Avalanche network', which is specific and distinct from sibling tools like info_get_network_name (which gets the name) and info_get_blockchain_id (which gets a blockchain ID). This makes the tool's purpose unambiguous.

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

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

The description implies usage (getting the network ID) but provides no explicit guidance on when to use this tool versus alternatives such as info_get_network_name or info_get_blockchain_id. There are no exclusions or alternative mentions.

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

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

With no annotations, the description must disclose behavior itself. It says 'this node is participating in', implying the return value depends on the node's current network, but the optional 'network' parameter suggests a default of 'mainnet' per the schema. This conflict creates ambiguity about what the tool actually returns when no parameter is supplied.

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

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

The description is extremely concise at 14 words, front-loads the key action, and contains no filler. It is appropriately sized for a simple getter 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 simple getter, the description covers the essential purpose and the schema defines the parameter. However, it leaves ambiguity about the default behavior and the format of the return value, and lacks any clarification of edge cases. More context would be needed to fully guide the agent, especially given the lack of annotations.

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 parameter is already well-documented. The tool description adds the phrase 'this node is participating in', which creates ambiguity rather than adding clarity about the parameter's role. It adds limited value and potentially confuses the default behavior.

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

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

The description uses specific verb 'Get' and resource 'human-readable name of the Avalanche network', clearly distinguishing it from sibling tools like info_get_network_id that likely return numeric IDs. It precisely states 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 provides clear context for when to use the tool (when you need the network name), but it does not explicitly mention alternatives or exclusions. The context is self-evident, but no when-not guidance is given.

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

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

No annotations are provided, so the description carries the full burden. It adds context about the contents of the version information (database version, git commit, API compatibility) but does not disclose any side effects, permissions, rate limits, or response format. For a read-only info tool, this is moderate but not rich.

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

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

The description is a single, front-loaded sentence that starts with the core action and specifies the resource and included components. Every word 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?

The description adequately conveys the purpose and key return components, which is sufficient for a simple info tool. It lacks detail on response format or how the network parameter affects output, but the schema covers the parameter default, and the tool's simplicity reduces the need for more.

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

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

The schema has 100% coverage for the only parameter 'network', including its default value, so the description does not need to add parameter details. Baseline 3 applies per the rubric.

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 'Get' and clearly identifies the resource ('the version of the node') with additional detail on included components. It distinguishes itself from sibling info_* tools that retrieve network IDs, fees, or bootstrapped 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?

No explicit guidance on when to use this tool versus alternatives or any exclusions. The usage is implied by the purpose, but there is no direct statement of when to choose this over sibling info tools.

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

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

No annotations are provided, so the description carries the full burden. It discloses the return format (nAVAX/AVAX) but does not mention the optional network parameter's default behavior or any other behavioral details (e.g., read-only nature, error conditions). A basic read query with limited behavioral complexity, so a mid score is appropriate.

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, focused sentence that immediately communicates the tool's purpose and output format, with no unnecessary words.

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

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

This is a simple tool with one optional parameter and no output schema. The description covers what the tool returns and the schema documents the parameter, making the context sufficiently complete. A minor gap is not stating the default network explicitly in the description, but the schema covers it.

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

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

The input schema has 100% description coverage for the single 'network' parameter, including an enum and default. The description adds no additional parameter details, 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?

The description clearly states the tool's function: fetching current transaction fees for the network, with the return format specified in both nAVAX and AVAX. This distinguishes it from sibling info_get_* tools that query other network information.

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

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

The description does not explicitly state when to use this tool or mention alternatives, but the purpose implies usage for querying transaction fees. No exclusions or alternative tools are referenced, so guidance is merely 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the core check but does not mention that it is a read-only operation, what the return value looks like (e.g., boolean), or how errors are handled (e.g., invalid chain). For a simple status check, this is a minimal but incomplete disclosure.

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

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

The description is a single sentence that states the purpose directly and front-loads the verb 'Check'. It contains no fluff or redundancy; every word contributes to the meaning, making it highly concise and 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?

The tool is simple with only two well-documented parameters, but there is no output schema and the description does not explicitly state the return type or any behavioral nuances. While the main purpose is clear, the lack of return-value details and context around bootstrapping completeness leaves the description somewhat incomplete.

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

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

Schema description coverage is 100% for both parameters ('chain' and 'network'), so the schema already documents their meaning and defaults. The description adds no additional parameter semantics, but this is acceptable given the baseline of 3 when the schema covers all parameters.

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

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

The description uses the verb 'Check' with a specific resource ('a given chain') and a specific condition ('has finished bootstrapping on the node'). This clearly identifies the tool's function and distinguishes it from sibling info_* tools like info_peers or info_get_node_version, which check other node aspects.

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 to verify chain bootstrapping status but provides no explicit guidance on when to use it versus alternatives, nor any conditions for use. There are no exclusions or references to sibling tools, leaving usage context only implied by 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?

No annotations are provided, so the description must carry the transparency burden. It contributes context that the peers are for 'this node' and supports filtering, but it omits details like response format, pagination, or error conditions. This is adequate but not rich.

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

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

The description is a single concise sentence, front-loading the primary action and adding the optional filter. No superfluous words.

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

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

For a simple read-only info tool with two optional parameters fully specified in the schema, the description covers the essentials: what it returns and the optional filter. It doesn't explain return structure, but the lack of output schema and the straightforward nature make 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?

The schema provides 100% description coverage for both the network enum and nodeIDs array, including defaults and examples. The description only restates the nodeIDs filter, adding no new parameter semantics beyond the schema.

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

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

The description uses the specific verb 'Get' and clearly identifies the resource as 'a list of peers this node is connected to,' with optional filtering by NodeIDs. This clearly differentiates it from sibling tools, none of which list peers.

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

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

The description implies usage for querying peer connections and optional filtering, but it doesn't explicitly name alternatives or exclusion conditions. However, the context is clear, and no sibling tool offers this functionality, so it's sufficient.

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

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

No annotations provided, so description carries full burden. It discloses that it returns transaction count and recent samples, time-windowed, with defaults for various scopes. Read-only nature is implied but not stated.

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

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

Concise but packed with information. Front-loaded with core purpose, then details. Slightly dense; could benefit from bullet points for readability.

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

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

Covers input semantics well for 10 parameters and various scopes. However, lacks description of output format (what fields in the sample) and pagination behavior. Adequate but could be more complete.

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

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

Schema coverage is 100% with descriptions. The description adds context beyond schema: explains effect of scope (chain returns count, primary defaults to P-Chain), hours max, and defaults for value and blockchainId.

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

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

The description clearly states it returns time-windowed on-chain activity with transaction count and recent samples. It distinguishes itself from siblings like chain_stats and onchain_query by mentioning alternatives for longer windows.

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 guidance on different scopes (address, chain, token, primary, contract) and feeds, with defaults and constraints. Suggests alternatives for longer windows but does not explicitly list all when-not-to-use scenarios.

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

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

No annotations exist, so the description carries full burden. It mentions auto-detection of kind, network inference from P-/X-Chain prefixes, and backing by Glacier + P-Chain RPC. However, it does not disclose whether the tool is read-only, idempotent, or any side effects. For a primary lookup tool, this is acceptable but incomplete.

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 with multiple clauses and parentheticals. While it conveys all necessary information, it could be more scannable (e.g., using bullet points). It is adequately sized but lacks front-loading of the most critical 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 lacks any mention of the output format or structure of the lookup results. With no output schema provided, the agent needs to infer return values. It names data sources (Glacier, P-Chain RPC) but not what the response contains, making it incomplete for a complex tool.

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

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

Schema coverage is 100% (all 6 parameters described). The description adds value by explaining auto-detection for 'kind' and network inference from prefixes, which goes beyond the schema's enum lists. It also consolidates the entity types in prose, aiding interpretation.

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

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

The description clearly states it is a PRIMARY lookup tool for any on-chain identifier, enumerating specific entity types (EVM address, contract, token, NFT, tx hash, subnet, validator, chain name/id, P-/X-Chain account) and explicitly contrasts with raw RPC. This provides a specific verb+resource and distinguishes from siblings like blockchain_get_* functions.

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

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

The description advises to use this tool instead of raw RPC and for any address/contract/token/identity question. It does not explicitly list exclusions or alternatives, but the context of siblings like blockchain_lookup_* implies it covers them. A clear usage context is 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?

With no annotations, the description discloses behavior: each op selects live sources, stamps sources, flags caveats, and requires relaying warnings. Also notes C-Chain gasUsed regulation. This goes beyond basic read/write expectations.

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

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

Description is comprehensive but verbose; while well-structured with front-loaded purpose, it could be more concise given the length. Earns its detail but not a model of brevity.

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

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

Complex tool with 9 ops; description covers all ops, parameters, lookback limits, and behavioral quirks. No output schema, but mentions return fields (sources, warnings). Complete enough for effective use.

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

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

Schema coverage is 100% but schema provides only minimal descriptions. The description compensates by detailing each op's parameters thoroughly, adding meaning beyond the schema's enum and nested object.

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

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

Description clearly identifies as 'PRIMARY tool for indexed on-chain stats/activity/totals' and specifies it should be preferred over raw RPC, making the purpose and resource 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?

Explicitly guides to prefer this over raw RPC, provides lookback limits, and explains when to use day-based vs hour-based ops. However, it does not explicitly differentiate from sibling tools like chain_stats or onchain_activity.

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

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

No annotations are provided, so the description carries the full burden. It only states the operation ('Get balance') without disclosing behavior such as default network handling, error scenarios, pagination, or whether it accepts only P-addresses. The mainnet default is only visible in the schema, not the description.

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

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

The description is a single concise sentence that directly states the tool's purpose without any filler or redundancy. Every word is necessary and 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?

The tool is simple with only two parameters and no output schema, so the description is mostly sufficient. However, it does not explain the return format (e.g., units, decimal precision, or how balances are aggregated) which would be valuable for a balance query without an output schema. It is decent but slightly incomplete.

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

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

Schema coverage is 100%, with both 'network' and 'addresses' already described in the input schema. The description adds no additional parameter semantics beyond restating that addresses are for the P-Chain, which is already in the schema. Baseline 3 is appropriate because the schema handles parameter documentation.

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

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

The description uses the specific verb 'Get' and names the exact resource ('AVAX balance of one or more P-Chain addresses'). This clearly distinguishes it from sibling platform_* tools that query validators, staking, or subnets, and from blockchain_get_native_balance which likely targets a different chain.

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

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

The description implies usage context by specifying 'P-Chain addresses', which suggests this tool is for P-Chain balance queries. However, it does not explicitly state when to prefer this tool over alternatives like blockchain_get_native_balance, nor does it mention any exclusions or edge cases.

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 for behavioral disclosure. The description only states the basic get operation; it does not mention read-only behavior, return format, error handling, or any side effects. The verb 'Get' is already in the name, so no additional behavioral context is added.

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

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

The description is a single, concise sentence with no redundant words. It immediately states the tool's action and scope, making it efficient and 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 simple get-by-ID tool with fully described parameters, the description conveys the core purpose. However, it lacks usage guidance vs. sibling tools and does not describe the return value or behavior, which is more relevant given no output schema is present. It is adequately complete 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?

The input schema provides 100% coverage for all three parameters, each with clear descriptions (e.g., 'CB58-encoded block ID', network enums, encoding format). The description adds no extra semantic information about the parameters, 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 'Get a P-Chain block by its block ID' uses a specific verb ('Get'), a specific resource ('P-Chain block'), and a clear identifier ('by its block ID'). It distinguishes from sibling tools like platform_get_block_by_height, which retrieves by height, and platform_get_tx, which retrieves transactions.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention that platform_get_block_by_height should be used when only the height is known, nor does it state any preconditions or contextual hints for choosing this tool.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. However, it only says 'Get' without explicitly stating it is a read-only operation, how errors are handled (e.g., missing height), or what the return format looks like. This is a minimal disclosure for a tool with no 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 redundant words. It efficiently states the tool's purpose without unnecessary elaboration.

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 relatively simple (3 params, no output schema), but without annotations or an output schema, the description is slightly under-specified. It doesn't mention the return format or that the 'encoding' parameter controls it, nor does it note that 'network' defaults to mainnet. Adequate but with 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 covers 100% of the parameters, so baseline is 3. The description adds no extra meaning beyond the schema; it only mentions 'height' location but does not explain the encoding/network parameters beyond what the schema already says.

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 'Get a P-Chain block by its height' uses a specific verb and resource, and the 'by its height' qualifier distinguishes it from sibling tools like platform_get_block (likely by ID or hash). It is clear and non-tautological.

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 purpose is clear enough to infer when to use (when you need a block by height), but there is no explicit guidance about alternatives (e.g., use platform_get_block for by-ID lookup) or when not to use this tool. The context is implied rather than 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 burden of behavioral disclosure. It does disclose pagination behavior, but it does not mention read-only status, default network (mainnet), response format, error handling, rate limits, or any other behavioral traits. For a simple getter, the missing details are not risky, but the description adds only minimal behavioral context beyond the schema.

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

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

The description is a single, front-loaded sentence: 'Get all blockchains that exist on the P-Chain (paginated; use limit/offset)'. It conveys the essential purpose and a key usage detail without any wasted words. Perfectly concise and 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?

Given that all parameters are optional and well-documented in the schema, and there is no output schema, the description covers the core purpose and pagination behavior adequately. It does not explicitly describe the return format (e.g., an array of blockchain objects), but for a straightforward list retrieval, this is a minor gap. The description is complete enough for an agent to invoke the tool correctly.

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

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

The schema already describes all three parameters (limit, offset, network) with clear descriptions, so schema coverage is 100%. The description's mention of 'paginated; use limit/offset' reinforces what the schema already states but adds no new semantic detail. Baseline 3 is appropriate because the schema does the heavy lifting.

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

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

The description clearly states the action ('Get'), the specific resource ('all blockchains that exist on the P-Chain'), and even adds the pagination detail. This distinguishes it from sibling tools like platform_get_subnets (which lists subnets, not blockchains) and blockchain_lookup_chain (which looks up a specific chain). The verb+resource+scope is specific and unambiguous.

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

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

The description clearly indicates when to use this tool: when you need to retrieve all blockchains on the P-Chain. The parenthetical '(paginated; use limit/offset)' provides guidance on paging through the full list. However, it does not explicitly name alternative tools or describe when not to use this tool, so it falls short of a 5.

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

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

With no annotations, the description carries the burden of showing behavior. The verb 'Get' clearly indicates a read-only operation, which is a key behavioral trait. However, it does not disclose return format, permissions, or other potential limitations, so it only partially conveys the 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, well-structured sentence that directly states the purpose with no unnecessary words. It is front-loaded and easy to scan.

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

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

The tool is simple, but without an output schema or annotations, the description does not specify the return format or units. It adequately conveys the main purpose, but leaves some ambiguity about the response, making it minimally 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%, with both network and subnetID having clear descriptions. The tool description adds no extra parameter information, so the baseline score of 3 is appropriate per the rubric.

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 gets the current total supply of AVAX on a subnet, using a specific verb and resource. It distinguishes itself from sibling tools like platform_get_total_stake by focusing on supply rather than stake.

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, nor does it mention exclusions or prerequisites. It merely states the core function without any contextual hints.

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

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

With no annotations, the description must disclose behavioral traits, but it only mentions pagination—information already present in the parameter schema. It does not clarify what 'current' means, the return format, or any permissions or limitations.

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

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

The description is a single concise sentence, front-loaded with the core purpose. It is not verbose and every word contributes, though it omits important details that would make it more useful.

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 five parameters, no annotations, and no output schema, the description is inadequate. It fails to explain the meaning of 'current', the response structure, or how this differs from similar tools like platform_get_pending_validators or platform_get_validators_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?

All five parameters have detailed descriptions in the schema (100% coverage), so the baseline is 3. The description merely repeats the pagination hint for limit/offset, adding no new semantic context beyond the schema.

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

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

The description clearly states the tool retrieves 'current validators of a subnet' with a specific verb and resource. The word 'current' suggests a distinction from siblings like platform_get_pending_validators, but no explicit differentiation is provided.

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

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

No guidance is given on when to use this tool versus alternatives. The only usage hint is 'use limit/offset' for pagination, which is already evident from the schema and does not address selection among sibling tools.

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

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

No annotations are provided, so the description carries the full burden. The word 'Get' implies a read-only operation, but the description does not disclose potential side effects, network defaults, or error behavior. It adds no behavioral context beyond the basic action, which is minimal but not misleading.

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

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

The description is a single, front-loaded sentence with no redundant words. It efficiently conveys the core purpose without unnecessary detail.

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

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

Given the tool's simplicity (one optional parameter, no output schema, no annotations), the description is adequate. It clearly states what it does, but it does not explain the return value format or any error cases. For a simple height getter, 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 schema covers the single parameter 'network' with an enum and a description ('Avalanche network to query (default: mainnet)'), giving 100% schema_description_coverage. The tool description adds no additional parameter semantics, 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 'Get the current P-Chain block height' clearly specifies the verb 'Get' and the exact resource (current P-Chain block height). It distinguishes from sibling tools like platform_get_block_by_height, which retrieves a specific block by height, and platform_get_block, which fetches block data.

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

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

The description provides clear context that this tool is for retrieving the current height on the P-Chain. It does not explicitly mention alternatives, but the purpose is unambiguous. Sibling tools like platform_get_block_by_height for historical blocks are not referenced, so there is no exclusion 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that it gets minimum staking amounts, without mentioning return format, defaults, potential errors, or the fact that it queries a specific network/subnet (which are only in the schema). It also does not explicitly confirm it is a read-only operation, though that is implied.

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

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

The description is a single, concise sentence with no wasted words. It communicates the core purpose 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 simple read-only query with two well-documented optional parameters, the description is adequate. However, without annotations or an output schema, it could provide more context on what the result looks like or any important caveats. Still, it covers the essential purpose and inputs well.

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

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

Schema coverage is 100% with both parameters fully described. The description adds minimal extra meaning beyond the phrase 'on a subnet,' which only weakly relates to the subnetID parameter. Baseline of 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states the tool returns minimum staking amounts for validators and delegators on a subnet. It uses a specific verb and resource, and is distinct from sibling tools like platform_get_total_stake or platform_get_current_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?

No guidance is provided on when to use this tool versus alternative platform_* tools. The description does not mention exclusions, prerequisites, or scenarios where another tool would be more appropriate.

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

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

No annotations are provided, so the description carries the burden. It discloses pagination behavior, but does not describe return format, error cases, or authentication requirements. For a read-only getter, this is acceptable but minimal.

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

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

The description is one concise sentence with parenthetical guidance. It is front-loaded and every word earns its place, with no redundancy.

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

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

For a simple read tool with 5 optional parameters and full schema coverage, the description plus schema is nearly complete. It lacks explicit differentiation from sibling tools and does not mention response shape, but these are minor given the straightforward purpose.

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 fully documents each parameter. The description's mention of 'limit/offset' reinforces pagination but does not add new meaning beyond the schema.

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

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

The description clearly states a specific verb ('Get') and resource ('pending validators of a subnet'), distinguishing it from sibling tools like platform_get_current_validators and platform_get_validators_at. The addition of 'paginated' further clarifies the function.

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 on how to use pagination ('use limit/offset'), but does not explicitly mention when to choose this tool over alternatives or when not to use it. The context is clear enough for a simple getter, but lacks explicit 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 burden of behavioral disclosure. It states a 'Get' operation, implying read-only, but does not mention potential errors, return format, or effects of default parameters. It adds minimal context beyond what the name implies.

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

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

The description is a single, concise sentence that front-loads the core purpose. No filler or redundant information.

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

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

For a simple two-parameter getter with no output schema, the description is nearly complete. It could benefit from mentioning default values for network and subnetID, but these are already in the schema. Overall adequate for the tool's complexity.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (network and subnetID). The description adds no extra meaning about parameter usage, formats, or relationships, earning the baseline of 3.

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

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

The description clearly states the tool gets the asset ID of the staking token for a subnet, which is specific and distinguishable from sibling tools like platform_get_total_stake or platform_get_min_stake. The verb 'Get' and the resource 'asset ID of the token used for staking' precisely define the action and target.

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

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

The description implies usage when the staking asset ID is needed for a subnet, but it does not explicitly state when to use this tool over alternatives or provide exclusions. No mention of when not to use it or compare with similar platform_get_* 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 burden. 'Get information' implies read-only, but no additional behavioral context is provided—no mention of pagination, default network, or return structure. Schema includes limit/offset but the description does not explain how these affect 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?

Single sentence, front-loaded with verb and resource. No wasted words, though the term 'information' is vague. Still, appropriate size for the tool's simplicity.

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

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

With no output schema and only a one-line description, an agent cannot infer what fields are returned or how to interpret the result. The schema details parameters but not outputs, and the description adds no completion context.

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

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

Schema coverage is 100% with descriptive text for each parameter (filter by ids, pagination via limit/offset, network enum). The description adds no further meaning, so baseline 3 is appropriate.

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

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

Description states a clear action ('Get information') and specific resource ('subnets on the P-Chain'). This differentiates it from sibling tools like platform_get_blockchains, though it doesn't explicitly contrast with blockchain_lookup_subnet.

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. Sibling tools like blockchain_lookup_subnet or platform_get_blockchains exist, but the description gives no context for choosing this one.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only states the basic function and does not mention return format, what 'total stake' includes (validators vs delegators), potential errors, or default network/subnet behavior. This is a notable gap for a tool that queries blockchain data.

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

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

The description is a single, concise sentence that is front-loaded with the action. Every word is essential, and there is no filler or redundancy.

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

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

The tool is simple (two optional params, no output schema), and the description is a minimal summary. It is adequate for a basic understanding, but it does not explain return values, what constitutes 'total stake', or how to interpret subnet selection. Given the lack of annotations and output schema, slightly more context would be expected.

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 'network' and 'subnetID' already described. The description adds no additional parameter detail beyond what the schema provides, so a baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Get') and resource ('total amount staked on a subnet'), clearly distinguishing it from sibling tools like platform_get_min_stake or platform_get_current_supply. This is unambiguous and immediately indicates the tool's core function.

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. With many similar platform_get_* siblings, the agent gets no hints about which tool to choose for a given use case, nor any exclusions or 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?

With no annotations, the description must carry the full burden of behavioral disclosure. It only says 'Get', which implies a safe read, but it does not describe the response structure, what is included in the transaction object, error behavior for invalid IDs, or any rate limits. The encoding parameter hints at response format but is not explained in the description.

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, direct sentence with no wasted words. It is appropriately sized for the tool's simplicity and front-loads the action ('Get') and resource ('P-Chain transaction').

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

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

For a simple transaction getter with no output schema and no annotations, the description is minimal but not entirely inadequate. It lacks usage guidance and response details, but it clearly states the core function. Given the many sibling tools, it could benefit from differentiation, but the basic purpose is covered.

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

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

The input schema covers all three parameters with clear descriptions (txID as CB58-encoded, network with enum, encoding with enum). Schema coverage is 100%, so the baseline is 3. The description adds no extra semantics beyond the schema; it only restates that the tool retrieves by txID.

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+resource ('Get a P-Chain transaction') and specifies the lookup key ('by its transaction ID'). It clearly distinguishes from sibling tools like platform_get_tx_status (which only returns status) and blockchain_lookup_transaction (which may cover other chains).

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 explicit guidance on when to use this tool versus alternatives. It does not mention that platform_get_tx_status should be used for status-only queries, nor does it note any prerequisites such as the transaction needing to exist on the P-Chain. The only implied use is 'have a P-Chain transaction ID and want the full transaction.'

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It only says the tool gets a status; it does not disclose return format, possible status values, error behavior, network defaults beyond the schema, or read-only guarantees (though the verb implies it).

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, focused sentence that immediately states the tool's purpose. It is concise, front-loaded, and contains no superfluous words.

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

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

The tool is simple with two fully described parameters, but there is no output schema and the description does not explain the returned status shape or possible values. It is minimally adequate for tool selection, but less complete than would be ideal for an agent interpreting the result.

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

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

Schema description coverage is 100% for both parameters (txID and network), so the schema already provides full parameter meaning. The description adds no extra semantic detail beyond naming the resource, matching the baseline for fully documented 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?

The description uses a specific verb ('Get') and resource ('status of a P-Chain transaction'), clearly stating the tool's scope. It distinguishes from sibling tools like platform_get_tx by focusing on 'status', but does not explicitly contrast with 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 is provided on when to use this tool versus alternatives such as platform_get_tx, platform_get_utxos, or blockchain_lookup_transaction. There is no mention of prerequisites, typical use cases, or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It only states the action and does not disclose any behavioral traits such as default network, how the limit parameter behaves, sourceChain semantics, or output format. This is insufficient for operational transparency.

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

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

The description is a single, front-loaded sentence with no redundant words. It communicates the essence 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?

The schema thoroughly documents all parameters, and the description clearly states the tool's purpose. Since there is no output schema, the return format is not specified, but for a simple getter with well-documented parameters, the description is largely complete. A small gap is the lack of mention of atomic UTXOs or network default, but this is not critical.

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 provides descriptions for all 4 parameters (100% coverage). The description adds no new meaning beyond echoing that addresses are P-Chain addresses; the limit, network, and sourceChain parameters are not elaborated in the description. Baseline 3 is appropriate given full schema coverage.

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

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

The description clearly states the verb 'Get', resource 'UTXOs', and scope 'P-Chain addresses'. It distinguishes this tool from sibling tools like platform_get_balance or platform_get_tx by targeting UTXOs specifically.

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, no mention of prerequisites, and no exclusions. The description only states what the tool does, leaving the agent to infer usage context from the name and schema.

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 behavioral disclosure burden. It indicates a read-only operation ('Get') and specifies the output (validators and weights), but it does not disclose potential edge cases, error behaviors, or limitations such as how the network default or subnetID default are handled. It adds some scope context but lacks deeper behavioral detail.

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

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

The description is a single concise sentence, front-loaded with the verb and resource, and contains no extraneous information. It efficiently conveys the essential purpose.

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

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

The tool is relatively simple, with all parameters documented by the schema, and the description states the output ('validators and their weights'). This covers the core invocation context. However, the absence of explicit usage guidance and edge-case behavior slightly reduces completeness, though the schema compensates for parameter details.

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

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

The input schema provides thorough descriptions for all three parameters, including enums and defaults, with 100% schema description coverage. The description only reiterates the height and subnet concepts without adding new parameter semantics. A baseline score of 3 is appropriate given the schema's completeness.

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

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

The description clearly states the action ('Get') and the specific resource ('validators and their weights of a subnet at a given P-Chain height'). This distinguishes it from siblings like platform_get_current_validators and platform_get_pending_validators by emphasizing the historical height aspect.

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 a given P-Chain height' implies a historical query use case, but the description does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions or alternative tool names. Guidance is only implicit.

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

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

No annotations are provided, so the description carries the burden of disclosing behavior. It describes what it looks up and the scope, but does not mention return format, pagination, or that it is a read-only search. This is adequate but not rich; it doesn't contradict any annotations (none exist).

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

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

The description is a single sentence that front-loads the action and resource. It contains zero filler and communicates scope 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?

The tool has no output schema, and the description does not explain what the response looks like (e.g., list of methods, links, code examples). The scope is clearly stated, but the lack of return-value context and differentiation from generic docs search leaves some gaps for an agent invoking this 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% (all parameters have descriptions), so the baseline is 3. The description does not add substantial meaning beyond the schema—it repeats the chain scope already present in the chain property enum. No extra syntax or usage details 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 states a specific verb ('Look up') and resource ('Avalanche RPC methods and API guides') across defined chains (C-Chain, P-Chain, X-Chain, Subnet-EVM, node RPC docs). This clearly distinguishes it from sibling tools like blockchain_lookup_* (blockchain data) or cli_lookup_command (CLI commands).

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 by naming the exact chains and doc areas it covers, implying when to use it (e.g., for RPC method documentation lookups). It does not explicitly exclude alternatives or name sibling tools, but the scope is sufficiently clear for an agent to choose it over generic docs search.

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