Radix Community

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

readOnlyHint=true is consistent with "decodes ... and returns," and the description adds real behavioral context beyond the annotation: the WASM payload is deliberately excluded because it is "too large for the agent," and the connector reads it from disk. This discloses an out-of-band file dependency the annotation alone would not reveal.

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

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

Three tight sentences with the core action front-loaded, then the scope exclusion, then the sequencing instruction. 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?

Given a fully documented schema and a simple readOnly annotation, the definition covers inputs, the boundary (no WASM), and the return (the deploy_package call to run). Minor gap: it does not describe what the decoded value looks like or how the connector call is structured, but nothing essential to 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?

Schema coverage is 100%, so the schema already documents rpdHex, owner and network fully, including enums and defaults. The description re-characterizes rpdHex as a compiled .rpd Manifest SBOR but adds no format or syntax detail beyond the schema, 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?

States a specific verb (decodes) and resource (.rpd package definition / Manifest SBOR) and the output it produces (the value needed to publish a Scrypto package, plus the exact deploy_package call). This clearly distinguishes it from the other build_*_manifest siblings, which the agent can tell apart 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?

"Use this before deploy_package" gives explicit sequencing guidance, and the note that WASM is not handled here clarifies scope. It does not name when-not to use it relative to the sibling build_* tools, so it stops short of full routing guidance.

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

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

readOnlyHint=true is consistent with a tool that only assembles a manifest rather than executing anything, and the description reinforces this by framing it as building a request, not performing the transfer. The Stokenet-only network constraint is genuinely useful context beyond the annotations, though it says nothing about downstream sign/submit steps.

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

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

Three tight sentences: what it does, the network constraint, and the funding use case, all front-loaded with zero filler.

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

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

For a read-only manifest builder with a fully documented 2-param schema and no output schema, the description covers purpose, network scope, and usage. It could mention what the returned manifest is meant to be used with (e.g., signing/submission), but nothing essential is missing.

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

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

Schema description coverage is 100% and both parameters are documented with formats (account_tdx_2_…, en/es), so the schema carries the load. The description adds only the implicit notion of an account to fund, which the schema already conveys.

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 the manifest that requests free test XRD from the Stokenet faucet and deposits it into an account'), which is unmistakably distinct from siblings like build_validator_manifest or build_wallet_request. The Stokenet-only scope further sharpens its identity.

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 clear when-to-use guidance ('Use it to fund a test account before other transactions') and a hard constraint (Stokenet only — mainnet has no faucet). It doesn't name a specific alternative tool for mainnet users, but the exclusion is well articulated.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds real behavioral context beyond that: the token is created with owner=none and open transfers, and the initial supply is deposited into the supplied account. What it omits is the lifecycle point — that this only produces an unsigned manifest that must subsequently be signed/submitted, which an agent might misread as an executed state change.

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, no filler: the capability and its defaults come first, the deposit destination second, and the sibling routing last. Nothing is repeated from the schema or 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?

There is no output schema, so the description carries the burden of telling the agent what comes back and what to do next (a manifest to be signed/submitted, presumably via build_wallet_request or validate_transaction_manifest). It also never explains how the required 'locale' parameter affects output. With 9 required parameters and no return-value guidance, it is adequate but leaves a real 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%, so the baseline is 3 and the schema already documents name, symbol, divisibility, network, locale, etc. The description still adds meaning the schema does not: the defaults for ownership and transfer rules, and the fact that accountAddress is the recipient of the initial supply rather than, say, an owner address.

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?

Specific verb (builds) plus resource (transaction manifest for a new fungible token on Radix) with scope qualifiers (sensible defaults: owner none, transfers open) and the destination of the initial supply. It explicitly names the sibling it is not (build_nft_collection_manifest), so the agent can distinguish it 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?

Explicit routing: 'For NFTs use build_nft_collection_manifest; for advanced role setups send the user to the console create-token tool.' That gives both the alternate tool and the condition that selects it, going beyond the implied usage most tool descriptions settle for.

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

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

Annotations only carry readOnlyHint, so the description adds meaningful behavior: it renders, validates, and returns a manifest rather than submitting anything, and signing happens externally in the web console. It still says nothing about validation failure behavior or how missing/extra field values are handled.

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 covering render, validation, and the handoff to signing, with the template dependency folded in as a parenthetical. No wasted clauses.

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 four-parameter, fully-documented tool with no output schema, the description covers purpose, prerequisource, validation, and the next step for the returned artifact. Gaps are minor: no statement of failure modes or how template/values mismatches surface.

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 enums documented for locale and network, so the schema carries the burden. The description only references 'given field values' and the template, adding no syntax or constraint details beyond what the schema already states.

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 chain: renders a manifest template with given field values, validates it, and returns a signable manifest. That is clearly distinct from the fixed-purpose siblings (build_fungible_token_manifest, build_nft_collection_manifest), though the differentiation is implied by 'template' rather than stated 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?

Gives real workflow context: pull template ids and fields from list_manifest_templates, then sign the result in the web console. It does not spell out when to prefer this over the other build_*_manifest tools or what happens when values fail validation, so it stops short of explicit when/when-not guidance.

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

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

Annotations only declare readOnlyHint=true, so the description usefully adds that the manifest is built with sensible defaults (owner: none, transfers open) and that NFTs land in the given account. It does not explicitly say the output is an unsigned manifest requiring preview/signing, which would remove the mild ambiguity between 'builds' and 'creates'.

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: the first front-loads what is built and its defaults, the second handles the escape hatch to the console tool. 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 9-parameter builder with no output schema, the description covers the effect, the defaults and the fallback path, which is enough to invoke it correctly. It stops short of describing the returned manifest or the expected next step (preview/validate/sign).

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 every parameter (name, nfts, mintable, burnable, network, locale, accountAddress, iconUrl, description) is already documented in the schema. The description restates the NFT payload fields and defaults but adds no syntax or format detail beyond the schema, so 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 (builds) and resource (transaction manifest creating an NFT collection on Radix), plus the scope of what the manifest does (initial NFTs deposited into an account). It is clearly separable from the other build_* manifest siblings and from get_nft_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?

Gives an explicit routing rule: for custom data fields or advanced role setups, send the user to the console create-token tool. It does not contrast against build_fungible_token_manifest or build_manifest_from_template, but the boundary for this tool's supported subset of cases is clear.

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

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

With readOnlyHint=true already declaring the safety profile, the description adds real context beyond annotations: it resolves the owner badges the account holds, composes a single proof across all operations, rejects combinations 'the ledger would garble', and states the output is an unsigned manifest for the user to sign in their wallet. That is a meaningful disclosure of pre-signing behavior, though the refusal condition remains vague ('garble').

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

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

Three sentences, front-loaded with the core action and no filler. The middle sentence ('Refuses combinations the ledger would garble') is colorful but carries a real constraint; only the wallet-signing clause borders on the obvious.

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, and the description compensates by explaining that the return value is a manifest intended for user signing rather than for direct submission. Combined with the 100%-covered input schema and the badge/proof composition note, an agent has enough to call it correctly; the exact failure semantics of rejected combinations is the only notable 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% and the nested operations array is fully documented in-schema (kind enum, values shape, minItems, pointer to list_validator_operations), so the baseline is 3. The description adds only the aggregate notion of 'one or more validator operations' and does not clarify field-level semantics or the account/network roles 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?

Specific verb ('Builds') plus specific resource ('one transaction manifest out of one or more validator operations'), which cleanly separates it from the other build_*_manifest siblings that target tokens, NFTs, packages, faucets and templates. The scope (validator operations only) is stated up front, so an agent can route correctly 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?

Usage is implied by the resource ('validator operations') and by the schema's reference to list_validator_operations, but the description never states when to prefer this over build_manifest_from_template or when it should be avoided. No explicit prerequisites or alternatives are named, leaving the agent to 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?

With readOnlyHint=true already covering the safety profile, the description adds real behavioral value: it discloses the return payload (interaction JSON, fresh ROLA challenge when something is signed, the validation problems the wallet would reject, and the matching radix-connector call) even though no output schema exists. It omits permission/auth prerequisites and any rate or size limits, so it is strong but not exhaustive.

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 purpose is front-loaded in the first clause, followed by the scope enumeration and then the return/next-step sentence. The opening sentence is long and dense with the auth-mode list, but every clause carries information and there is no filler.

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

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

For a 9-parameter tool with nested objects, enums, and no output schema, the description covers purpose, request scope, and return contents adequately. Remaining gaps are minor — no explicit mention of error behavior beyond validation problems or of prerequisites relative to setup_wallet_connector.

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 baseline is 3, but the description adds cross-parameter meaning beyond the schema — e.g. that a request may ask for no address at all and that certain modes need a persona. This helps an agent reason about valid parameter combinations the flat schema does not spell out.

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 the exact schema-v2 wallet interaction a dApp sends to the Radix Wallet) and enumerates the request categories it covers. It also names the sibling verify_rola_proofs as the follow-up verification step, so an agent can place it in the workflow 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?

The enumerated auth modes and the note that a request may ask for NO address give clear context for when each configuration applies, and it points to verify_rola_proofs for the signed answer. It does not explicitly contrast with near siblings like setup_wallet_connector or check_signing_request, so no true exclusions are 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?

readOnlyHint=true already declares the safety profile, and the description reinforces it with 'Read-only Gateway query' while adding genuinely useful behavioral detail: it tells the agent what the call returns (required signers, who has signed, completeness). It omits rate limits, caching, or failure behavior for an unknown/incomplete request, keeping 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 short sentences, front-loaded with the core purpose, followed by the id example and the return contents. 'Read-only Gateway query' overlaps with the annotation but is a small redundancy at worst.

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 usefully summarizes the return payload, and the required inputs are fully covered by the schema. It is complete enough to call correctly, with only minor gaps around error/edge-case behavior.

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 required parameters and the optional docHash are already documented in the schema with pattern/format guidance. The description restates the requestId example but adds no syntax or semantics beyond what the schema provides, matching the baseline 3 for high-coverage 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 names a specific verb and resource ('Reads the on-ledger status of a Radix Seal signing request') and adds scope detail (lookup by id) plus expected output. It is clear enough to distinguish from verify_document_signature or verify_rola_proofs, though it never explicitly contrasts itself with those signing/verification 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?

Usage is implied rather than stated: an agent can infer you call this after a signing request exists to check its state, and 'Read-only Gateway query' signals the read-only context. There is no explicit when-to-use, when-not-to-use, or named alternative, so it stays at the minimum-viable level.

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?

readOnlyHint=true already tells the agent this is a safe read; the description adds genuinely new behavior: account conversions also return the compressed secp256k1 public key and a wallet-import QR payload, and it explicitly reassures that the payload contains only public data (never a seed phrase or private key). It stops short of describing failure modes for malformed or resource-form addresses.

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

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

Four sentences, purpose front-loaded, and the behavioral/security details are ordered after the core definition. The wallet-import rendering instructions are slightly operational rather than tool-defining, but they earn their place by telling the agent what to do with the output.

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 carries the return-value burden and does so: Babylon equivalent for both branches, plus public key and QR payload for accounts. For a 6-parameter, read-only conversion tool this is complete enough to call and interpret 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 description coverage is 100%, including enums for network and accountType, so the schema already carries the parameter meaning and the baseline is 3. The description adds no per-parameter detail beyond the account/resource distinction it already makes at the purpose 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?

States a specific verb (converts) and resource (legacy Olympia address), and explicitly distinguishes the two input forms it handles: 'rdx1… account or _rr1… resource'. An agent can tell this apart from siblings like inspect_address or resolve_vault_address without opening any 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?

Gives clear situational context: this is the legacy-wallet import path, and the returned string must be rendered as a QR (Settings → 'Import from a Legacy Wallet') to complete the import. It does not, however, name an alternative tool or state when-not to use it relative to siblings like inspect_address.

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 (readOnlyHint=true), so the bar is lower, and the description still adds real behavior: Scrypto vs Manifest SBOR is auto-detected from the prefix byte, and the return is human-readable text. It stops short of describing malformed-payload behavior or failure modes.

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, zero filler, and the core capability plus the auto-detection behavior are front-loaded. Nothing could be trimmed without losing 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 two-parameter read-only tool with no output schema, the description tells the agent what payloads are valid and what the output looks like (human-readable text). Only error handling and the practical size/round-trip use case are unstated, which are minor omissions.

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 the hex pattern and the network enum with the same 5c/4d prefix detail the description restates. The description adds no semantics beyond the schema, 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?

States a specific verb (decodes) and resource (hex-encoded SBOR payload) with concrete scope examples: component state, events, schemas. It is reasonably distinguishable from siblings like explain_manifest, though it never names an alternative to sharpen the boundary.

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 description — an agent can infer it should use this when it has a hex SBOR payload to read. There is no explicit when-to-use/when-not guidance and no sibling routing (e.g. explain_manifest vs decode_sbor).

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?

readOnlyHint=true already establishes this is a safe, non-mutating operation, so the description's burden is lighter. It adds the nature of the output (plain-language step-by-step narrative) and the supported locales, but says nothing about whether explanation is generated locally or via a model, whether errors are surfaced for invalid manifests, or how long/large manifests are handled.

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, zero waste: the first defines the transformation and its output shape, the second states the use case. The core action is front-loaded and the parenthetical list of explained elements is compact and informative.

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, fully schema-documented tool with no output schema, the description adequately covers what the tool does and roughly what it returns. It could go slightly further by noting behavior on malformed manifests or the relationship to validate_transaction_manifest, but nothing essential for 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?

Schema description coverage is 100%, with both `manifest` and `locale` (enum en/es, default en) fully documented in the schema. The description's mention of "English or Spanish" echoes the locale enum without adding syntax, format, or constraint detail beyond it, 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?

States a specific verb and resource: translating a Radix transaction manifest into a plain-language, step-by-step explanation, and enumerates the content types covered (withdrawals, deposits, proofs, component calls). This clearly distinguishes it from the sibling build_*_manifest, validate_transaction_manifest, and preview_transaction tools, which construct, check, or simulate rather than explain.

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?

"Use it to help the user understand what they are about to sign" gives a concrete usage scenario and a clear trigger. It does not name alternatives (e.g., validate_transaction_manifest or preview_transaction) or state exclusions, so it falls short of the explicit when/when-not guidance a 5 requires.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds useful return-shape context (fungible amounts, NFT local ids), which matters since there is no output schema, but it says nothing about pagination, ordering, or whether empty accounts return an empty 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?

A single sentence with no filler, and the resource (what is listed) is front-loaded ahead of the qualifier (held by a Radix account). Every clause earns its place.

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

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

With no output schema, the description correctly carries the burden of describing the return shape, and does so adequately for a two-parameter read tool. Minor gaps remain around pagination or result size for accounts holding many tokens.

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 address format examples and a mainnet/stokenet enum plus default already documented. The description adds no parameter meaning beyond the schema, 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?

States a specific verb ('Lists') and a precisely scoped resource: fungible tokens with amounts and NFTs with local ids held by a Radix account. The scope wording is strong enough to distinguish it from siblings like get_resource_holders or get_nft_data, though it does not name 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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as get_component_state or lookup_entity. Usage is only implied by the tool name and the 'held by a Radix account' phrasing.

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

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

Annotations only declare readOnlyHint=true; the description adds ordering semantics, the fact that the first page is usually sufficient, the scale risk ('accounts can have thousands of transactions'), and how the returned cursor is meant to be used. That is substantial behavioral disclosure well beyond the annotation.

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

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

Four short sentences, no filler, front-loaded with purpose and the anti-pattern warning before the sibling reference. Every sentence carries distinct guidance.

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 no output schema, the description covers what comes back (newest-first page plus cursor) and the paging contract, so an agent knows how to call it and what to do with the result. Nothing material is missing for this read-only list 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%, so address, network, limit and cursor are already fully documented in the schema, including that cursor fetches the next/older page. The description adds the 'newest first' framing but no syntax or format detail beyond the schema, so 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 and resource ('Transaction history of any entity'), enumerates the entity kinds (account, validator, component, resource), and fixes the ordering ('newest first'). It also explicitly distinguishes itself from get_transaction, so an agent can separate them without opening either 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?

Gives explicit when-to-use ('the first page already shows the most recent activity, which is what users almost always want'), an explicit when-NOT-to ('do NOT keep paging to the end'), and names the alternative tool for the single-transaction case. The condition that triggers further paging is spelled out.

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 (readOnlyHint=true), so the bar is lower. The description adds genuine context beyond that: it discloses the return content (functions/methods with argument names and types) despite there being no output schema, and explains the auto-resolution behavior for component addresses.

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

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

Two tight sentences with zero waste; the output definition is front-loaded and the calling convention follows immediately. Every clause carries 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?

With no output schema, the description compensates by describing what is returned, and annotations cover the safety profile. It is nearly complete, lacking only error/failure behavior for invalid addresses.

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 three parameters are already documented, including 'Ignored for component addresses' for blueprintName. The description restates the address/blueprintName relationship but adds little syntax or format detail beyond the schema, so 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+resource: returns the 'callable interface' of a component or package blueprint, specifying it lists every function/method with argument names and types. This clearly distinguishes it from state-oriented siblings like get_component_state or lookup_entity, though it never names an alternative 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?

The second sentence gives practical calling guidance (pass a component address, or a package address plus optional blueprintName), and notes the blueprint is resolved automatically. However, it offers no when-to-use vs. when-not guidance against siblings such as get_component_state or inspect_address.

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 readOnlyHint annotation already establishes this as a safe read, and 'Live decoded on-ledger state' reinforces freshness. The description adds the response contents (package, blueprint), but gives no error behavior, auth/permission notes, or data-volume context, so with annotations covering safety this lands at an adequate 3.

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

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

Two tight sentences, front-loading the primary purpose and appending the sibling routing note. 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 carries the burden of describing return values, and it does so by enumerating what the state includes plus the package/blueprint. Complete enough for correct invocation, though error and edge-case behavior 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%, so the schema fully documents address format and the network enum/default. The description adds nothing beyond that, which is the correct baseline when 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?

States a specific verb+resource ('Get decoded on-ledger state of a component'), gives concrete examples (oracle prices, pool reserves, configuration), and explicitly distinguishes itself from the sibling get_component_blueprint. An agent can tell it apart from get_component_blueprint without opening either 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?

Explicitly routes the agent to get_component_blueprint for callable methods, which is the most likely confusion given the sibling name. It does not, however, clarify when to prefer this over other state readers like get_validator_state or get_key_value_store.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds one genuinely useful behavioral fact: results are decoded to JSON. It says nothing about whether the full store is returned, size or pagination limits, or failure modes for malformed addresses.

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 core action. The second sentence is a slightly clipped fragment but carries real disambiguating information about the address prefix rather than padding.

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 read tool with readOnlyHint and full schema coverage, the description covers what the tool does and the shape of the output (JSON-decoded entries). With no output schema, a little more detail on completeness of the returned entries would be ideal, but nothing essential is missing.

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

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

Schema description coverage is 100%, so both parameters and the network enum are fully documented in the schema. The description reinforces the internal_keyvaluestore_… address format but adds no syntax or semantics beyond what the schema already provides; 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+resource ('Reads the entries of an on-ledger key-value store') and clarifies the domain concept as component internal storage. The closing note about where KVS addresses appear implicitly ties it to get_component_state, though it never names a 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 implied rather than stated: the note that 'KVS addresses appear inside component state' hints you arrive here via get_component_state, but there is no explicit when-to-use, no when-not-to-use, and no named 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?

readOnlyHint=true already establishes the safe-read profile, so the bar is lower. The description adds genuine value by disclosing the exact return content and the wallet-signing relevance (dApp definition + origin), which no structured field provides.

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 front-loaded sentences with no filler, and the content enumeration plus the usage clause each earn their place. It is dense but not padded.

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

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

With no output schema, the description compensates by enumerating what is returned (addresses, badges, dApp definition/origin), which is what an agent needs. Nothing essential for calling the 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?

There is a single parameter with 100% schema description coverage and a documented enum (mainnet/stokenet), so the schema already carries the full parameter meaning. The description adds no param-level detail beyond that, making the baseline 3 correct.

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?

It names a specific verb and resource (get canonical well-known network addresses) and enumerates the exact contents: XRD resource, faucet, native packages, system badges, plus the dApp definition and origin. This clearly distinguishes it from address-resolving siblings like inspect_address and resolve_vault_address.

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?

"Use it to fill manifest addresses without guessing" gives a clear, actionable context that ties it to the build_*_manifest siblings. It stops short of naming an alternative or stating when-not to use it, so it is strong but not exhaustive.

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 readOnlyHint annotation already establishes this as a safe read, so the bar is lower. The description adds the concrete contents of the response, which is genuinely useful given there is no output schema. It says nothing about freshness, caching, or whether stokenet lags mainnet, so there is room left.

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, and the most important identifier (Radix network) comes first. It is a fragment rather than a sentence, but nothing is wasted.

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

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

With no output schema, the description correctly compensates by listing the return fields, and the one input parameter is fully covered by the schema. It is nearly complete for a simple read tool; only usage context is absent.

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 single 'network' parameter is fully documented with an enum and default. The description does not mention the parameter at all, so the baseline of 3 applies since the schema carries this dimension entirely.

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 exact resource (Radix network status) and enumerates the specific data points returned: epoch, total XRD staked, active validator count, average APY, average uptime. This distinguishes it implicitly from granular siblings like get_validator_state or get_xrd_price, though no sibling is named 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?

There is no when-to-use guidance, no mention of prerequisites, and no routing to alternatives. The agent must infer from sibling names alone that this is the network-level aggregate rather than a per-validator view.

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?

readOnlyHint=true is consistent with the description, so the safety profile is already covered; the description adds non-annotation context in the form of the max-10-NFTs-per-call batching limit and the nature of the returned payload (local ids vs decoded traits/fields). It does not say whether listing a large collection's ids is itself capped or 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 that discloses both modes and the batch cap with no filler; every clause earns its place.

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

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

With no output schema, the description does the necessary work of characterizing both return shapes (list of local ids vs decoded traits/fields), which is enough to call it correctly. Minor gaps remain around pagination/listing limits and behavior for invalid or out-of-range ids.

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's own 'ids' description already says 'Omit to list the collection ids' and carries the maxItems: 10 constraint, so the description largely restates structured data. It adds no format or addressing detail beyond the schema example ("#1#").

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 verb and resource (explore an NFT collection) and spells out the two operating modes: list local ids when "ids" is omitted, decode on-ledger trait/field data when it is supplied. That is far more precise than the title 'Get NFT ids and data', but no sibling (e.g. get_resource_holders, list_claimable_stake_nfts) is named to anchor the boundary.

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?

"Without 'ids' it lists... with 'ids' it returns..." tells the agent exactly which input selects which behavior, which is real invocation guidance. It stops short of saying when to prefer this tool over sibling lookups such as get_component_state or list_claimable_stake_nfts.

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?

readOnlyHint=true already covers the safety profile, so the description is free to add the behavioral facts it does: results are network-wide, only committed transactions, and ordered newest first. It doesn't mention the 50-item cap or pagination, which are minor gaps against an annotated 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?

Two sentences, zero filler, and the core behavior (what you get, in what order) is front-loaded before the pointer to the sibling 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?

No output schema exists, so the description carries some of the return-shape burden; it says transactions are committed and newest-first but not what fields a transaction record contains. For a simple two-parameter list tool with full schema coverage, this is close to 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% – both network (enum, default mainnet) and limit (1-50, default 10) are fully documented in the schema. The description's 'network-wide' phrase aligns with the network parameter but adds no syntax or bounds beyond the schema, 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?

States a specific verb+resource (recent transactions), plus scope (network-wide), ordering (newest first), and status (committed). It is immediately distinguishable from the sibling get_transaction, which requires an intent hash.

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 routes the agent: use get_transaction with an intent hash to get the full breakdown of one of these results. That is a named alternative plus the condition that selects 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?

Annotations already declare readOnlyHint=true, so the safe-read profile is covered. The description adds return-shape context ('ordered by amount held, with the total holder count'), which is useful, but says nothing about how many holders constitute 'top', pagination, or empty-result 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 front-loaded sentence with zero filler; the verb and resource lead, and the return detail follows immediately. Nothing redundant or padded.

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 read tool with annotations covering safety and no output schema, the description conveys what is returned and in what order. The only gap is the unspecified size/pagination of the 'top' holder list.

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

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

Schema description coverage is 100%, with both network and resourceAddress documented in the schema, so the baseline is 3. The description's phrase 'any token or NFT collection' loosely hints at the resourceAddress scope but adds no syntax, format, or constraint detail 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?

States a specific verb (Lists) and resource (top holders of any token or NFT collection), plus ordering semantics and that the total holder count is included. No sibling tool returns holder distribution data, so an agent can distinguish this from get_component_state, get_account_balances, or lookup_entity 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?

The description never says when to reach for this tool versus alternatives such as get_component_state or lookup_entity, nor does it state prerequisites. Usage is only inferable from the resource it operates on; there is no explicit when/when-not 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?

The readOnlyHint annotation already establishes this as a safe, non-mutating operation, so the description need not restate that. It does sketch the response content (sections with URLs and descriptions), which is useful, but says nothing about caching, freshness, or how the locale changes output behavior. Adequate but thin on behavioral context.

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 with the tool's output front-loaded and the usage cue second; nothing is wasted. The phrase "Radix Community web" is slightly informal but still parses clearly.

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 low-complexity, single-parameter, read-only tool with no output schema, the description covers what it returns (sections, URLs, offerings) and when to reach for it. Only minor ambiguity remains about the exact response format (structured data vs. prose).

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 single locale parameter is documented in the schema with an enum and default, so the schema does the heavy lifting. The description never mentions locale at all, so it adds no meaning beyond the structured field — this is the baseline 3 case.

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

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

The description states a concrete deliverable: a map of the Radix Community site listing every section with its URL and contents. That distinguishes it from content-fetching siblings like read_radix_doc and search_radix_docs, though it never names those siblings directly. It is clear but does not explicitly contrast itself with them.

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

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

"Call it first when you need to know where something lives on the site" gives an explicit usage condition and positions the tool as a discovery/orientation step. It stops short of naming the alternative tools (search_radix_docs, read_radix_doc) or stating when not to use 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?

readOnlyHint=true already establishes the safe-read profile, and the description adds that it returns status, fee, timestamp, entities, balance changes and manifest. However, it does not mention behavior for non-existent or uncommitted hashes, nor any auth/rate considerations, so it only partially goes beyond the annotation.

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 identifying the resource and key, followed by a compact colon list of returned data. 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?

With no output schema, listing the returned fields (status, fee, timestamp, entities, balance changes, manifest) usefully fills the gap, and the parameters are fully covered by the schema. Only the absence of error/edge-case behavior 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%, with both network and intentHash fully documented in the schema. The description restates the txid_… format but adds no new syntax or constraint beyond the schema, 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?

States a specific verb (Fetches), resource (committed transaction), and key (intent hash/txid). The word 'committed' implicitly distinguishes it from preview_transaction and the recent/address transaction list siblings, though no sibling is named 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 'committed transaction by its intent hash', which signals you need a known txid rather than a filter, but there is no explicit when-to-use/when-not guidance or named alternative (e.g., get_recent_transactions, preview_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?

Annotations only declare readOnlyHint=true, so the description carries extra weight by disclosing what is actually returned: registration status, delegated-stake acceptance, fee factor, consensus public key, and the LSU/claim NFT resources. That is meaningful behavioral detail beyond the annotation, though nothing about errors or address-not-found behavior is covered.

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 the action and its returned fields, then rounded off with the use case. The enumeration earns its length because no output schema exists to convey those 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?

With no output schema, the description usefully enumerates the returned state and the readOnly annotation covers the safety profile, so an agent knows enough to call it. Minor gap: no indication of failure behavior for an unknown or non-validator address.

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, so the schema already documents the network enum and the validator_ address format. The description adds no format or constraint detail beyond that, which matches the baseline 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?

States a specific verb and resource ("Reads a validator from the ledger") and enumerates the state fields it exposes, which makes the scope of a single-validator read unambiguous. It does not explicitly contrast itself with the nearby list_validators or get_component_state siblings, so it falls short of a 5.

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?

"Use it to know the current state before proposing a change" gives an explicit usage context, which is more than implied guidance. It stops short of naming alternatives (e.g. list_validators for enumeration) or stating when not to use 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?

readOnlyHint=true already establishes the safety profile, so the description's main addition is the data source (CoinGecko) and that values are live. It does not disclose refresh cadence, caching, rate limits, or behavior when the upstream API is unavailable. Useful context beyond annotations, 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?

A single front-loaded sentence that names the source and then lists the payload fields. No filler, no 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 correctly takes on the job of enumerating returned fields, which is the key completeness requirement here. It omits only secondary details such as refresh interval or failure behavior, which are minor for a no-arg 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?

There are zero parameters, so per the rubric the baseline is 4. The schema description coverage is 100% and there is nothing for the description to compensate for.

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 (get XRD market data) and enumerates exactly what is retrieved: USD/EUR price, 24h change, market cap, circulating supply, TVL. This is unmistakably distinct from every sibling, which are all Radix node/network/manifest tools rather than market-data 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 never says when to reach for this tool, when not to, or what alternatives exist. For a zero-parameter convenience tool this is a mild gap, but no usage context is provided at all.

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 readOnlyHint=true already declaring the safety profile, the description adds genuinely new behavioral context: the operation is fully offline and issues no network calls, so there is no latency, rate-limit, or side-effect risk. It also discloses that checksum validity is reported rather than enforced, implying invalid input is handled gracefully.

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 constraint ('Offline') and then lists the outputs. Every clause earns its place; nothing is padding.

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, and the description compensates by stating what is returned (entity type, network, checksum validity), which is exactly what an agent needs. The lone parameter is fully documented, though error behavior for malformed non-bech32m input is not spelled out.

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 parameter with 100% schema description coverage ('Any Radix address or transaction id'), so the schema carries the semantics. The description slightly narrows scope to bech32m addresses, but adds no format, casing, or edge-case detail 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 verb and resource ('Offline analysis of any Radix bech32m address') and enumerates what it extracts: entity type, network, checksum validity. The 'offline / no network calls' framing implicitly separates it from network-fetching siblings like lookup_entity, but it never names an alternative, so it stops short of full sibling differentiation.

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/when-not guidance or named alternative among the many siblings (convert_olympia_address, resolve_vault_address, lookup_entity). The 'Offline... No network calls' phrase is only an implied selection cue — it tells the agent the tool is appropriate when a local, side-effect-free decode is wanted.

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?

readOnlyHint=true already declares this a safe read, so the description only needs to add context. It does so usefully by disclosing the shape and meaning of the returned data (per-validator attribution, redeemable XRD, maturity flag), which tells an agent why it would call this before a claim. Pagination or result-size behavior is not addressed.

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. The core scope (what is listed) is front-loaded, and the second sentence is purely actionable routing information. Every clause earns its place.

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

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

With no output schema, the description must convey the return shape, and it does name the salient fields an agent needs to decide whether to proceed to a claim. It leaves minor gaps: whether all NFTs are returned or the list is bounded/paginated, and what an empty result implies.

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?

Both parameters are fully documented in the schema, including the mainnet/stokenet enum and the account_… address format, so the schema carries the burden. The description adds no parameter-level detail (e.g., network defaults or address validation), which matches the baseline 3 when coverage is 100%.

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: it lists the stake claim NFTs an account holds, and goes further by naming the three attributes returned (minting validator, redeemable XRD, maturity). This is well beyond a tautology and is clearly distinct from generic siblings like get_nft_data or list_validator_operations, though it never explicitly contrasts itself with any of them.

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

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

Gives clear downstream context by naming the sibling and the intent: feed the matured NFTs to build_validator_manifest as a claim-xrd operation. That effectively describes the workflow this tool feeds. It stops short of stating exclusions, such as when to prefer get_nft_data or what to do with unmatured entries.

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 readOnlyHint=true already covering the safety profile, the description adds genuine value by disclosing the return shape (each tool plus its URL and whether it requires a connected wallet). It does not mention pagination, caching, or locale-dependent behavior, so it is not exhaustive.

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: the first front-loads what is returned, the second states the routing use case. Every clause earns its place.

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

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

For a read-only, single-param listing tool with no output schema, the description covers the essentials of what comes back and when to call it. It omits locale effects on the returned labels/links, a minor gap given the schema documents the 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 single locale parameter is fully documented in the schema, including its enum and default, so the description cannot add much. It never mentions locale or language behavior, making this the baseline 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?

States a specific verb (lists) and resource (every tool of the web developer console), and enumerates the categories covered (send transactions, staking, token creation, package deployment, metadata, SBOR decoding), which clearly separates it from the sibling API/query 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?

"Use it to route the user to the right console page" gives a clear context for invocation, so an agent knows this is a discovery/router tool. It stops short of naming when-not-to-use or an alternative tool, so it is not a full 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 already declare readOnlyHint=true, so the safety profile is covered. The description adds value beyond that by disclosing the return content shape - template categories plus 'the fields each one needs' - which is the key behavioral fact for a listing tool. No pagination or rate-limit behavior is mentioned, but a static template catalogue plausibly has none.

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

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

Two tight sentences, front-loaded with the resource and its coverage, then the routing instruction. No filler, and every clause earns its place.

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

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

For a one-parameter read-only listing tool with no output schema, the description covers purpose, content, and the natural follow-up tool, which is nearly everything an agent needs. Minor gaps remain: it does not describe the returned structure beyond field lists, nor note that locale changes the returned labels/links.

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 'locale' parameter is fully documented in the schema with its enum and default. The description says nothing about locale, so it adds no meaning beyond the schema; 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 and resource ('Lists the ready-made transaction manifest templates') and enumerates the concrete template categories covered (transfer, stake, mint, burn, faucet...). It distinguishes itself from the many build_* siblings by naming build_manifest_from_template as the renderer, so an agent can tell this is the discovery/listing tool.

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 routes the agent: 'Use build_manifest_from_template to render one,' which is a clear follow-up condition and separates this tool from all the build_* siblings. It does not state any when-not condition (e.g., that this is static and needs no prior setup), so it falls short of a full 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 already declare readOnlyHint=true, so the safe-read profile is covered and the description need not restate it. The description goes beyond that by disclosing the per-operation metadata returned (owner-badge requirement and transaction-sharing compatibility), which is genuine behavioral content. It does not mention pagination or caching, but for a static catalog listing that gap is minor.

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 sentence, front-loaded with the verb and resource, followed by the enumeration and the two returned flags. The long parenthetical list is dense but each item is an operation name the agent would otherwise have to discover; it earns its space, though it could be trimmed.

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 and does so: it names the operation set and the two boolean attributes per entry. An agent can decide to call it and interpret the result without further documentation.

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 to disambiguate and the baseline is 4. The description correctly implies a no-argument, full-catalog call rather than introducing filtering semantics that do not 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?

States a specific verb (Lists) and a precise resource (every operation a validator supports), then enumerates the operation set so the agent knows exactly what will be returned. It is clearly distinguishable from siblings like list_validators or get_validator_state, which operate on validators, not on the operation catalog.

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 usage timing: 'Use it before build_validator_manifest,' which names the downstream sibling and the sequencing condition. It does not state when not to use it or cover the other alternative paths, but the primary routing guidance 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?

With readOnlyHint=true the safety profile is already covered, and the description usefully adds sort order and returned fields. However, it is silent on pagination/truncation behavior (the 200 cap) and on whether the full validator set is always returned, which matters for a list 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?

Two short sentences, front-loaded with the core behavior, followed by the filter and the use case. 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?

There is no output schema, and the description compensates by naming the returned fields and the ordering, which is the key information an agent needs. It omits anything about result size limits or how to page beyond the limit parameter, leaving a small 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%, so network, limit and find are fully documented in the schema. The description only restates the find filter ("Filter by name or address with 'find'") and adds no syntax or interaction detail beyond it, 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?

States a specific verb+resource ("Lists the validators of the Radix network") and immediately scopes it with the ordering (stake rank) and the fields returned (stake, fee, uptime, APY). This clearly separates it from the single-entity sibling get_validator_state and from list_validator_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?

"Use it to answer questions about staking targets or a specific validator" gives an explicit use context, and the find-filter hint tells the agent how to reach the specific-validator case. It stops short of naming alternatives or when-not-to-use conditions (e.g., use get_validator_state for a single validator's 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?

With readOnlyHint=true already declaring the safe-read profile, the description still adds real value: it discloses the return shape (entity type, metadata, and a *summary* of details), which implicitly tells the agent this is a shallow generic read rather than a deep type-specific one. It omits any note on pagination, size limits, or error behavior for unknown addresses.

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 scope, then return shape, then the routing hint. No filler and nothing an agent needs is buried.

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 usefully compensates by naming the returned fields and flagging that details are a summary. It stops short of telling the agent where to go for full details of a component/validator, which is the one gap for a tool this broad.

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 both parameters are fully documented in-schema (Bech32m examples, network enum with default). The description adds no syntax, format, or constraint detail beyond what the schema already carries, 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?

Specific verb ('fetches the on-ledger state') plus explicit resource scope, enumerating every address family it covers (accounts, components, packages, resources, validators, pools). An agent can distinguish it from get_component_state, get_validator_state and inspect_address purely from the description.

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?

'For account token balances prefer get_account_balances' gives one explicit alternative with the condition that selects it. However, it is silent on the other heavily overlapping siblings (get_component_state, get_validator_state, get_nft_data, inspect_address), which an agent must disambiguate on its own.

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 readOnlyHint annotation already declares a safe read, but the description adds real value on top: it runs 'without any signature' (no auth/signing required) and returns execution status, fee, per-entity balance changes and engine logs. It does not mention rate limits or size constraints, keeping it below 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?

Two tight sentences, front-loaded with the core action and benefit, with the pre-signing workflow guidance placed last. 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?

With no output schema, the description carries the burden of describing returns and does so by naming execution status, fee, balance changes and engine logs. Combined with 100% schema coverage for inputs, an agent has what it needs, though a note on dry-run semantics vs. actual execution would round it out.

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 every parameter including blobs, network and locale is already documented in the schema; the baseline is 3. The description adds no syntax or format details beyond that (e.g. nothing on blob/manifest relationship), so it does not earn higher.

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 ('Dry-runs a transaction manifest on the Gateway') plus the notable constraint ('without any signature'), and even enumerates what it returns. However, it does not differentiate itself from the close sibling validate_transaction_manifest or explain_manifest, so an agent must still infer which one to pick.

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 clear workflow context: 'Always preview a manifest before asking the user to sign it,' which tells the agent exactly when in the flow to call this. It offers no explicit exclusions or named alternatives (e.g. when to prefer validate_transaction_manifest), 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?

readOnlyHint=true already tells the agent this is a safe read, so the description's added value is the disclosure that the entire page body is returned as Markdown and that content is locale-dependent. It does not address behavior on an invalid or stale docId, page size, or versioning.

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, zero filler, with the output format stated up front and the parameter-sourcing hint placed last. Every clause earns its place.

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

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

For a simple two-parameter read tool with no output schema, the description covers purpose, how to obtain docId, the return format, and the language dimension, which is enough to invoke it correctly. Only failure behavior for bad 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 both parameters carry their own descriptions plus an enum for locale, so the schema already does the work. The description only echoes the language option and the source of docId, adding no syntax or format detail 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?

States a specific verb (returns full content), resource (one curated documentation page), format (Markdown) and supported languages. The 'one page' scope plus the docId sourcing note cleanly separates it from the sibling search_radix_docs.

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 the prerequisite workflow explicitly: get valid doc ids from search_radix_docs. What is missing is any when-not-to-use guidance (e.g. don't use it to search or to fetch multiple pages) or a note that ids not from search will fail.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds genuine behavioral context beyond that: the one-vault-per-account/resource invariant and the conditional extra NFT-id output for non-fungibles. It omits what happens when the account does not hold the resource, but that is a modest gap for a read-only 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?

Three tight sentences, front-loaded with the core verb and resource, followed by the invariant and the downstream consumers. Every sentence 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 carries the return-value burden and does so for the main case (vault address) and the conditional case (NFT ids). It is complete enough to call correctly; only the not-found/empty behavior and any pagination or size caveats on NFT ids are 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 coverage is 100%, so the schema already documents account, resource, and the network enum and its default. The description adds no parameter-level syntax or format detail, so it sits at the baseline for a fully documented 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?

States a specific verb (resolves) and resource (internal vault address holding a resource in an account), and uniquely identifies itself among siblings — no other tool in the list resolves a vault address. It also adds scope detail (exactly one vault per account/resource) and a secondary output (NFT ids for non-fungibles).

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 clear context: it identifies the target a recall/freeze needs and names the four manifest templates that consume its output (recall-token / recall-nft / freeze-vault / unfreeze-vault). It stops short of explicit exclusions or naming an alternative tool, but there is no obvious competing sibling for this lookup.

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

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

Annotations declare readOnlyHint=true, so the safety profile is already carried. The description adds real context beyond that: results include document URLs, and there is a distinct list-all mode when query is omitted. It stops short of noting result limits or pagination, so it is 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?

Four tight sentences with no filler; the content scope is front-loaded and the listing mode plus sibling routing follow naturally. Every sentence 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?

With no output schema, the description usefully discloses that matches come with URLs, and it covers the listing fallback. Minor gaps remain around result volume/pagination, but the essentials for correct invocation are present.

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 "query" (free-text, omit to list all) and "locale" (en/es, default en) are already documented in the schema. The description's note about omitting query largely duplicates the schema, so 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?

Names a specific verb (Searches) and resource (curated documentation), and enumerates the covered content (whitepapers, Scrypto/developer guides, node & validator guides, DeFi concepts). It also distinguishes itself from read_radix_doc, which retrieves full content rather than search matches.

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 explicit operating conditions: call without "query" to enumerate all documents, and route to read_radix_doc to fetch full content. The when-to-use boundary against the sibling is stated, not 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?

Annotations only declare readOnlyHint=true; the description goes well beyond this by revealing that the tool returns installation/usage instructions rather than performing signing, that the local connector holds the wallet channel, and that the phone approves. This is exactly the kind of architectural context an agent needs and cannot infer from 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?

Three tight sentences, front-loaded with what the tool is before the when-to-call triggers. No filler, and each sentence contributes distinct information (purpose, architecture, invocation criteria).

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 convey that the response is explanatory content and clarifies the signing boundary. It could say slightly more about what the returned instructions contain (installer links, registration snippets), but it is complete enough for an agent 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?

Schema coverage is 100% with both parameters (os, client) fully described and enum-constrained, so the schema carries the semantics. The description adds no additional param syntax or format detail beyond what the schema provides, making the baseline 3 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?

States a specific verb (explains/installs) and resource (the LOCAL Radix signing connector, radix-connector-mcp), and explicitly distinguishes this tool from the stateless HTTP server that 'cannot sign'. An agent can tell this apart from build_wallet_request and check_signing_request without opening their 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?

Gives an explicit, concrete trigger list: 'Call this when the user wants to send/sign a transaction, stake, create a token, deploy, or log in with Radix.' It does not name a specific alternative tool for the non-signing cases, so it falls just short of full when-not/alternatives guidance.

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

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

Annotations only declare readOnlyHint=true, so the description usefully adds that validation is 'statically' performed via the Radix Engine Toolkit and that the exact parse error is reported on failure. It doesn't state the success response shape or whether oversized manifests are rejected, so it adds moderate value beyond the annotation.

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 well-formed sentence that front-loads the core action and ends with the failure behavior. No filler or repetition of the name/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?

For a simple two-parameter, annotation-covered validation tool with no output schema, the description covers the essential behavior including the error path. Only the precise success/return shape is left unstated, which 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?

Schema description coverage is 100%, with both parameters documented including the mainnet/stokenet enum. The description adds no syntax, format, or size guidance for the manifest string, so the schema does the heavy lifting — baseline 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?

States a specific verb ('Statically validates') plus resource ('Radix transaction manifest syntax') and names the implementing toolkit. It implies a distinction from execution-oriented siblings like preview_transaction, but never explicitly contrasts itself with them, so it stops short of a 5.

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 when-to-use guidance, no mention of alternatives (explain_manifest, preview_transaction), and no prerequisites. Usage must be inferred from the verb 'validates' alone.

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 readOnlyHint annotation already covers safety, so 'Read-only' is repeat credit; the real value is the disclosure of what the report contains: the controller's roles, its timed-recovery delay, and any recovery or badge-withdrawal attempt in flight. That is substantive behavioral context an agent could not infer from the schema or annotation alone.

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 core answer (who controls the account) before drilling into the badge/controller case. Every sentence carries information, though the parenthetical asides make it slightly heavy 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?

No output schema exists, so the description must convey the return shape, and it does: control type, badge placement (Access Controller vs. loose), controller roles, recovery delay, and in-flight recovery/withdrawal attempts. For a two-parameter read tool this is 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 only two parameters (address, network), both fully documented in the schema including the mainnet/stokenet enum. The description adds no parameter-level meaning, 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?

States a specific verb and resource: it 'reads from the ledger who actually controls a Radix account' (key/seed phrase vs. account owner badge). The scope is precise enough to separate it from generic siblings like inspect_address, lookup_entity, or get_component_state, which do not describe control/recovery posture.

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 domain (checking how an account is protected), but there is no explicit when-to-use statement and no alternative named, e.g. it never says 'use inspect_address for general account metadata' or 'use get_component_state for the controller component itself.'

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

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

Beyond the readOnlyHint annotation, it discloses what is actually checked (each signature against the shared payload, ROLA proofs and/or on-ledger chain of custody) and that it reports certificate completeness. It stops short of describing the report shape or failure semantics, but adds real behavioral context the annotation does not cover.

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

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

Three tight sentences, front-loaded with the verb and resource, then the internals, then the input boundary. No filler and every sentence earns its place.

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

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

For a one-parameter, read-only verification tool with no output schema, the description covers what is verified and that a completeness verdict is returned. It could do slightly more on expected failure reporting, but nothing essential for 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?

Single required parameter with 100% schema description coverage, so the schema already documents 'certificate' as the full .radixsig.json contents. The description adds no syntax, format, or size guidance beyond that, 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?

States a specific verb (verifies) and resource (Radix Seal document-attestation certificate / .radixsig.json contents), and pins the scope to the certificate rather than the document. It does not explicitly differentiate itself from the sibling verify_rola_proofs even though it mentions ROLA proofs internally, so it falls short of a 5.

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 artifact named (.radixsig.json certificate), and the 'receives ONLY the certificate, never the document itself' line draws a useful boundary. However, no when-to-use/when-not guidance and no alternative sibling (e.g., verify_rola_proofs) is named for related verification tasks.

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

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

Annotations only carry readOnlyHint=true; the description adds substantial behavior beyond that: it enumerates the exact checks performed (challenge/dApp-definition/origin signature, ledger owner_keys vs derived virtual address) and states that it 'Reports the reason for every failure'. It also discloses the anti-replay security requirement, which is critical operational context.

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 purpose, then input alternatives, then the security warning last, so the most important routing and safety information lands first. It is dense rather than padded, though the single long opening sentence carries several clauses that could be split 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?

For a read-only verification tool with no output schema, the description covers what an agent needs: what it verifies, the two ways to supply proofs, the origin/dApp-definition linkage, that failures report reasons, and the replay caveat. Nothing material is left undefined.

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 baseline is 3, but the description adds real meaning: it clarifies that proofs and wallet_response are alternate input forms ('every proof in it is found') and explains the security-relevant semantics of the challenge parameter. It stops short of field-level detail, which the schema already owns.

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 ('Server-side ROLA verification of the signed challenge proofs') and frames the exact trust decision a dApp backend must make. It is clearly distinguishable from siblings like build_wallet_request (which produces the challenge) and check_signing_request, and spells out the two things checked: signature over challenge + dApp definition + origin, and key-controls-entity via owner_keys or virtual address.

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 the two input routes ('Pass EITHER the raw wallet response ... OR proofs in the {type, address, proof} format') and names build_wallet_request as the source of the challenge. It also gives a strong when-not condition: never verify against the challenge inside the response, since that would accept a replayed answer.

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