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

No annotations are provided, so the description must fully disclose behavioral traits. It mentions 'Offline' and that it returns SARIF-lite findings, but does not state whether it is read-only, requires authentication, or any side effects.

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

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

Two sentences: the first clearly defines the action and output, the second adds context. Minimal waste, though 'THE MOAT' may be jargon. Efficient but could be slightly clearer.

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 an output schema existing (unseen), the description only mentions SARIF-lite findings. It lacks details on parameter usage, prerequisites, or error cases, leaving gaps for a tool with 7 parameters and no schema 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?

Schema coverage is 0% with 7 parameters. The description mentions 'CreateCode WASM (+ optional SetHook params)' implying wasmHex/wasmBase64 are inputs, but does not explain flags, grants, hookOn, namespace, or parameters. Partial compensation, but insufficient.

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

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

The description clearly states the tool performs static analysis on hooks using a security rule engine and returns SARIF-lite findings. It distinguishes itself as 'The first Hooks-specific analyzer' among many hook-related siblings.

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

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

No explicit when-to-use or when-not-to-use guidance is provided. The term 'Offline' implies no network dependency, but there is no comparison with alternatives like inspect_hook_wasm or hook_dry_run.

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

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

The description thoroughly discloses behavioral traits: decoding rules by byte-width, confidence levels ('definite' only for canonical XFL), that raw hex is always preserved, and that it is fully offline with no network calls. This is exceptionally transparent, especially since no annotations are provided.

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

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

The description is detailed but well-structured, starting with the overall purpose and then detailing decoding rules. While slightly lengthy, each sentence adds value and the information is logically organized. It could be slightly tightened without losing clarity.

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

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

Given the tool has a single parameter and no output schema, the description fully explains what the tool does, how it processes the input, and what the output will contain (e.g., decoded values with confidence). It covers all necessary behavioral aspects for an agent to correctly invoke it.

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

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

Schema coverage is 100%, but the description adds crucial semantic detail beyond the schema: it explains that each trace element is 'label: HEXVALUE', how each byte-width is interpreted (XFL float, int64, UInt32, Ripple-epoch date, account-id to r-address, tx/hook hash, raw blob), and that confidence varies. This is far more informative than the schema alone.

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

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

The description clearly states that the tool annotates the trace[] array from an execute_hook result, specifying its purpose of decoding hex blobs into human-readable formats. It uses a specific verb (annotate) and resource (hook trace), and is distinct from sibling tools which are about different aspects of Xahau.

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

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

The description implies that this tool should be used after execute_hook to decode trace output, but it does not explicitly state when to use it versus alternatives or when not to use it. No exclusions or alternative tools are mentioned, leaving usage guidance implicit.

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

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

No annotations provided, so description must cover behavioral traits. It states 'Read-only network + offline analysis', which clarifies safety. However, it omits details like performance implications for many hooks, error handling, or network dependency details.

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

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

The description is concise but lacks structure. It does not include parameter details or a clear breakdown of steps. While efficient, it is incomplete.

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 complex multi-step tool (fetch all hooks, retrieve each WASM, run analyzer), the description is too brief. It does not mention output format, analyzer behavior, or limitations. With no output schema, more context is needed.

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 0%, and the description provides no information about the parameters (address, network) beyond what the schema already gives. The description adds no value for parameter understanding.

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

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

The description clearly states the verb (Fetch, pull, run), the resource (every hook on an account, each HookDefinition's WASM), and the outcome (run analyzer over all). It distinguishes from siblings like get_account_hooks (list only) and analyze_hook (single analysis).

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

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

The description implies this is for comprehensive auditing but does not explicitly state when to use vs alternatives. No mentions of when not to use or alternative tools for simpler 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?

With no annotations, the description discloses key behaviors: pagination via marker, 20-page cap with truncated flag, and RPC reads. It implies read-only nature but does not explicitly state safety. Overall good transparency.

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

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

The description is concise at two sentences, front-loading the action and key features. Technical details are present but not excessive. Could be slightly more structured, but overall efficient.

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

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

Given the complexity of reading remarks from multiple objects and the existence of an output schema, the description covers main behaviors like pagination and decoding. However, it misses error conditions and network selection context, leaving some gaps.

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

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

The description has 0% schema coverage and fails to explain the network parameter or the account parameter beyond implicit context. It references a marker concept that is not a parameter, causing potential confusion. Compensation is insufficient.

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

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

The description clearly states the tool reads Remarks attached to an account's owned ledger objects, with hex-to-text decoding and immutable flag surfacing. It distinguishes itself from sibling tools like audit_account_hooks by focusing on Remarks and object annotations.

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

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

The description provides a use case (dynamic-NFT patterns and object annotations) but does not specify when not to use or offer alternatives. The context is clear enough for an agent to infer appropriate usage given the unique purpose.

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

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

With no annotations, the description carries full burden. It discloses that it does not sign, returns unsigned JSON and instructions, and defaults to testnet. No destructive or state-modifying behavior is mentioned, which is appropriate as it only assembles a transaction.

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

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

The description is a single concise sentence that includes all critical information: what it does, output format, that it never signs, and default network. There is no wasted text.

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?

While the description covers purpose and output, it lacks context on what a ClaimReward transaction is and how it relates to sibling tools like compute_reward and reward_status. No mention of prerequisites or error conditions, which is adequate but could be improved.

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 0%, so the description should explain parameters. It only mentions 'testnet by default' for the network parameter, but does not explain 'issuer' or 'account'. This is insufficient given the lack of schema descriptions.

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

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

The description clearly states it assembles an unsigned ClaimReward transaction and returns unsigned JSON with offline signing instructions. It distinguishes itself from sibling 'build_*_unsigned' tools by naming the specific transaction type.

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

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

The description does not provide explicit guidance on when to use this tool versus alternatives like compute_reward or reward_status. It only implies usage for building a ClaimReward transaction and notes it never signs.

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

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

Discloses key behaviors: returns unsigned JSON + preflight, does not sign, uses testnet by default, and notes prerequisite. With no annotations, description carries full burden and handles it well.

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 compact sentences plus note, front-loaded with purpose, no redundant information.

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

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

Covers input requirements, return format, prerequisites, and limitations. Lacks error handling or edge cases but sufficient for a transaction builder.

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?

Description clarifies key parameter roles (account = issuer, holder = target) beyond schema, and notes currency limitation. Schema coverage 80%, description adds value for the two key parameters.

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

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

Clearly identifies the tool as assembling an unsigned clawback transaction, specifying the issuer and holder roles, and distinguishes from sibling builders like build_payment_unsigned.

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?

Specifies prerequisite (clawback enabled), limitation (cannot claw native XAH), and behavior (never signs, testnet default). Lacks explicit alternatives but provides clear context for when to use.

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?

Discloses key behaviors: the tool never signs, defaults to testnet, returns unsigned JSON + preflight. It explains parameter ranges (repeatCount 0–256) and the meaning of startTime/startInSeconds. Given no annotations, this provides adequate transparency, though error handling is not 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?

Concise at 4 sentences, front-loads the main purpose, and every sentence adds value. No redundancy or unnecessary details.

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

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

Covers the main aspects: purpose, key parameters, return type, default network, and prerequisite. However, the return description ('unsigned JSON + preflight') is slightly vague, and more detail on output structure would improve completeness for a tool with no output schema.

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

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

Adds significant meaning beyond the input schema: explains startTime as Ripple-epoch seconds, startInSeconds as convenience for now+N, and clarifies that omit repeatCount for one-off. Compensates for schema parameters (like delaySeconds) that lack descriptions.

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

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

The description clearly states the tool's purpose: 'Assemble an UNSIGNED CronSet — schedule a Hook's future self-invocations.' It uses a specific verb ('assemble') and resource ('CronSet'), and distinguishes from sibling tools like build_sethook_unsigned by focusing on cron scheduling.

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

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

Provides clear context for use, such as the prerequisite ('account must have a Hook installed') and the cancel functionality ('set cancel:true for tfCronUnset'). However, it does not explicitly contrast with alternatives or specify 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?

With no annotations, the description carries full burden and discloses key traits: returns unsigned JSON + preflight, never signs, defaults to testnet, and mentions DeepFreeze amendment requirement. This adds value beyond the schema, though could mention the tool only assembles and does not submit.

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

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

The description is extremely concise—two sentences that front-load the main purpose and efficiently cover key behaviors (unsigned, never signs, testnet default). No wasted words.

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

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

For a tool with 6 parameters, no annotations, and no output schema, the description is adequate but leaves gaps. It does not explain what 'preflight' means, nor does it mention prerequisites like needing an existing trustline. Return format details are minimal.

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 description adds meaning beyond the schema by explaining the 'action' parameter's four possible values and their effects, and noting the 'network' default. However, other parameters (account, counterparty, currency, limitValue) are already adequately described in the schema.

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

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

The description clearly states the tool assembles an unsigned TrustSet to toggle a freeze on a trustline, using a specific verb 'assemble' and resource. It distinguishes itself from sibling build_*_unsigned tools by specifying the freeze action.

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

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

The description implies usage for assembling freeze transactions, listing action types. However, it does not explicitly state when to use this tool versus alternatives or when not to use it. No sibling comparisons are provided.

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

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

Discloses it is unsigned, irreversible, runs an internal readiness check, fails closed, and never signs. No annotations provided, so description carries full burden and handles it well.

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?

Every sentence adds value: step context, action, irreversibility, internal check, failure condition, signing behavior. No wasted words.

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

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

Covers purpose and preconditions well but lacks parameter explanations and expected return format (e.g., unsigned transaction blob). Adequate but has gaps.

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

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

Description does not explain the two parameters (account, network) despite 0% schema description coverage. Account is implied but not explicitly linked to the parameter.

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

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

The description clearly states it builds an unsigned AccountSet to disable the master key, and identifies itself as step 3 of the rotation wizard, distinguishing it from sibling build_* 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?

Explicitly states irreversibility and precondition that an alternative signer must exist; implies when not to use without naming alternatives.

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

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

With no annotations, the description carries the full burden. It clearly states the tool never signs, defaults to testnet, and returns unsigned JSON and offline instructions. This provides adequate behavioral disclosure for a non-destructive assembly 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?

Concise at 2-3 sentences with front-loaded action verb. Every sentence adds value: purpose, output format, and safety caveat. No wasted words.

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

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

Given the tool is a simple assembler with no output schema, the description covers key aspects: purpose, output type, network default, and safety. However, it misses explaining the account parameter's meaning and lacks mention of required fields beyond the schema.

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

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

Schema coverage is low (33%), and the description only adds minimal meaning for xpopBlobHex ('HEX-encoded XPOP'). The 'account' and 'network' parameters are not explained beyond default values, leaving ambiguity about their roles.

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

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

The description clearly states the tool assembles an UNSIGNED Import (Burn2Mint) transaction using a HEX-encoded XPOP, returns unsigned JSON and offline instructions, and never signs. It distinguishes from sibling build tools by focusing on import transactions and unsigned nature.

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

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

The description implies use for creating unsigned import transactions but lacks explicit when/why to use vs. alternatives. It mentions 'Never signs; testnet by default' but provides no comparison with other build_*_unsigned tools.

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

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

No annotations are provided, so the description carries the full burden. It states the tool does not sign ('Never signs'), returns unsigned JSON plus instructions and preflight, and defaults to testnet. This reveals key behavioral traits (no mutation, preflight validation, network default). It could be improved by explicitly stating it does not modify state or require special authorization, but it is still informative.

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

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

Two concise sentences containing all essential information. Front-loaded with purpose and key behavior. No extraneous words.

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

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

Given no output schema and 5 parameters, the description adequately outlines the output (unsigned JSON + offline signing instructions + payload preflight) and the default network. It could be more specific about the structure of the returned JSON or what 'preflight' entails, but it is reasonably complete for a tool among many build_*_unsigned siblings.

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 only 20% (only amountDrops has a description). The description adds minimal parameter context: it states amounts are in drops (which schema already indicates) and mentions offline signing instructions, but does not explain account, destination, or destinationTag beyond schema basics. Baseline for low coverage is that description should compensate; it does not sufficiently elaborate parameter meanings.

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

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

The description clearly states the action ('Assemble an UNSIGNED XAH Payment'), the resource (XAH Payment), and key attributes (amount in drops, returns unsigned JSON + offline signing instructions + payload preflight, never signs, testnet default). This distinguishes it from sibling tools like build_sethook_unsigned or build_claimreward_unsigned.

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 mentions 'Never signs; testnet by default,' which implies when to use (for preparing unsigned payments) but lacks explicit when-not-to-use or comparisons with alternatives. Sibling tools are not referenced, so guidance is limited to implied context from the tool name.

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

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

With no annotations provided, the description fully discloses behavioral traits: auto-creating missing trustlines, paying token reserves, creating destination account if absent, all-or-nothing execution, and returning unsigned JSON + preflight + offline signing instructions. It also clarifies it never signs and defaults to testnet.

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

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

The description is a single dense paragraph that conveys essential information without excessive verbosity. While it could benefit from bullet points for readability, it is efficient and front-loaded with the core purpose.

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

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

Given the tool's complexity (10 parameters, nested objects, no output schema), the description covers key aspects: purpose, behaviors, return type, and default network. It does not cover error scenarios or limits, but it provides sufficient context for an AI agent to understand and invoke the tool correctly.

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

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

The schema description coverage is 60%, so the description adds value by explaining high-level behavior (e.g., 'Optionally Inform a third-party hook' for the 'inform' parameter). It does not detail every parameter but provides context that supplements the schema. For example, it explains that amounts can be native or issued tokens.

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

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

The description clearly states the tool's purpose: assembling an unsigned Remit (XLS-55) for Xahau's atomic multi-asset push payment. It specifies the actions: sending multiple currencies, transferring URITokens, minting new URITokens, all in a single all-or-nothing transaction. This distinguishes it from sibling tools like build_payment_unsigned, which handles simpler payments.

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

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

The description implies when to use this tool: when you need atomic multi-asset push payments with auto trustlines and account creation. It explicitly states it does not support partial payments or pathing, guiding users away from those use cases. However, it does not directly compare to alternatives like build_payment_unsigned, which could be clearer.

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

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

With no annotations, the description carries full burden. It discloses the preflight analysis (analyze_hook with critical flagging), the return format (unsigned JSON + offline signing instructions), and the fact it never signs. This provides adequate transparency for an agent to understand the tool's 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?

Two tightly written sentences with zero waste. The first sentence captures the core action, preflight, and output; the second adds key constraints. Every word serves a purpose.

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

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

Given 10 parameters (2 required, nested objects) and no output schema, the description outlines the purpose and preflight but does not explain the relationship between CreateCode and parameters, nor the exact content of the output. It is functional but leaves gaps for a complex tool.

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

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

Schema description coverage is only 10% (only namespace is documented). The description mentions 'from CreateCode + params' but does not explain what CreateCode refers to or detail the role of parameters like wasmHex, createCodeHex, grants, etc. The agent would lack understanding of how these parameters interact.

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

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

Description clearly states the tool assembles an unsigned SetHook transaction, runs analyze_hook preflight, and flags critical findings. The verb 'build' combined with 'sethook_unsigned' precisely identifies the resource and action, distinguishing it from sibling build tools for other transaction types.

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 tool never signs and defaults to testnet, guiding safe usage. However, it does not explicitly contrast when to use this versus other build_*_unsigned tools, though the name makes the use case 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 no annotations, the description discloses that it returns unsigned JSON and signing instructions, and never touches secrets. It doesn't detail side effects, but the non-destructive nature is implied.

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

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

The description is two sentences plus a short post-instruction, front-loaded with the key purpose. Every sentence adds value.

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

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

Given no output schema, it sufficiently describes the return value and provides follow-up guidance. It covers the essential aspects for a build tool.

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

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

The description clarifies the 'regularKey' parameter (omit to remove), compensating for the schema's 33% coverage. However, 'account' and 'network' lack explanatory context beyond schema defaults.

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

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

The description clearly states 'assemble an UNSIGNED SetRegularKey' to assign or remove a regular key, and the context of 'ROTATION WIZARD step 1' distinguishes it from sibling build_* 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?

It provides clear context as the first step in key rotation, advises to never touch secrets, and recommends a test transaction after. It does not explicitly list when not to use, but the purpose is well-defined.

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

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

With no annotations, the description fully covers behavioral traits: constraints (max 32, unique names, byte limits), cost (+1 drop/byte), encoding (hex vs UTF-8), return value (unsigned JSON + preflight), and side effects (no signing). It also clarifies ownership requirements.

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

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

The description is concise, with two dense sentences covering the core purpose, constraints, and return. Both sentences earn their place without redundancy. Front-loaded with the main verb and resource.

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

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

Given the complexity of building a transaction with nested remarks, the description is complete: it specifies inputs, constraints, output format, and safety note (no signing). No output schema exists, but the description covers return value. No gaps identified.

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?

Despite low schema coverage (25%), the description adds significant meaning: it explains the remarks structure (name required, value omitted for delete, immutable flag), the hex encoding, and the purpose of each parameter (account as owner, objectId as target). This complements the schema well.

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

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

The description clearly states the verb (assemble/build unsigned), the resource (SetRemarks transaction), and the specific actions (attach, update, delete key-value remarks). It distinguishes from sibling build tools by specifying the transaction type and its purpose, such as powering dynamic NFTs.

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

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

The description provides clear context on when to use this tool (for remark management on owned objects or issued tokens) and notes that it never signs and defaults to testnet. However, it does not explicitly list alternatives or state when not to use it, though the sibling tools cover different transaction types.

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

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

No annotations provided, so description carries full burden. It discloses 'Never signs' and rejects unreachable quorum, but lacks details on what happens with invalid accounts or whether it returns a transaction blob. More behavioral context is needed.

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

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

The description is concise, front-loaded with purpose, and uses clear language. However, the informal 'ROTATION WIZARD alt' phrasing slightly reduces clarity.

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

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

Given 4 parameters, no output schema, and no annotations, the description fails to explain the return value (e.g., unsigned transaction blob) or usage workflow. Leaves significant gaps for the agent.

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 0%, but description only explains quorum=0 removal. The signers array, account, and network parameters are not described. Minimal compensation for lack of schema descriptions.

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

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

The description clearly states the tool's purpose: assembling an unsigned SignerListSet (multisig) transaction. It contrasts with disable-master and mentions safety for high-value accounts, distinguishing it from sibling tools like build_sethook_unsigned.

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

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

The description provides when to use (safer than disable-master for high-value accounts) and when quorum=0 removes the list. It warns against unreachable quorum. However, it does not explicitly list alternatives among the many build_*_unsigned siblings.

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

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

With no annotations, the description carries the full burden. It discloses that it reads server_info, uses a fixed endpoint (no arbitrary URLs), and performs 1 RPC read. This is sufficient transparency for a simple read operation, though it could explicitly state it is safe and non-destructive.

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

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

The description is two sentences with no wasted words. It front-loads the core purpose and adds necessary context about fixed endpoint and RPC count. Every phrase 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?

Given an output schema exists, return value explanation is not needed. The description covers the main output (amendment blocked, build version, ledger) and parameter. It is complete for a simple read tool with no annotations, though it could list the exact output fields for extra clarity.

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 0%. The description mentions 'this network' and 'network's fixed endpoint', implying the parameter selects the network, but does not explicitly describe the 'network' parameter or its enum values. While the parameter is simple, the description adds little beyond the schema's own definition.

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

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

The description clearly states it reports whether the configured RPC node is amendment blocked, along with build version and validated ledger. It specifies the verb 'report', the resource 'RPC node', and distinct condition 'amendment blocked'. This distinguishes it from sibling tools like xahau_server_info or get_amendment_status.

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

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

The description implies this tool is used to check if the node is too old to process transactions, but does not explicitly state when to use it versus alternatives like xahau_server_info or get_amendment_status. It mentions it reads server_info and uses a fixed endpoint, which gives context but lacks explicit usage boundaries.

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

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

No annotations are provided, so the description carries the burden. It discloses the heuristic, offline nature and that it does not execute bytecode, but does not detail input requirements or error behavior.

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

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

The description is a single sentence with a clarifying appendix, concise and front-loaded with the action. Minor redundancy 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?

Given an output schema exists, the description covers the tool's purpose and approach adequately, but fails to explain input parameters or when to choose this tool over siblings, leaving gaps for a functional understanding.

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 0% and the description does not explain the three parameters (hookOn, wasmHex, wasmBase64) at all, leaving the agent without guidance on how to provide input.

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

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

The description clearly states the tool infers the function of a Hook from its structure, listing example categories and specifying it is heuristic and offline, which distinguishes it from execution-based 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?

The description implies use for static analysis without execution, but does not explicitly state when to use this tool versus alternatives like analyze_hook or hook_dry_run.

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

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

No annotations provided, so description must bear full burden. It notes the tool is a legacy approximation but does not elaborate on constraints, side effects, or authentication needs. For a read-only computational tool, this is acceptable but not thorough.

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

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

Two concise sentences plus legacy and alternative notes. Every sentence adds value with zero waste.

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 6 parameters and no output schema, the description covers the main function, input modes, and legacy status. However, it omits the output format (expected reward) and does not clarify mutual exclusivity of inputs or essential parameter combinations.

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 0%, yet the description only groups parameters as 'reward fields' without explaining individual semantics. The meaning of balanceXAH, currentLedger, etc., is left to the user's assumed knowledge of the model.

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?

Clearly states the tool computes a reward using a documented time-weighted model, distinguishes from sibling reward_status by labeling itself as legacy.

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 when to use (for legacy approximation) and when to prefer reward_status instead. Also describes two input modes: direct fields or 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?

With no annotations, the description adds behavioral details: non-standard 160-bit codes pass through, and it works offline. However, it does not specify return format, input validation rules, or error handling, which would improve transparency.

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

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

Two sentences, no filler. The first sentence immediately states the core function, and the second adds important edge-case behavior. Every word 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?

Given the tool's simplicity (one parameter, no output schema), the description covers conversion direction, formats, and pass-through behavior. It is missing explicit mention of the return value, but the overall context is sufficient for a simple conversion tool.

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

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

The parameter 'input' is described in the schema as 'a 3-char code or a 40-hex currency', which is clear. The description adds nuance about non-standard codes passing through, enhancing understanding beyond the schema. Schema coverage is 100%, so the baseline is 3, but the extra context justifies a 4.

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 explicitly states the tool converts between 3-char ISO codes and 160-bit/40-hex currency formats, using specific verbs ('Convert') and resources ('currency'). It also distinguishes from siblings, as no other sibling tool performs currency conversion.

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

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

The description implies usage for currency code conversion but does not explicitly state when to use it or mention alternatives. Since no sibling tool overlaps, the lack of explicit guidance is acceptable but not ideal.

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

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

No annotations are provided, so the description carries the full burden. It states 'Offline' and lists input formats, but does not disclose error behavior, performance characteristics, or limitations. This is adequate but not thorough.

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

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

The description is extremely concise with two sentences, front-loading the verb 'Decode' and then specifying input formats. Every sentence contributes meaning without repetition or filler.

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

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

Given the tool's complexity (multiple input formats), single required parameter, and existence of an output schema, the description covers the essential input-output mapping. It could mention typical use cases or error handling, but is largely complete for agent invocation.

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 baseline is 3. The description adds significant value by specifying byte sizes (8-byte native, 48-byte issued) and the structure of the issued amount object {currency,issuer,value}, which goes beyond the schema's generic 'drops string, STAmount hex, or amount object'.

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

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

The description clearly states the tool's function: decoding amounts from native drops, serialized hex, or issued amount objects into normalized values. It specifies the resource (amount) and action (decode), and differentiates itself from sibling tools by its specific input types.

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

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

The description implies usage for offline decoding of amounts but does not explicitly state when to use this tool over alternatives or when not to use it. No comparisons to sibling decode tools are provided, leaving the agent to infer context.

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

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

No annotations provided, so description must disclose behavior. It says 'Heuristically classify' and 'Offline', but fails to explain what the heuristic entails, whether it is read-only, or any side effects. No mention of error conditions or assumptions.

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

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

Description is a single sentence, concise but too brief. It front-loads purpose but lacks any structuring or additional details. Could be expanded moderately without losing conciseness.

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 complex nested object parameter, no output schema, and no annotations, the description is severely insufficient. Agent has no guidance on input format, output expectations, or heuristic 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?

The single parameter 'tx' is a black-box object with no schema details. The description does not clarify what 'tx' should contain (e.g., transaction object, hex blob, JSON). With 0% schema description coverage, the parameter is entirely undocumented.

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

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

Description states the tool classifies a Burn2Mint-related transaction, specifying the verb 'classify' and resource 'Burn2Mint transaction'. It adds bridge direction context (XRPL↔Xahau) and offline nature. However, 'Heuristically' introduces ambiguity, and it doesn't distinguish from other decode tools like decode_tx_blob.

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

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

No guidance on when to use this tool vs alternatives. The only hint is 'Offline', implying no network calls, but no explicit when-to-use or when-not-to-use. Sibling tools include many decode functions, but no comparative advice.

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

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

With no annotations, the description fully discloses the tool is a pure decode operation, offline, and only for present values. Adds context about encoding but lacks explicit statement of no side effects.

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

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

Three concise sentences, each adding value: purpose, usage note, and offline status. No waste.

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 low complexity and good schema, description covers input and key behavior. Could briefly mention output type (set of transaction types) but acceptable as is.

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

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

Schema coverage is 100% but description adds meaning: explains it's a 256-bit bitmap and encoding similarity to HookOn, going beyond the hex string description.

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

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

The description clearly states the tool decodes a HookCanEmit bitmap into transaction types, and distinguishes it from siblings like decode_hook_on and encode_hook_can_emit.

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

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

Provides explicit guidance: use when the field is present; when absent, decoding is unnecessary. Also notes offline operation and encoding similarity.

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

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

With no annotations, the description carries full burden. It details the inverted/active-low encoding and active-high SetHook bit handling, and states it is offline. It lacks explicit safety or auth notes but covers key behavioral traits.

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

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

Two sentences, front-loaded with purpose, no superfluous words. Every part adds value.

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

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

Given the existence of an output schema, the description does not need to explain return values. It provides sufficient encoding context for a decoding tool, making it complete for the intended use.

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

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

The single parameter hookOn is described in the schema as 'HookOn hex (up to 64 chars)'. The tool description adds crucial context: it is a 256-bit bitmap with inverted encoding, going beyond the schema's minimal description.

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

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

The description clearly states the tool's action: decoding a HookOn 256-bit bitmap into transaction types. It includes specifics about encoding and offline operation, distinguishing it from siblings like encode_hook_on.

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 mentions 'Offline' to imply no network needed, but does not explicitly state when to use this tool versus alternatives like decode_hook_can_emit or encode_hook_on. No when-not guidance is provided.

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

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

Discloses it is offline and verified against canonical implementation, implying safety and determinism. No annotations exist, so description carries the burden well. Could mention error handling but reasonable.

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 concise sentences cover purpose, inputs, and verification. No wasted words.

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

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

Describes inputs and outputs adequately given single parameter and no output schema. Could specify return structure (object vs list) but fields are listed.

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 already describes parameter fully (100% coverage). Description adds no new parameter-level meaning beyond restating acceptable formats.

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

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

The description clearly states the tool decodes an Evernode lease URIToken URI and lists the exact output fields (lease index, amount, etc.), distinguishing it from siblings like decode_uritoken_id.

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 mentions acceptable input formats (hex, base64, raw buffer) and that it operates offline. No explicit contrast with alternatives, but the specificity makes usage 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?

No annotations are provided, so the description carries the full burden. It discloses the tool is 'Offline' (no network calls) and accepts both number and string inputs. It does not mention potential errors or limits, but for a simple mapping, this is sufficient transparency.

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

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

The description is two sentences, front-loaded with the core purpose and examples. Every word adds value with no redundancy or extraneous information. It is optimally concise for a simple 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?

The tool has no output schema, so the description should clarify the return format. The '⇄ its name' hint suggests bidirectionality but does not explicitly state what the tool returns (e.g., the corresponding name or number). For a tool with minimal parameters and no output schema, this omission leaves some ambiguity.

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 parameter 'result' is described in the schema as 'a result code number or name'. The description adds concrete examples (e.g., '0/tesSUCCESS'), which clarify the expected format beyond the schema's minimal description. This provides practical guidance for the agent.

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

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

The description clearly states the tool decodes transaction engine result codes between numbers and names, with specific examples like '0/tesSUCCESS'. This distinguishes it from sibling decode tools such as decode_hook_can_emit and decode_tx_blob, which handle different domains.

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

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

The description marks the tool as 'Offline', implying it is a safe, instantaneous lookup with no network cost. It does not explicitly state when to use it versus alternatives, but the tool's specific domain (transaction result codes) makes the distinction implicit among the many sibling tools.

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

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

No annotations provided; description only mentions 'Offline' for network independence. Lacks details on idempotency, authentication, or side effects. For a decode tool, read-only nature is assumed but not stated.

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

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

Single sentence packs core information (what, input, output, offline). No redundancy or superfluous words.

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

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

With no output schema and no annotations, description is thin. It does not explain the structure of hook definitions or behavior on invalid input. Sufficient only for basic understanding.

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 0%, so description adds value by naming 'JSON or tx blob' which maps to 'tx' and 'txBlobHex' parameters. However, it does not explain the difference, constraints, or which to prefer.

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?

Clearly states verb 'decode', resource 'SetHook transaction', and output 'hook definitions, each with HookOn decoded'. Distinguishes from sibling decode tools like decode_hook_on and decode_tx_blob by specifying the transaction type.

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?

Implies offline usage, but no explicit when-to-use, when-not-to-use, or alternatives. Could benefit from stating it is for decoding submitted or constructed SetHook transactions.

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

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

The description discloses the tool decodes offline (no network call) and produces transaction plus a summary and specific safety warnings (SetHook, AccountDelete, key changes, no-expiry, already-signed). In absence of annotations, this sufficiently conveys behavior without contradictions.

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

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

The description is a single focused sentence that conveys the core action, input types, output components, and safety context. No extraneous words; every phrase serves a purpose.

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

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

Given the output schema exists (not shown but noted), the description explains the return value (transaction + summary + warnings). The two parameters are adequately addressed. The tool's role among 80+ siblings is clear due to its unique focus on sign request decoding with safety warnings.

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 0%, so the description compensates by referencing the two parameters: txjson as 'Xaman/Xumm payload's txjson' and txBlobHex as 'raw tx_blob hex'. This adds meaning beyond the schema's empty property descriptions. While it doesn't detail formats, it gives enough context for correct use.

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

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

The description clearly states the tool decodes a sign request (specific resource: Xaman/Xumm payload or raw tx_blob) into a transaction and a plain-English summary with safety warnings. It distinguishes from siblings like decode_tx_blob and decode_sethook by emphasizing the sign request context and the human-readable output.

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

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

The description advises 'Offline — understand before you sign', indicating when to use it. While it doesn't explicitly exclude alternatives, the safety focus implies it should be used before signing. This provides clear context, though a note about when to use the simpler decode_tx_blob instead would improve score.

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

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

No annotations are provided, so the description bears the full burden. It discloses the tool is offline (no network call) and uses a specific codec, which is helpful. However, it does not mention any limitations, side effects, or that the operation is read-only.

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

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

The description is extremely concise—a single sentence that conveys the essential purpose and key behavior (offline). Every word earns its place with no redundancy.

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

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

Given the tool's simplicity (one parameter, no output schema), the description provides minimal context. It omits the return format and any constraints on the hex blob, leaving gaps for the agent.

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 0%, yet the description only implies the parameter is a hex string without detailing format, length, or validation rules beyond the schema's minLength. It fails to compensate for the lack of parameter documentation.

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

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

The description clearly states the action (decode), resource (Xahau transaction blob in hex), output (JSON), and mechanism (Xahau-aware binary codec). It also distinguishes the tool from siblings like encode_tx_blob by specifying decoding.

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

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

The description implies usage for decoding transaction blobs offline but does not explicitly state when to use this tool versus alternatives like decode_result or encode_tx_blob. No when-not guidance is provided.

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

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

With no annotations, the description carries full burden. It states the tool is 'not reversible offline,' which discloses a key behavioral trait. It also implies no side effects (offline, read-only). However, it does not describe error handling or return format, which would improve transparency.

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

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

The description is extremely concise (one sentence with a parenthetical) and front-loaded with the core action. Every word adds value; no redundant language.

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 decode tool with one input and no output schema, the description covers purpose and structure but omits what the output looks like (e.g., fields of the explained structure). It is minimally adequate but leaves ambiguity about the return value.

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 single parameter uriTokenId has 0% schema description coverage. The description adds only that it is a 'URIToken ID' to be validated, but offers no guidance on format, length, or examples. The parameter meaning relies entirely on the tool name and generic type.

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

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

The description clearly states the tool's action ('Validate a URIToken ID and explain its structure') and provides specific details about the resource (SHA512-Half of issuer||URI). This distinguishes it from sibling decode tools like decode_hook_can_emit or decode_tx_blob, which target different data types.

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 includes 'Offline' but does not specify when to use this tool versus alternatives like get_account_uritokens (which might list URITokens) or other decode tools. No explicit context about when to validate vs fetch or prerequisites is given.

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

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

With no annotations, the description bears full responsibility for behavioral disclosure. It clearly states the tool decodes (a read-only, offline operation), specifies inputs and outputs in detail (source ledger header, decoded BURN transaction, UNL validator set), and indicates it is offline. It does not cover error scenarios but is transparent about the core behavior.

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

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

The description is three sentences, each carrying essential information: purpose, accepted input formats, and output components. It is front-loaded with the core action and resource, with no extraneous or redundant phrasing.

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

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

Given the complexity (single parameter, straightforward decode) and the existence of an output schema, the description adequately covers what the tool does, what it accepts, and what it returns. The mention of 'Offline' is a helpful contextual signal. No additional information is needed for an agent to use this tool correctly.

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

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

The input schema provides a description for the single parameter 'xpop' (string or object), but the tool description adds context: it explains the relationship between the hex and JSON formats and identifies the XPOP as the proof blob. This additional semantic information helps the agent understand the parameter's nature beyond the schema.

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

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

The description clearly identifies the tool's purpose: decoding an XPOP (Xahau Proof of Payment) blob from Import/Burn2Mint transactions. It specifies the unique resource ('XPOP') and action ('decode'), distinguishing it from sibling tools like decode_tx_blob or decode_b2m.

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

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

The description implies usage when you have an XPOP blob ('Accepts the Import Blob hex... or the XPOP JSON'), but it does not provide explicit when-not to use or contrast with similar decode tools among siblings. No alternatives or exclusions are mentioned.

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

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

With no annotations, the description fully discloses behavior: it's a read-only RPC call that decodes chain data without re-execution. It explains what it decodes (failure codes, rollback strings, partial payments) and what it doesn't (no replay). No contradictions.

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

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

The description is dense but well-structured, starting with the core question and then listing features. Every sentence adds value, though it could be slightly trimmed without losing clarity.

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

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

Given the complexity of diagnosing failed transactions and the presence of an output schema, the description comprehensively covers all aspects: failure codes, rollback decoding, partial payment trap, and not-found triage. No missing context.

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

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

Schema description coverage is 50% with basic descriptions for both params. The description does not add new semantic detail beyond the schema, but the schema already provides adequate info (txHash required, network enum with default).

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

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

The description clearly states the tool's purpose: providing plain-English diagnosis for failed transactions using on-chain facts. It lists specific features (decoding hook rollbacks, partial payment trap, not-found triage) and distinguishes itself from sibling 'hook_execution_postmortem'.

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

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

The description implies when to use (when a transaction fails or has issues) and explicitly says not to use for re-execution, directing to a sibling tool. However, it could be more explicit about exclusions (e.g., for very new transactions).

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

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

No annotations are provided, so the description carries full burden. It mentions '2 RPC reads,' indicating the tool performs two network calls and is likely read-only. It also notes that amendments are compared 'by name where known,' acknowledging potential gaps. No contradictions.

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

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

The description is concise with three sentences: purpose, use case, and efficiency. No unnecessary words or redundancy. Every sentence adds value.

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

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

Given the presence of an output schema (not shown but indicated), the description need not detail return values. It covers purpose, use case, and number of RPC calls. Missing details like output format or edge cases are minor gaps.

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

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

Schema description coverage is 0%, and the description does not elaborate on the parameters beyond the example 'mainnet vs testnet.' It does not explain the default values or behavior when both networks are the same. The schema's enum values provide the main meanings, but the description adds little.

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

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

The description clearly states it diffs enabled-amendment sets between two networks, listing what is enabled on one but not the other. It references specific networks (mainnet vs testnet) and explains why a transaction or Hook feature works on one network but not the other, distinguishing it from siblings like get_amendment_status.

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

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

The description gives a use case (explaining why a transaction/Hook feature works on one network but not the other), but does not explicitly state when to use this tool versus alternatives, nor does it mention when not to use it. The usage context is implied but not fully 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?

No annotations provided, so description fully responsible. Declares 'Read-only', signaling no mutation. Explains what it checks and returns. However, does not explicitly state it does not modify state beyond 'Read-only', which is sufficient.

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 purpose and context. Minor jargon ('ROTATION WIZARD gate') but not excessive. No wasted words.

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

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

No output schema, so return values are described (safeToDisable, proven, reasons). Tool purpose, prerequisite, and read-only nature covered. Missing parameter documentation for network and lack of return structure details limit completeness. Adequate for a pre-check tool but not exhaustive.

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 0%. Description mentions 'this account's master key' implying the 'account' parameter, but never explicitly describes it or 'network'. The network parameter with enum (mainnet/testnet) is completely unaddressed. Agent may infer account but not network.

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

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

The description clearly states the tool's purpose: checking safety of disabling master key by verifying alternative signer existence. It specifies the checks (regular key signed, signer list exists) and return values (safeToDisable, proven, reasons). Distinguishes from sibling build_disable_master_unsigned by saying 'Run this BEFORE'.

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

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

Explicitly says 'Run this BEFORE build_disable_master_unsigned', providing clear ordering relative to a sibling tool. Also labels it a 'ROTATION WIZARD gate', implying it's a prerequisite check.

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

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

No annotations exist, so the description must convey behavior. It states 'Offline' (no network) and that output is hex. However, it does not disclose error handling, validation of input types, case sensitivity, or expected output format beyond 'hex'. This leaves significant gaps for the agent.

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

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

The description is two sentences with no wasted words. It front-loads the core purpose and adds a key behavioral detail (omit to allow all) succinctly.

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

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

Given no output schema, the description could better explain how the hex is used (e.g., in SetHook transactions) and provide an example. It mentions 'SetHook' and 'offline', but lacks integration context or post-encoding steps.

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 a minimal description ('e.g. ["Payment","Remit"]'). The description adds context: 'list of transaction types a hook should be allowed to emit' and mentions encoding similarity to HookOn. This is helpful but could specify valid values or format more precisely.

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

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

The description clearly states the tool builds a canonical hex for the HookCanEmit field from a list of transaction types. It mentions the amendment and similarity to HookOn. However, it does not explicitly differentiate from sibling tools like encode_hook_on or decode_hook_can_emit.

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

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

The description gives a single conditional: 'Omit the field entirely... to allow emitting anything.' This provides a when-not-to-use case. But it lacks comparison to related encoding tools or guidance on when to use this vs encode_hook_on.

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

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

With no annotations provided, the description carries full burden. It states 'Offline,' suggesting no side effects or network calls. However, it does not explicitly confirm the tool is read-only or purely computational, missing a chance to disclose behavioral traits beyond the schema.

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

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

The description is a single sentence with no unnecessary words. It efficiently conveys the tool's purpose and an important behavioral hint ('Offline').

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

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

Given the tool has an output schema (likely describing the returned hex), the description adequately covers input and core functionality. It explains input (list of tx types), purpose, and offline nature. A small improvement would be noting the hex format, but the output schema fills that gap.

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

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

Schema coverage is 100%, and the schema already provides an example for txTypes ('e.g. ["Payment","Invoke"]'). The description adds minimal semantic value beyond restating 'list of transaction types.' Baseline 3 is appropriate.

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

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

The description clearly states the tool builds a canonical HookOn hex from a list of transaction types. The verb 'Build' and resource 'canonical HookOn hex' are specific, and the purpose distinguishes it from sibling decode_hook_on and other encoding tools.

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

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

The description includes 'Offline,' implying no network is needed, which guides when to use. However, it lacks explicit alternatives or when-not-to-use guidance. The purpose is clear enough for basic usage but could be more directive.

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

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

No annotations are provided, so the description must disclose behavior. It correctly notes the tool does not sign and is offline, but does not mention other traits like being read-only, safe, or side-effect-free. The information is adequate 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 description is a single sentence that is both concise and front-loaded with the core action. Every word serves a purpose, with no redundancy.

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

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

Given no output schema and minimal annotations, the description covers the basic purpose and usage context. However, it lacks details on the output format, constraints, or potential errors. It is adequate but not fully comprehensive.

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

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

The schema has 0% coverage for parameter descriptions. The description only states the parameter is a 'transaction JSON', which adds minimal meaning. It does not specify required fields, structure, or examples. More detail is needed.

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

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

The description clearly specifies the verb 'encode', the input 'transaction JSON', the output 'UNSIGNED Xahau binary blob', and the usage context 'for inspection/round-trip; never signed. Offline.' This distinguishes it from sibling tools like decode_tx_blob and build_*_unsigned.

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 states 'for inspection/round-trip; never signed. Offline.' which implies when to use (inspection, round-trip, offline) but does not explicitly mention when not to use or name alternatives. The context is clear but lacks explicit exclusion criteria.

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

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

No annotations exist, so description carries full burden. It discloses that results are estimates (not exact on-ledger fees), that the static instruction count is an upper-bound proxy, and that the tool operates offline. It does not mention destructive effects (none assumed) or auth requirements, but overall is transparent about its behavioral limitations.

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

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

Extremely concise: two sentences covering purpose, what it outputs, and a key caveat. No wasted words, front-loaded with the verb 'Estimate'. 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?

Given no output schema, the description adequately describes output (byte size and static instruction count) and notes it is an estimate and offline. It covers the main purpose and limitations. Could be improved by mentioning that it returns numeric values or typical error cases, but overall is complete for a simple estimation 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 0%, so description must compensate. It mentions 'from its WASM' but does not explain the two parameters (wasmHex, wasmBase64) beyond their names. It fails to clarify that only one should be provided, or describe acceptable formats/constraints. Adds minimal value over parameter names.

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

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

Clearly states it estimates cost signals (byte size and static instruction count) from a Hook's WASM. It distinguishes itself as an ESTIMATE and offline, differentiating from on-ledger fee tools. However, it does not explicitly name sibling tools like 'estimate_hook_state_cost' or 'simulate_hook_trigger' as alternatives, which would strengthen clarity.

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

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

Provides clear context: it is an estimate and offline, and notes that the on-ledger execution fee depends on the actual executed path. This implies it should not be used for exact fees. However, it does not explicitly list when to use this tool versus specific sibling tools or state when-not-to-use scenarios.

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

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

No annotations provided, so description must disclose behavior. It states computation is offline, returns per-entry capacity, reserve units, overflow warnings, and minimum scale. It does not mention if any network calls are made, but 'offline' implies local computation. Good but could explicitly note no side effects.

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

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

Four sentences with no waste. First sentence states purpose, second and third explain outputs, fourth gives implementation tip. Front-loaded and easy to parse.

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

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

Describes return values (capacity, units, warnings, min scale) adequately without output schema. However, lacks explicit return structure (e.g., object fields), but enough for an AI to infer usage. Sibling tools provide contrast.

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?

Description adds meaning for all 3 parameters: explains 'scale' range (1–16), 'entries' as objects with valueBytes (size in bytes), and 'ownerReserveIncrementXah' for optional XAH conversion. This goes beyond the schema, which only describes one parameter.

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

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

Description clearly states it computes owner-reserve cost of Hook State entries under ExtendedHookState, using specific verb 'Compute' and resource 'owner-reserve cost'. It distinguishes from sibling tools like 'estimate_hook_fee' by focusing on state entries.

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

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

Provides clear guidance on when to use: given value size and scale, returns cost info. Also specifies optional parameter to get XAH figure. However, no explicit when-not-to-use or alternatives are mentioned beyond the tool's scope.

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

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

No annotations are provided, so the description carries the full burden. It clearly states the tool is read-only and explicitly warns that it performs ~9 serial RPC reads, making it slow but thorough. This exceeds typical transparency.

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

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

The description is a single paragraph of moderate length, front-loading the purpose. It is dense but not verbose, though it could be slightly more structured (e.g., bullet points) for easier scanning.

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

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

Given the tool's complexity and the presence of an output schema, the description adequately covers the checks performed, read-only nature, and performance characteristics. No gaps are apparent for the intended troubleshooting use case.

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

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

The input schema has two parameters, but only 'address' has a description ('host r-address'). Schema description coverage is 50%, and the description adds no additional parameter details beyond what is in the schema, so it does not compensate for the missing schema description for 'network'.

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

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

The description clearly defines the tool as a 'one-call health check for an Evernode host' and enumerates specific checks (registration, heartbeat, instance load, etc.), making it distinct from sibling tools which focus on accounts, hooks, transactions, or other features.

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

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

The description implies usage for host troubleshooting and mentions read-only behavior, but does not explicitly state when not to use or provide alternatives. Among siblings, it is uniquely positioned for host diagnostics.

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

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

The description discloses key behavioral traits: it runs real bytecode (not faked), records unsupported API calls with fidelity LOCAL_VM, and does not require a xahaud node. Given no annotations, this provides sufficient transparency for safe invocation, though it could mention the simulation's accuracy limits or performance characteristics.

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

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

The description is a single dense paragraph with a marketing introductory word 'GROUNDBREAKING', which adds minimal informational value. It conveys necessary information but could be more structured (e.g., bullet points) and remove hyperbolic language to improve conciseness.

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 14 parameters, an output schema, and no annotations, the description covers the tool's purpose, inputs (simulated transaction and ledger state), and outputs (decision, return code, state writes, emitted txns, execution trace). It lacks explicit mention of parameter defaults or required fields but is sufficient for an informed agent to understand the tool's scope.

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 57%, with some parameters like state and txType described in the schema. The tool description adds overall context (simulating transaction and ledger state) but does not explain individual parameters beyond what the schema provides. For parameters without schema descriptions (e.g., feeBase, ledgerSeq), the description offers no additional guidance.

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

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

The description clearly states the tool runs real Hook WebAssembly bytecode in a local VM, simulating a transaction and ledger state, and reports the true accept/rollback decision, return code, state writes, emitted transactions, and execution trace. It distinguishes itself as the first dev-accessible Hook simulator without needing a node, setting it apart from siblings like simulate_hook_trigger.

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

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

The description implies use when simulating a Hook locally without a node, but does not explicitly state when to use or avoid this tool compared to alternatives like hook_dry_run or simulate_hook_trigger. No exclusions or prerequisites are mentioned, leaving the agent to infer usage context from the tool's capabilities.

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

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

With no annotations, the description fully discloses read-only nature and precise RPC behavior (5 serial reads spaced ≥1100ms apart), plus lists all the data categories fetched, giving agents clear expectations of cost and time.

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

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

Single sentence front-loads purpose, then bullet-like list of contents, followed by behavioral notes. No fluff, every word adds value.

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 complex tool with no output schema, description comprehensively lists all return fields (balance, key safety, hooks, trustlines, URITokens, activity, warnings) and notes read-only behavior. Adequate for an agent to understand output and side effects.

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

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

Schema coverage is 50% – 'address' is described as 'r-address' in schema and 'network' has enum default. The description does not add further parameter details beyond what's in schema, missing opportunity to clarify format or validation, but the tool's purpose implies the address parameter is the target account.

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?

Clearly states it provides a plain-English account snapshot enumerating specific components (balance, key safety, hooks, trustlines, URITokens, activity) and distinguishes from numerous sibling tools like get_account_info or get_account_objects by emphasizing the one-call comprehensive overview.

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?

Describes usage context as a 'one-call' snapshot for human-readable overview and notes it is read-only with exact RPC count and spacing, implying a trade-off between comprehensive data and speed. However, does not explicitly state when to use vs alternatives or when not to use.

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?

Despite no annotations, the description provides extensive behavioral details: determinism (no randomness/clock), reporting of counts, boundary findings, sample inputs, and honest handling of degraded/halted runs (excluded, inconclusive if all fail). This fully compensates for missing annotations.

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

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

The description is a single dense paragraph that front-loads the core purpose and efficiently covers axes, reporting, and honesty. Every sentence adds value with no repetition or fluff.

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

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

The description explains the tool's behavior, inputs, and outputs (counts, boundaries, sample inputs) thoroughly given the complexity. However, it does not detail all 18 parameters (e.g., state, feeBase, ledgerSeq), which are left to the schema. The overall completeness is high but not exhaustive.

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 50%, and the description adds meaning by explaining the axes (e.g., txType, amount range, account/destination ids) and their roles. It clarifies the purpose of parameters like amountMin/amountMax and mentions wasmHex/wasmBase64 for bytecode. However, some parameters (state, feeBase, otxnFields) remain unexplained.

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

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

The description clearly states the tool is a 'DIFFERENTIAL FUZZER' for finding a Hook's decision boundary by running real bytecode with deterministic inputs. It specifies the resource (Hook) and action (fuzz to find boundaries), and the detailed axes distinguish it from sibling tools like simulate_hook_trigger.

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 outlines when to use the tool (for fuzzing hooks to find decision boundaries) but does not explicitly mention when not to use it or suggest alternatives. The context is clear, but no 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?

The description mentions 'Read-only', which indicates no destructive side effects, but with no annotations provided, this is minimal transparency. It also notes the decoding of the HookOn bitmap, adding some behavioral context beyond the schema.

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

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

The description is a single, relatively clear sentence with no extraneous information. It is efficient but could be improved by front-loading the verb.

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 two parameters and no output schema or annotations, the description provides a basic idea of the output but lacks details on required fields, defaults, or the return format. It is adequate but has gaps.

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

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

Schema description coverage is 0%, and the description does not elaborate on the parameters 'address' or 'network'. It only implies the address via 'account', adding little value beyond the schema.

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

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

The description clearly states the tool retrieves hooks installed on an account with decoded HookOn bitmaps, which distinguishes it from sibling tools like get_hook_definition or get_hook_state. However, the phrasing is somewhat passive and could be more active (e.g., 'Retrieve').

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

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

No guidance is provided on when to use this tool versus alternatives such as get_hook_definition or get_hook_state. The description lacks explicit usage context or exclusion criteria.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'Read-only', which indicates no mutation but does not cover other behavioral aspects (e.g., authentication, error handling, data freshness, or rate limits). This is minimal transparency.

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

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

The description is a single sentence with no superfluous information. It front-loads the key resource and fields, followed by the read-only trait. Every word contributes value.

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

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

Given the absence of an output schema, the description should describe the return format. It lists fields (balance, sequence, flags, regular key) but does not specify the structure or data types. The description is insufficient for an agent to fully understand the output, though the tool is simple.

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 description adds no information about the parameters 'address' or 'network'. The schema covers 50% with a description for 'address', but the description fails to compensate for the undocumented 'network' parameter or add any semantic context beyond the schema.

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

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

The description clearly indicates the tool retrieves account root information including balance, sequence, flags, and regular key. It explicitly states 'Read-only', distinguishing it from mutation tools. The verb 'get' is implied, and the resource 'account root' is specific, differentiating from sibling tools like get_account_objects or get_account_lines.

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

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

No explicit guidance on when to use this tool versus alternatives. The description does not mention when-not-to-use or provide context for selecting this over other account-related tools. The 'Read-only' hint is the only implicit usage guide, but it lacks explicit comparisons to siblings.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It mentions 'Read-only,' indicating no state modification, but does not disclose potential behaviors like pagination, error handling, or limits on the response size.

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

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

The description is a single, front-loaded sentence with no wasted words. However, it is very brief and could benefit from slight expansion to cover more details without becoming verbose.

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

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

Given the simple tool with 2 parameters and no output schema, the description should at least mention the return format or common error cases. It only states the purpose and read-only nature, which is insufficient for full comprehension.

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 0%, and the description does not add any meaning beyond the schema structure. It fails to explain the parameters (address, network) or their expected formats, leaving the agent with no extra guidance.

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

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

The description clearly states it retrieves trustlines (issued-currency balances) for an account and notes it is read-only. This distinguishes it from sibling tools like get_account_info or get_account_objects, though it does not explicitly contrast 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?

No guidance on when to use or not use this tool versus alternatives. The description only implicitly suggests it is for retrieving trustlines, but lacks explicit context or exclusions.

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

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

The description declares 'Read-only,' which is a key behavioral trait in the absence of annotations. However, it omits other details like pagination, error handling, or response structure.

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