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

Beyond the annotations (which already cover readOnly/idempotent/openWorld), the description discloses the exact call order (eth_chainId, eth_getBlockByNumber latest, one eth_call), that a chain-id mismatch is reported before any call, the provenance (chain-read), and that sealing/append-authority is inherited from the contract rather than a local signature check. That is substantial behavioral context the structured fields do not carry.

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?

Information is dense and front-loaded, with the primary action stated first and supporting detail (input shapes, return, provenance) following. It is slightly overwrought with parenthetical variants, but nearly every clause carries distinct 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 one-parameter tool with a full output schema, annotations, and 100% schema coverage, the description supplies everything an agent needs: call semantics, input forms, the pre-call guardrail, and what the returned snapshot is for. Nothing material is missing.

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

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

Schema coverage is 100% and the schema itself documents the two union branches, so the baseline is 3. The description adds genuine meaning on top: it frames the two shapes as genesis-derived vs. explicit, notes the chainId is optional and checked pre-call, and clarifies rpcUrl sourcing. It does not restate field formats, which the schema already handles.

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 first sentence states a specific verb (read) and resource (the log's published accumulator from the univocity contract), with the exact RPC sequence used. This distinguishes it clearly from siblings like fetch_genesis and fetch_receipt, which fetch different artifacts.

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

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

It establishes the context in which the tool applies (split-view under known-accumulator, against the chain rather than the operator) and the two supported input shapes, plus the chain-id-mismatch guardrail. It does not explicitly name sibling alternatives or state when-not-to-use, so it stops 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?

Annotations cover the safety profile (readOnly, idempotent, non-destructive, openWorld), and the description adds substantive behavior beyond them: return encoding (CBOR, base64), that the bootstrap key is preserved for the verifier, the provenance ('fetched'), and the trust-root caveat about copies taken at check time. This is real context an agent cannot get from the annotations.

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

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

The endpoint is front-loaded, but the body is a dense, semicolon-chained run-on with cryptic boilerplate tags ('Provenance: fetched. Supports: sealing...') that are hard to parse. It is information-rich yet not cleanly 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?

With an output schema and full annotations present, the description still supplies the trust and capture context an agent needs to use the result correctly. Minor gaps remain around the cryptic 'Supports' tag and when a fresh fetch is legitimate.

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

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

Schema description coverage is 100%, so both logId and baseUrl are already documented in the schema; the description only embeds them in the URL template, adding no format or fallback semantics beyond what the schema states. Baseline 3 applies.

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

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

States a specific verb (GET) and resource (the forest's genesis document) plus the exact endpoint template, so the agent knows precisely what is retrieved. It is readily distinguishable from siblings like fetch_receipt or fetch_accumulator because it names the genesis document and its chain-binding contents.

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?

Gives concrete usage guidance: 'obtain it once, keep it, and pass it as bytes from then on,' with an explicit when-not ('A copy obtained at check time is not the genesis trust root as intended'). It does not name sibling tools as alternatives, so it stops short of the top band.

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/non-destructive/open-world, so the safety profile is covered. The description adds genuinely new behavioral context the annotations cannot: the return shape (base64 bytes plus verifier decoding), the 'Provenance: fetched' marker, and the trust caveat that a receipt is only the operator's claim. It does not discuss auth or rate limits, so not 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 dense sentences, front-loaded with the retrieval modes before the return shape and trust guidance. Every sentence carries information, though the cryptographic jargon and packed clause structure cost a little 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?

With an output schema present, the description needn't explain returns, yet it still summarizes them helpfully, and with rich annotations it focuses on the trust model. The main residual gap is not clarifying whether the two addressing modes are mutually exclusive or how conflicts are resolved, so not a perfect 5.

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 83%, so the baseline is 3, and the description goes beyond by framing the six parameters as two alternative addressing schemes and tying receiptUrl back to query_registration. It does not add per-field syntax detail beyond the schema, keeping it at a solid 4 rather than 5.

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

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

States a specific verb (GET) and resource (a receipt), and enumerates the two distinct input shapes: by receiptUrl or by the {baseUrl, bootstrapLogId, logId, massifHeight, entryId} tuple. It also names the sibling it works with (query_registration for the URL, verify_fetched_receipt for trust), so an agent can distinguish it from siblings without opening schemas.

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 that this tool 'supports: none on its own' and routes the agent to verify_fetched_receipt or its own trust root, which is a clear when-not and alternative. It is slightly less explicit about when to prefer receiptUrl over the tuple form, so it stops short of full when/when-not coverage.

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, so the safety profile is covered. The description adds the endpoint path, that the result is JSON, and a genuinely useful trust caveat — the self-description is only 'what the operator says about itself' rather than verified truth. It omits pagination/error behavior, but adds real context beyond the annotations.

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

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

Front-loaded with the concrete endpoint, then supporting facts in terse form. The 'Provenance: fetched' / 'Supports:' shorthand is slightly compressed jargon but each clause carries information; no filler sentences.

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 an output schema present, the description needn't explain return values, and the rich annotations cover the safety profile. Combined with a fully documented single parameter, an agent has what it needs to invoke this correctly; only the lack of alternative-routing guidance keeps it from a 5.

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 fully documents baseUrl including the FORESTRIE_BASE_URL fallback. The description only mirrors baseUrl via the {baseUrl} path placeholder and adds no syntax or semantic detail beyond the schema — the baseline 3 applies.

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

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

States a specific verb (GET) and resource (the /.well-known/scitt-configuration self-description), and enumerates what the resource contains (service id, base URL, supported algorithms). An agent can distinguish this config-fetch from the sibling fetch_receipt/fetch_genesis/fetch_accumulator calls without opening the schema.

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

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

It gives some orientation ('Supports: none of the four questions; this is what the operator says about itself'), which implies when it is relevant, but it never names an alternative tool or states a condition that selects this over a sibling. Usage is implied 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 cover the safety profile (readOnly, idempotent, openWorld, non-destructive), so the bar is lower; the description still adds single-shot semantics and the pending/retryAfterMs response branch. It doesn't discuss auth requirements or error cases, keeping it short of 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?

The endpoint and return shape are front-loaded in the first two sentences, and the no-polling rule is stated early. The trailing 'Provenance: fetched. Supports: none of the four questions' is meta-noise that doesn't earn its place.

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

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

An output schema exists, so return values needn't be re-explained, and the description still summarizes the two response branches plus the non-polling contract. Nothing critical for invocation is missing, though auth and failure behavior are 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%, so all four parameters, including contentHash as the hex sha256 of signed statement bytes, are already documented. The description restates contentHash without adding syntax or format detail beyond the schema, matching the baseline for fully-covered schemas.

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

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

States a specific verb, resource and endpoint shape (GET /logs/{bootstrapLogId}/{logId}/entries/{contentHash}) and what comes back: pending with retryAfterMs, or the receipt's URL and entry id. An agent can distinguish this from fetch_receipt, which retrieves the receipt itself rather than its locator.

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?

'Never polls: call again yourself if you want to' gives concrete retry guidance, and the return of a receipt URL (rather than the receipt) implicitly routes retrieval to a sibling. There is no explicit when-not or named alternative, 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?

Annotations cover the safety profile (readOnly, idempotent, non-destructive, openWorld), and the description adds real behavioral detail beyond them: the four verification questions, that 'not_answered_by_this_root is a real answer', that result fields are passed through unaltered, and that a genesis fetched in the same call is never the trust root. Return-shape disclosure partially overlaps the output schema, keeping this from 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?

Purpose and the trust-root enumeration are front-loaded, but the dense single-paragraph form with heavily nested parentheticals (the chain object grammar inline) makes it harder to parse than the content warrants. Every sentence carries technical weight, so little is wasted, but structure could be cleaner.

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 9-parameter tool with a nested trust union and an output schema, the description covers the hard parts (trust-root selection, chain vs byte roots, result composition) thoroughly. Minor elements like baseUrl and receiptUrl sourcing are left to the schema, which is acceptable given 89% coverage and an existing output schema.

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

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

Schema description coverage is 89%, so the schema already carries most parameter meaning (baseline 3). The description adds above-schema value by tying payload+entryId to the attribution answer and enumerating the trust-root shapes and the chain path, helping the agent map inputs to verification outcomes.

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 concrete compound verb+resource ('Fetch a receipt ... and verify it') and explicitly frames the fetch as being like fetch_receipt, letting an agent distinguish it from the plain fetch sibling. The scope is unambiguous: retrieve then cryptographically verify under a supplied trust root.

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 framing '(as fetch_receipt) and verify' implicitly routes agents who only want a raw receipt to fetch_receipt, and it gives a live condition ('Supply payload bytes and the entry id to have attribution answered'). It stops short of an explicit when-not statement, so it is strong context rather than full routing guidance.

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