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

With no annotations provided, the description carries full responsibility for disclosure. It reveals that the tool returns the raw unsigned transaction hex and fee details, and it implies the operation has no on-chain side effects ('ready for signing'). It also adds credit cost details, which is useful context. It does not cover all potential behaviors (e.g., authentication, rate limits), but it covers the essential nature of the operation.

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 well-structured: it starts with a clear one-sentence overview, then lists the three actions with brief explanations, and finally includes credit information. It is concise enough for the complexity it covers, though the credit section could be trimmed if not essential, but it does contribute operational context.

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

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

The tool has 12 parameters and no output schema, yet the description gives sufficient context: it names the three actions, describes the expected output (transaction hex and fee details), and outlines the follow-up steps for signing and broadcasting. It does not provide examples or error handling details, but for correct invocation it is reasonably complete.

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

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

The schema provides descriptions for 100% of the parameters, including which actions they apply to. The tool description adds value by explaining what each action does, but it does not add meaning for individual parameters beyond the schema. Given the high schema coverage, this baseline of 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's function: 'Build unsigned EVM transactions ready for signing.' It lists three specific actions (native transfer, ERC-20 transfer, NFT transfer), which distinguishes it from downstream signing and broadcasting tools. The mention of the prepare-sign-broadcast workflow further differentiates its scope.

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 explicit guidance on when to use the tool: before signing locally via a tool like evm_sign, and before broadcasting via broadcast_signed_transaction. It gives a clear sequential workflow but does not explicitly state when not to use it or name alternative preparation tools, so it falls slightly short of a 5.

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

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

With no annotations, the description carries the burden and does well: it states the operation is a prepare-only step (returns an unsigned transaction, no signing), discloses the return shape (unsigned tx + fee details), and surfaces cost (60 credits for native-coins). It omits auth requirements, funding prerequisites, and failure behavior, leaving some transparency gaps.

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

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

Front-loads purpose and workflow in the first three sentences, then organizes actions and credits as labeled lists. The credits disclaimer boilerplate is slightly verbose but informative; overall well-structured with little 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?

For a 9-parameter mutation-preparation tool with no output schema and no annotations, the description covers the essentials: what it builds, what it returns, the follow-up signing/broadcast steps, and cost. Missing prerequisites (funded UTXOs, address ownership) and error/edge-case handling, but adequate given full schema coverage.

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

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

Schema description coverage is 100%, so the schema already documents all 9 parameters (exactFee, locktime, recipients, feePriority, fromAddress, prepareStrategy, etc.). The description adds only the action's meaning ('native KAS transfer, supporting multiple recipients'), which is redundant with the schema's recipients description. 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 opens with a specific verb+resource ('Build unsigned Kaspa transactions ready for signing') and enumerates the single supported action (native-coins) with its behavior. It clearly scopes to Kaspa, though it never explicitly contrasts itself with the sibling prepare_transactions_* chain variants, relying on the tool name and the 'Kaspa' mention to disambiguate.

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

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

It gives a clear end-to-end workflow: prepare here, then 'sign locally (kaspa_sign) and broadcast via broadcast_signed_transaction', naming the two follow-up tools. It stops short of stating when NOT to use it or how it relates to the other prepare_transactions_* tools for other chains.

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

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

Annotations are absent, so the description must carry the behavior, and it does add value beyond the schema: it clarifies the output is unsigned with fee details, defines the post-call signing/broadcast path, and discloses per-action credit costs with the caveat that they are indicative and authoritative values appear in response headers. It omits auth/permission requirements and any rate-limit behavior, keeping it from a 5.

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

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

Front-loaded with the core purpose and return shape, then structured as a scannable action list and credit table. Every element is useful, though the credit list plus the disclaimer paragraph is more text than the tool itself strictly requires.

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, the description still tells the agent what comes back (unsigned transaction plus fee details) and the exact next call to make. Missing only peripheral details such as authentication needs or failure modes for a 9-parameter, two-action 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?

Schema coverage is 100%, so the baseline is 3; the description goes beyond it by mapping each action to its semantics (native SOL transfer vs SPL token transfer) and by associating credit costs with each action value. It still leaves parameter-level detail such as feePriority/fee semantics and base-unit formatting to the schema.

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

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

States a concrete verb (build/prepare) and resource (unsigned Solana transactions) and enumerates its two actions, native-coins and spl-tokens. The chain name in both tool and description cleanly separates it from the six sibling prepare_transactions_* chain variants.

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 places the tool in a workflow: build unsigned, sign locally, then broadcast via the named sibling broadcast_signed_transaction. It does not, however, say when to choose native-coins vs spl-tokens beyond stating that one builds a SOL transfer and the other an SPL token transfer.

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 burden and does reasonably well: it discloses that output is unsigned/forged bytes plus fee details, that signing happens locally (so keys are never sent), and that credits are consumed per action. It omits permission/auth requirements and rate-limit behavior, but the core non-destructive 'build only' trait is clearly conveyed.

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

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

Purpose and the critical next-step are front-loaded in the first two sentences, then actions and credits are cleanly sectioned. The credits subsection and its 'indicative only' disclaimer add bulk that is only marginally relevant to invocation, keeping this short of a 5.

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

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

For a 10-parameter, no-annotation, no-output-schema tool, the description covers the essential gaps: what is returned (forged bytes + fees), the signing/broadcast handoff, and per-action credit costs. It could say more about required permissions or address prerequisites, but it is complete enough to invoke correctly.

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

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

Schema description coverage is 100%, so every parameter is already documented, including enum values, defaults, and per-action requirements. The description's action list adds a small semantic gloss on the three enum values but no unit, format, or conditional detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb+resource: 'Build unsigned Tezos operations ready for signing', which names the chain and the exact artifact produced. The action list (native XTZ, FA1.2, FA2 transfers) makes it unambiguous against the chain-specific siblings (prepare_transactions_evm, prepare_transactions_tron, etc.).

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

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

Gives a clear workflow context: prepare, then 'sign locally and broadcast via broadcast_signed_transaction', which tells the agent where this fits in the sequence. It does not explicitly state when to pick this over a sibling chain tool or any exclusions, but the chain scoping in the name plus the flow is sufficient to route correctly.

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 that the output is unsigned, returns fee details, and incurs per-action credit costs. It does not state auth/permission requirements, whether the call has side effects on-chain, or rate limits, which is a moderate gap for a no-annotation 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?

Front-loaded first sentence states the core purpose, then a flow sentence, then a scannable action/credit list. The credits disclaimer is slightly verbose but earns its place by warning costs may change.

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, the description covers the purpose, the return shape at a high level (unsigned tx + fee details), the follow-up calls, and per-action costs. Missing auth and side-effect details keep it from being fully complete, but it is adequate for a 9-param builder tool.

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

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

Schema description coverage is 100%, so the per-parameter meaning (amount units, sender/recipient, contract, tokenId, feeLimit) is already documented. The description adds the action enumeration with credit costs, which is marginal value beyond the schema enum.

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

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

States a specific verb (build/prepare) and resource (unsigned Tron transactions) and explicitly distinguishes itself from the generic EVM prepare endpoints used for other chains. The three action bullets make the scope concrete, so an agent can tell it apart from the sibling prepare_transactions_* 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?

Gives an explicit downstream flow: prepare, then sign locally with tron_sign, then broadcast via broadcast_signed_transaction. It also names the alternative (generic EVM endpoints) and the condition (other chains), leaving little to inference.

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 usefully discloses that the output is unsigned (not broadcast), that it returns fee details, the required fee inputs, and a credit cost (530). It omits auth/credential requirements, rate limits, and what the fee model does when neither strategy applies – gaps that matter on a 12-param mutation-adjacent builder.

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

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

Front-loads purpose, then the sign/broadcast workflow, then action details, then credits. The credits boilerplate ('indicative only, may change') is partly filler but is bounded and clearly separated. Overall well-structured with minimal 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?

With 12 params, no output schema, and no annotations, the description does substantial lifting: it explains the returned unsigned tx + fees, the action set, the fee requirement, and the follow-on tools. It is nearly complete, though it could state auth/prerequisite context given the parameter weight.

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

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

Schema description coverage is 100%, so every parameter (action enum, feePriority/exactFee, recipients, fromAddress, locktime, etc.) is already documented in the schema. The description largely restates this by naming the single action and its fee constraint, adding little syntax or format detail beyond the schema. Baseline 3 applies.

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

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

States a specific verb + resource (build unsigned UTXO transactions) and enumerates the exact chains (Bitcoin, Bitcoin Cash, Litecoin, Dogecoin, Dash, Zcash). This cleanly distinguishes it from the sibling prepare_transactions_evm/tron/solana/etc. that target other ecosystems. An agent can route without opening any other definition.

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 lays out the downstream workflow: sign locally with utxo_sign, then broadcast via broadcast_signed_transaction, and notes the feePriority-or-exactFee requirement. It does not explicitly say when to prefer this over sibling chain tools, but the chain enumeration and workflow cover the practical selection decision.

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

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

With no annotations, the description carries the full burden, and it does disclose meaningful behavior: the output is unsigned, signing happens locally (non-custodial), and the response contains transaction plus fee details. It also surfaces credit cost per action and that actual credits come back in response headers, which the agent cannot infer elsewhere. Missing auth/permission and failure-mode context keeps it from a 5.

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

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

The purpose and the sign/broadcast workflow are front-loaded, and the action/credit bullets are scannable. The credits-and-disclaimer block is somewhat boilerplate repetition, but it is bounded and clearly separated.

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

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

For a 9-parameter construction tool with no output schema, the description covers the essentials: what is returned (unsigned tx + fee details), what to do next, and per-action cost. It stops short of documenting the single supported action's required fields, but the schema covers those at full coverage.

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

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

Schema description coverage is 100%, so the baseline is 3; the schema already documents drops units, fee tiers, destination tags, and sequence override. The description adds no parameter-level syntax or constraints beyond what the schema provides.

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

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

States a specific verb and resource ('Build unsigned XRP transactions ready for signing') and names the resulting artifact. The 'XRP' qualifier cleanly separates it from the many chain-specific prepare_transactions_* 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?

Explicitly describes the downstream workflow — sign locally with xrp_sign, then broadcast via broadcast_signed_transaction — which tells the agent when this tool belongs in a sequence. It doesn't state exclusions or when a different sibling should be preferred, but the chain scoping makes that fairly obvious.

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

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

With no annotations, the description carries the full burden and explicitly notes 'no API call, no credits consumed,' which is key behavioral information. It also discloses detailed content such as retry strategy, HMAC security, and rate-limit penalty multipliers, going well beyond a generic 'returns info' statement.

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 front-loaded with the critical 'no API call, no credits consumed' caveat and uses a compact bullet list. Each bullet covers a distinct action without wasted prose, making it highly scannable for an agent.

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 reference-documentation tool with no output schema and no annotations, this description is complete enough: it defines all five actions and gives sufficient detail about their content. It also clarifies side effects (none) and cost implications (none), covering the main contextual risks.

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

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

Although schema coverage is 100%, the description adds significant meaning by explaining each allowed action enum value in detail (e.g., callbacks covers URL requirements, 5 retries, HMAC). This transforms enum names into actionable context and compensates fully beyond the schema's short parameter 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 states this is CryptoAPIs reference documentation with no API call or credits consumed, and enumerates five specific topics (blockchains, errors, credits, callbacks, limits). This clearly identifies it as an informational tool distinct from domain siblings like aml.

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 bulleted actions give clear contexts for when to use the tool, such as looking up error codes, credit structures, callback mechanics, or rate limits. It does not explicitly name alternatives or exclusion conditions, so it stops short of a full when/when-not specification.

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