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

With no annotations provided, the description must carry the behavioral disclosure burden. It states the operation is a read and that stats are 'live', which are useful behavioral clues. However, it does not mention side effects, latency, authentication needs, or what happens during a paused mint, so some transparency gaps remain.

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 leads with the action and resource, then lists the returned fields compactly. Every element earns its place; there is no filler or redundant phrasing.

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

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

For a zero-parameter read-only tool with no output schema, the description supplies the essential missing context: the contract source and the complete list of returned values. It could be more complete by specifying value types or units for fields other than currentPrice, but the low complexity makes this adequate.

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

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

The tool has zero parameters, so there is no parameter ambiguity to resolve. The schema coverage is trivially 100%, and the description adds value by naming the concrete statistics returned, including a unit clarification for currentPrice (USDC human units).

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

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

The description names a specific verb and resource ('Read live collection stats from PowMintNFTv3') and enumerates the exact fields returned. This clearly distinguishes the tool from siblings like price_info, which appears to focus on pricing, and get_token, which likely returns token-level data.

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

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

The description implies when to use the tool: whenever an agent needs current collection-wide minting statistics. However, it gives no explicit guidance about when not to use it or which sibling tool to prefer for related but different data, such as per-token details or craft information.

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

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

With no annotations, the description carries the full burden, and it does well: it explicitly labels the call read-only and lists every returned field plus the salt preimage rule. It does not address error cases or formatting, but for a zero-argument getter that disclosure is substantial.

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 packed with useful specifics and is front-loaded with the operation and target, but the single long sentence with nested slash-separated fields is harder to scan than a short bulleted list. No words are wasted.

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

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

For a parameterless read-only view, the description is complete: it names the state fields, the per-tier bounds, the window constants, and the salt-policy formula. There is no output schema, but the description itself supplies most of what an agent would need to interpret the result.

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

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

The tool has zero parameters, so the schema provides no parameter details and no compensation is needed; per the baseline for 0-param tools this is fully adequate.

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

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

The description names a specific operation ('Read-only view') and the target resource (CraftingController v1), then enumerates the exact fields and constants returned. This clearly distinguishes it from sibling verification/price helpers even without explicit comparisons.

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 establishes a clear read-only inspection context, but it never states when to prefer this tool over siblings like verify_craft_commit or price_info, nor does it give any when-not-to-use guidance. An agent must infer usage from the field list and tool name.

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

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

With no annotations provided, the description is the only disclosure. It explicitly says it reads data and returns an error for non-existent tokens, which is useful. It does not discuss side effects (though 'read' implies none) or potential external fetch behavior for off-chain URLs, so some behavioral depth is missing.

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 verb and resource, and contains no filler. Every phrase adds value: the field list sets expectations and the error clause sets failure behavior.

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

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

For a simple one-parameter read tool with no output schema, the description is complete. It enumerates the returned data and states the error condition. The schema handles parameter documentation, and there are no nested objects or complex behaviors requiring further explanation.

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 completely, including the tokenId description and exclusivity constraint. The tool description adds no additional parameter meaning, so a baseline score 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 identifies a read operation on a specific resource ('minted token') and lists the exact fields returned (owner, seed, nonce, tokenURI, image/metadata URLs). This distinguishes it from sibling tools like verify_nonce or collection_stats, which target different data or operations.

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

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

The phrase 'Read a minted token' implies the use case: call this when you need a token's stored and off-chain data. However, there is no explicit guidance about when not to use this tool or which sibling tool to prefer for related queries, leaving the differentiation to the agent.

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

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

With no annotations present, the description carries the full transparency burden. It explicitly states it 'reads' specific state variables and 'returns a wave summary,' clearly implying a read-only operation with no side effects. It also discloses the exact pricing config (priceStart 1 USDC, x2 per wave, no cap), adding concrete behavioral context. Minor omissions like error conditions or permissions are acceptable for a simple read 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 entire description is one tight sentence that front-loads the purpose ('Explain the pricing') and then efficiently lists the inputs, config values, and output. Every word earns its place with no redundancy or filler.

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

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

Given that there are no parameters, no output schema, and no annotations, the description is largely sufficient. It names the key inputs (currentWave, currentPrice, epoch config), the exact config constants, and the output type (wave summary). The only minor gap is that the structure of the wave summary is unspecified, but for a tool this simple it is likely not essential.

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

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

The input schema has zero parameters, so there is nothing to describe. Per the rubric, a 0-parameter tool gets a baseline of 4. The description does not need to compensate for missing parameter documentation because none exist.

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

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

The description opens with a specific verb-resource pair, 'Explain the pricing,' and then details what it reads (currentWave, currentPrice, epoch config) and what it returns (a wave summary). This clearly differentiates it from siblings like collection_stats or craft_info, which focus on other domains.

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

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

The description implies the tool is for retrieving a pricing summary based on current wave state, but it never explicitly states when to use it versus alternatives or any exclusions. An agent can infer 'use this when pricing info is needed,' but no direct guidance or comparison to siblings 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?

There are no annotations, so the description carries the behavioral burden. It discloses the response composition (difficulty plus three layers and mint count), but it does not explicitly state that the call is read-only or describe error behavior for an unknown/invalid miner. The 'Current' wording implies a query rather than a mutation, which provides partial 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?

One dense sentence front-loads the core result ('Current PoW difficulty') and fits the additional returned fields into a parenthetical. It is efficient and free of filler, though some jargon such as 'wave base' and 'load regulator' is not expanded.

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 tells an agent what the tool returns at a high level, which is enough to select and invoke it. However, with no output schema, it leaves the exact shape and units of the three layers and mint count unspecified, so it is not fully complete for interpreting the response.

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

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

Schema coverage is 100%, and the schema already documents the miner parameter as a 0x-prefixed EVM address. The description only echoes 'requiredBits(miner)' and adds no meaning beyond what the schema provides, so it sits at the baseline for well-documented 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 identifies the resource (a miner's PoW difficulty) and names the concrete returned quantities: requiredBits, the three layers, and wallet mint count. It is clearly distinct from sibling tools like get_token or price_info by being mining/PoW-specific, though it lacks an explicit fetch/read verb such as 'gets' or 'returns'.

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

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

The phrase 'Current PoW difficulty for a miner' implies when to use this tool: when an agent needs a miner's current difficulty parameters. However, there is no explicit when-not-to-use guidance or differentiation from PoW-adjacent siblings like verify_nonce or craft_info.

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 transparently states that the tool is read-only, reads on-chain commit data, recomputes the hash exactly as the contract does, and reports a match status plus additional fields. It does not mention error behavior (e.g., reverts for invalid commitId), which prevents a perfect score.

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 packs the core action, the non-transactional caveat, the exact computation, and the output contents into minimal words. No filler or repetitive phrasing is present, and every clause contributes useful 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?

Given the tool has no output schema, the description does a good job listing the returned data (match status, settlement flags, player, boost tier, reveal window). It does not cover edge cases such as behavior when commitId does not exist or invalid input handling, which would make it more complete, but for a read-only verification call it is largely sufficient.

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

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

Although the input schema already documents all parameters (100% schema description coverage), the description adds significant semantic value by explaining how the parameters interact: commitId selects the commit, while choices and salt are combined via keccak256(abi.encode(choices, salt)) in the contract's exact manner. This goes well beyond the baseline level.

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

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

The description opens with a specific verb ('Verify') and resource ('a crafting commit'), then immediately clarifies the non-transactional nature ('WITHOUT sending a transaction'), which distinguishes it from any mutation-style sibling. It further names the exact contract function (CraftingController.commits) and the verification computation, leaving no ambiguity about what this 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 explicitly states the tool verifies without sending a transaction, giving a clear context for when it should be used. It does not name sibling alternatives or provide explicit when-not-to-use conditions, but the non-transactional framing is a strong contextual cue that differentiates it from transaction-sending 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 provided, the description carries the full behavioral disclosure burden. It transparently discloses that no transaction is sent, that it reads on-chain workFor and requiredBits values, and that the check is performed locally. It does not specify the exact return value shape, which is a minor gap.

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

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

A single, dense sentence that front-loads the key differentiator ('WITHOUT sending a transaction') before explaining the mechanism. Every clause earns its place and there is no filler.

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

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

The core algorithm is explained, but there is no output schema and the description does not state what the tool returns (e.g., boolean, success object, or error behavior). Given no annotations and no output schema, an agent must infer the return contract, leaving a meaningful completeness 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 input schema already covers both parameters fully, giving a baseline of 3. The description adds value by explaining how each parameter is used: miner feeds workFor(miner, nonce) and requiredBits(miner), and nonce is the value being checked. This connects the fields to the verification logic beyond schema-level validation.

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

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

States a specific verb ('verify'), a clear resource ('mined nonce'), and the exact verification approach: reading workFor, counting leading zero bits, and comparing to requiredBits. The phrase 'WITHOUT sending a transaction' also distinguishes it from on-chain alternatives.

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

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

The description makes the usage context clear: this is a local, transaction-free verification, which implies it should be used when the agent wants to check a nonce without incurring gas or chain state changes. It does not name an explicit sibling alternative or give a when-not-to-use condition, but it is reasonably inferable.

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