DAEMON — on-chain generative art (8004 NONCE + KOINE)

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description's added value is enumerating what is returned (traits + owner), which matters since there is no output schema, but it offers nothing on auth, rate limits, or error behavior.

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

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

A single compact sentence that front-loads the core purpose ('traits + current owner') followed by the returned fields. No filler, though the parenthetical morpheme codes (R/B/T/L) are unexplained shorthand.

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?

Since there is no output schema, the description usefully enumerates the returned fields, which is the key information an agent needs. Remaining gaps are minor: no note on what happens for an out-of-range or non-existent token id.

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 a single parameter and 100% schema description coverage ('token id (0-23 for the genesis)'), the schema does the documentation work. The description only gestures at 'one KOINE token' without adding format, range, or lookup 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?

Names a specific resource (one KOINE token by id) and enumerates the returned traits: generation, morphemes, parent ids, seed, owner. It clearly reads as a single-item detail lookup versus the listing siblings, though it never names those siblings explicitly.

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

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

Usage is implied by 'one piece in detail' against siblings like koine_list_genesis and koine_provenance, but there is no explicit when-to-use statement or routing to an alternative. An agent can infer the intended case but gets no 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so safety semantics are fully covered by structured data. The description adds the useful fact that the collection is fully on-chain generative art on Ethereum L1 authored by agent DAEMON, but says nothing about freshness, caching, or whether supply/links are live values.

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, front-loaded with the field list. The second sentence is mildly redundant with the title but earns its place by supplying chain and authorship context.

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

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

With no output schema and no parameters, the description carries the return-value burden and does so by enumerating the fields returned. An agent knows what it will get; only live-vs-static behavior of the values is unspecified.

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

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

The tool takes zero parameters, so there is no parameter semantics burden to discharge; the baseline is 4. Nothing in the description misleads about inputs.

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 the resource ('KOINE collection overview') and enumerates exactly what it surfaces: name, total supply, artist agent DAEMON, contract address, chain, and links. That distinguishes it cleanly from siblings like koine_get_piece or koine_provenance, though it is a noun phrase rather than a 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?

There is no explicit when-to-use guidance, no mention of prerequisites, and no named alternative for the related metadata tools (nonce_info, koine_provenance). Usage is only inferable from the tool being a zero-argument overview.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so safety behavior is covered. The description adds that it returns the full set with parent/morpheme fields, but says nothing about volume, ordering, or whether it is unfiltered/paginated.

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

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

A single front-loaded sentence with no filler. It is appropriately terse for a no-argument list tool, though the trailing 'for discovery and composition' is soft padding rather than informative content.

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

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

For a zero-param, no-output-schema listing tool, the description naming the returned fields (id, generation, morphemes, parents) roughly substitutes for an output schema. The only real gap is lack of differentiation from koine_listings.

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?

Zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The listed return fields add a little orientation but are not parameter semantics.

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

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

States a specific verb ('List') and resource ('every KOINE piece') and enumerates the returned shape (id, generation, morphemes, parents). It does not distinguish itself from the similarly-named sibling koine_listings, so the agent still has to guess which listing tool to call.

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

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

The phrase 'for discovery and composition' only implies usage; there is no explicit when-to-use, when-not-to-use, or named alternative (e.g., use koine_get_piece for a single piece). Guidance must be inferred.

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?

Goes well beyond the annotations: it discloses the conditional return payload (live listings only when an OpenSea API key is configured), names the exact returned fields, identifies the listings as Seaport orders, and states the fulfillment prerequisite (a Seaport-capable wallet with funds). That is precisely the operational context a read-only annotation cannot convey.

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

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

Three sentences, front-loaded with what the tool returns, then the conditional payload, then the fulfillment path. No filler and no repetition of the title or annotations.

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 parameters and no output schema, the description carries the return-value burden itself and does so fully: it enumerates the always-present fields, the conditional listing fields, and the practical next step for acting on those listings. Nothing needed to call or act on this tool correctly is missing.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline for a parameterless tool applies. The mention of server-side API-key state is the only input-like condition and it is 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?

States a specific verb+resource (pieces currently for sale) plus the ordering (cheapest first) and the agent-facing goal (COLLECT). It is immediately distinguishable from koine_get_piece or the nonce_* tools by resource, but it never names its closest sibling koine_list_genesis, so the boundary between the two listing tools is left to inference.

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

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

Usage is only implied through the phrase 'so an agent can COLLECT' and the fulfillment note. There is no explicit when-to-use statement, no when-not (e.g. when you already hold a token id), and no pointer to koine_list_genesis as the alternative listing source, so the agent must infer the selection rule.

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

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

Annotations already declare readOnly, idempotent, openWorld, and non-destructive, so safety is covered. The description adds real value beyond that by disclosing the data source ('on-chain derivation graph') and the shape of the result (parents, ancestry, adoption), which matters with no output 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?

One dense sentence, front-loaded with the core concept (lineage) and followed by the returning fields. No filler or repetition of the title.

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

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

With no output schema, the description must describe returns, and it does adequately (parents, full ancestry, downstream adoption). It is complete enough to call correctly, missing only edge cases like what happens for a piece with no derivations.

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?

Single 'id' parameter is fully documented in the schema ('token id'), so baseline is 3. The description adds nothing about the id beyond what the schema provides — no format hints such as 'piece token id vs account id'.

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 resource (lineage of a KOINE piece) and enumerates what it covers: parents, full ancestry, downstream adoption. This clearly separates it from a generic piece getter like koine_get_piece, though it never names that sibling explicitly.

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

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

Usage is only implied — an agent can infer 'use this when you need ancestry/adoption data' but there is no explicit when-to-use, when-not-to, or routing to siblings such as koine_get_piece for plain detail.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and openWorld, so safety is covered. The description adds real context beyond them: that verification is performed on-chain against the digest committed at mint, and that it returns a self-contained answer in a single call.

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

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

Very short and front-loaded: the keystone framing and the call-and-return contract arrive immediately, followed by the return shape. 'One call, a trustable answer' has slight promotional flavor but conveys the no-follow-up guarantee.

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

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

With no output schema, the description does substantive work by naming the returned fields (canonical_ok, artist, digest, traits) and explaining what canonical_ok means. Field types and the traits structure remain undefined, but the trust semantics are conveyed well enough to call 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?

One required parameter with 100% schema description coverage ('token id to verify'), so the schema already carries the semantics. The description adds nothing about the id itself, which is the baseline-3 case when schema coverage is high.

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

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

States a specific verb and resource: calls the contract's on-chain verify(id) and returns a trust verdict. Clear enough to distinguish from a generic verify, but it never explicitly contrasts with the sibling nonce_verify, leaving the agent to infer which verify applies.

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

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

'THE KEYSTONE... One call, a trustable answer' implies this is the go-to verification entry point, but there is no explicit when-to-use or when-not-to-use guidance and no named alternative such as nonce_verify or koine_provenance.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive, open-world), so the bar is lower. The description adds genuine semantic context beyond the annotations: bands are UNCAPPED and emergent rather than designed, results are counts only, and data is read live from chain. It does not cover pagination or sampling completeness, which keeps it short of a 5.

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

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

Three sentences, front-loaded with the resource and scope, then the key semantic caveat (uncapped bands) and the return contract. No filler or repetition of structured fields.

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

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

For a read-only census tool with rich annotations and no nested parameters, the description covers what the tool computes and what it returns qualitatively. With no output schema, a sentence on the shape of the counts payload would fully close the gap.

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

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

Schema coverage is 100% and the limit parameter is already richly documented, including the 500 cap and the eth_call/RPC rate-limit rationale. The description adds nothing about the parameter, so the baseline of 3 applies.

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

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

States a specific verb+resource: the live distribution of minted 8004 NONCE pieces across difficulty bands, read from chain. It is clearly distinguishable from adjacent siblings like nonce_get_piece (single piece) and nonce_info (metadata). An agent can pick this over its neighbours without opening a schema.

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

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

Usage is only implied: this is the aggregate/census view, in contrast to the per-piece siblings. The clause 'Returns raw counts only — no interpretation' sketches what it is not for, but no alternative is ever named and no when/when-not condition is stated explicitly.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so safety is covered. The description adds genuinely new context beyond that: 'Every value is read live from the chain,' telling the agent results are uncached/fresh on-chain reads rather than snapshots. It stops short of noting rate limits or how stale or missing tokens behave.

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

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

Two sentences, no filler, with the subject (one token's full detail) front-loaded before the field list. The enumeration of fields is dense but earns its place since there is no output schema.

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

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

For a single-parameter read tool with annotations covering safety and no output schema, the description compensates by listing the returned fields and noting live chain reads. Nothing essential to invoking it correctly appears missing, though error/edge behavior for invalid ids is unaddressed.

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

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

Schema description coverage is 100%, and the schema already explains the id parameter including the '0-based; 0-20 are DAEMON's mined genesis' detail. The description adds nothing about the parameter, so the baseline of 3 applies when the schema carries the full burden.

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-plus-resource ('Full detail on one 8004 NONCE token') and enumerates what that detail comprises (seed, difficulty, band, rarity, owner, links), so the agent knows exactly what comes back. It distinguishes itself implicitly from list-oriented siblings like nonce_census, though it never names an alternative outright.

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

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

Usage is only implied: the phrase 'one piece' signals a single-token lookup versus a census or listing, which is enough for an agent to infer the use case. There is no explicit when-to-use/when-not statement or routing to a sibling 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds that the state is 'live' (dynamic) and explains the collection's mining-before-minting context, but does not disclose rate limits, authentication needs, or response behavior beyond the field list.

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

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

Two sentences, front-loaded with what the tool returns. The second sentence provides domain context about the collection and its mining process; it is relevant but not strictly about invoking this specific tool, keeping it from a 5.

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

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

No output schema exists, so the description appropriately lists the returned fields (minted count, price, mint status, supply remaining, canonical links). Annotations already cover the safety profile, making the definition complete for an agent to call this no-parameter read tool.

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

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

The tool has zero parameters and an empty schema, so there are no parameter semantics to document. Baseline score of 4 applies for zero-parameter tools.

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 resource (8004 NONCE collection) and enumerates the live metrics it returns (minted count, price, mint status, supply remaining, canonical links). However, it does not explicitly differentiate itself from siblings like nonce_census or nonce_get_piece, leaving sibling selection partly to inference.

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 context about the collection and mining prerequisite but offers no explicit when-to-use guidance, no conditions for choosing this tool over alternatives like nonce_census or nonce_mine, and no exclusions.

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

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

Annotations already declare readOnly/destructive/openWorld, so the safety profile is covered. The description adds substantial behavioral context beyond them: the nonce is bound to (chainId, contract, minter) and worthless to other addresses, the grind is deadline-bounded by a server-enforced 8s cap, and the best valid nonce is returned even on timeout.

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?

Front-loaded with the imperative and the core action, then binding constraint, then the deadline caveat. Dense but nearly every sentence earns its place; the 'DO THE WORK' opener is slightly theatrical but functions as emphasis.

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

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

No output schema exists, yet the description enumerates the return fields (nonce, work hash, leading-zero-bit difficulty, band) and the partial-result behavior. Combining that with the binding and timeout context, an agent has everything needed to call this correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description reinforces the critical semantic that minter must be the transaction sender (the proof is bound to it) and gives difficulty guidance that explains why targetBits above ~20 will time out on this server. That adds meaning beyond the schema field text.

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

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

States a specific verb and resource ('Grinds keccak256 to find a proof-of-work nonce valid for a specific minter address') and its role among siblings: it is the mining operation, distinct from nonce_verify, nonce_census, and nonce_mint_packet. An agent can tell immediately what it produces.

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

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

Explicitly says when to use it ('the only way to become eligible to mint an 8004 NONCE piece'), when not to use it ('for difficulty above ~20 bits, run the local miner script instead'), and warns to mine for the address that will actually send the transaction. Alternatives are named with the condition that selects 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?

Goes beyond the annotations (which already declare readOnly/idempotent/non-destructive) by disclosing key behavioral traits: it never touches a private key, re-derives and re-checks the proof before emitting, and reads the live price() so a bad nonce fails locally. These are genuinely useful failure-mode and safety disclosures not present in the structured fields.

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

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

Front-loads the core action and output shape, then layers safety and failure behavior. Dense but every clause carries information; no filler.

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

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

With no output schema, the description correctly compensates by describing the emitted payload ({to, data, value} plus wallet commands) and the failure behavior. Complete enough for an agent to call it, though the exact command/response format remains unstated.

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 nonce, minter, and slippageBps are all documented in the schema itself. The description only glancingly references the live price() read; the 200bps buffer/auto-refund semantics are already in the schema, so there's little added meaning.

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

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

States a specific verb and resource ('builds a ready-to-broadcast mint transaction from a mined nonce') and enumerates the exact artifact produced ({to, data, value} plus copy-paste wallet commands). This clearly separates it from nonce_mine (produces the nonce) and nonce_verify (checks it).

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 'from a mined nonce' and 'a bad nonce fails here instead of costing gas on a revert' imply this is the pre-broadcast step after mining, giving implicit sequencing. But it never explicitly says 'use after nonce_mine' or names when NOT to use it, so usage is inferred rather than directed.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and closed-world, so the safety profile is covered. The description adds a genuinely useful behavioral fact beyond them: the spec is static and needs no network, so it always answers — a reliability guarantee an agent can rely on.

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

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

Content list followed by the two highest-value facts (static/no-network, read-first) front-loaded with zero filler. Every clause earns its place by telling the agent what payload to expect.

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

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

With no output schema and no parameters, the description must convey what comes back, and it does — the enumerated spec sections. An agent knows the scope of the payload and when to consult it, so nothing needed for correct invocation is missing.

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

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

The tool takes no parameters, so there is nothing to disambiguate; baseline 4 applies. The description does not need to compensate for any schema gap.

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

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

Names a specific resource (the 8004 NONCE specification) and enumerates exactly what it contains: PoW rule and preimage layout, mint calldata, price curve, rarity derivation, selectors, and safety rules. This clearly distinguishes it from siblings like nonce_info, nonce_mine, and nonce_mint_packet.

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?

'Read this FIRST before mining or minting' gives explicit sequencing guidance tied to the nonce_mine and nonce_mint_packet siblings. It stops short of naming alternatives to use instead for other purposes, but the when-to-use condition is 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?

Annotations already cover read-only, idempotent, open-world, and non-destructive behavior. The description adds substantial behavioral context beyond that: it calls on-chain verification, performs an independent local keccak recomputation, compares the two, and returns both results plus a match verdict.

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 appropriately short and mostly front-loaded with the core mechanism. However, 'THE KEYSTONE' and 'Two machines, one truth' are rhetorical framing rather than operational detail, slightly reducing information density.

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

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

For a read-only verification tool with no output schema, the description compensates well by explaining the return components: chain answer, local recomputation, and whether they match. Combined with full schema coverage and safety annotations, it supplies what an agent needs to call and interpret the tool.

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

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

The schema has 100% description coverage for the single id parameter, so the baseline is 3. The description mentions id only incidentally and does not add format, range, or semantic detail beyond what the schema already 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 gives a specific verb and resource: verify a piece by calling the contract's on-chain verify(id) and independently recomputing proof-of-work. It clearly distinguishes the tool from a simple chain-only verification, but it does not name or compare against sibling tools like koine_verify or nonce_get_piece.

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

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

Usage is implied by the verification purpose and the trust-model framing, but there is no explicit when-to-use, when-not-to-use, or alternative-selection guidance. An agent can infer it is for verification, but not why it should choose this over other verify tools.

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