k402

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

With no annotations provided, the description must disclose behavioral traits. It does disclose the cost ('Paid (~$0.0002)') and output format, which is helpful. However, it does not mention idempotency, rate limits, or any specific requirements beyond the input schema. The read-only nature is implied but not explicit.

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 contains no superfluous words. Every sentence adds value: purpose, audience, cost.

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 usefully specifies the return format. It also explains the trust model and cost. However, it lacks details on error handling or edge cases, which would be valuable for a paid tool. Overall, it is fairly complete for a simple verification 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 the description must add meaning beyond the schema. While it mentions 'receipt_b64' and 'image_id' in context, it does not explain their format, constraints, or how they relate to the verification process. This adds minimal value over the empty 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's action: 'Verify a RISC Zero receipt against an image_id' and specifies the output format '{valid, journal_b64}'. This distinguishes it from sibling tools like 'prove_*' which create proofs, not verify.

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 explains who can use it ('Anyone can check an attestation without trusting the prover') and implies when to use it (when verifying an attestation). It does not explicitly state when not to use or name alternatives, but the context is clear given no sibling tool performs verification.

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 discloses that the tool is free and provides live prices, which are key behavioral traits. It does not mention rate limits or idempotency, but for a read-only listing tool, the transparency is adequate.

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 wasted words. The purpose is front-loaded, and the description is concise 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?

Given zero parameters and no output schema, the description fully covers the tool's behavior and output. It explains what is returned (list of services and prices) and that it is free, making it complete for its simplicity.

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

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

There are no parameters, and schema coverage is trivially 100%. The description adds meaning by specifying what the tool lists and that prices are live in two currencies, exceeding baseline expectations.

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 'List every service this gateway sells (text tools, Kaspa chain data, LLM tiers) with live prices in KAS and USD.' It uses a specific verb ('List') and identifies the resource (services with prices), clearly distinguishing it from sibling tools which are functional or data-specific.

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 'Free. Start here to see what's available and what calls cost.' It provides clear context for when to use the tool (as an entry point) but does not explicitly mention when not to use it or list alternatives. However, the guidance is sufficient for a listing tool.

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

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

No annotations are provided, so the description carries full burden. It notes the tool is free and returns an error if the feature is disabled. However, it does not explicitly state whether it is read-only or has side effects, though context implies it is a safe query.

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 with clear front-loading of purpose. It is informative without being overly verbose, though it could be slightly more concise by merging some explanations.

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 zero parameters, the description adequately explains the return values, experimental status, and how to use the tool in the broader workflow. It provides enough context for an AI to understand when and why to 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?

The input schema has zero parameters with 100% coverage, so the description cannot add parameter details. It compensates by explaining the output fields and usage context, meeting the baseline for a parameterless tool.

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 returns parameters for opening a trustless Kaspa channel, including specific return fields. It distinguishes from sibling tools like channel_status and open_session by focusing on configuration retrieval.

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 explains when to use this tool (before opening a channel) and mentions the experimental status and alternative client library. It does not explicitly list exclusions or when not to use, but provides sufficient context for correct usage.

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. The description only mentions it is 'Free' (cost) but does not disclose behavioral traits like read-only, permissions needed, rate limits, or side effects. Relies solely on the description, which is insufficient.

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 purpose, no wasted words. Efficient and to the point.

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 query tool with one parameter and no output schema, the description covers key return fields. Lacks error handling or authentication notes, but acceptable given simplicity.

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 'channel_id' as 'covenant id', adding meaning beyond the schema (which only has name and type). With 0% schema coverage, this compensation is significant, though more detail would be ideal.

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 status of a kaspa-channel by channel id, listing specific fields (funded value, vouchers spent, remaining, expiry, closed status). This distinguishes it from sibling tools like channel_config.

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 vs alternatives. The word 'Free' hints at no cost but does not address context or exclusions. Usage is implied by the description.

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 the result is constrained to the label set, the multi-label option, and an approximate cost. Lacks details on output format or error behaviors, but for a paid tool, cost transparency is valued.

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, each earning its place: core functionality and cost. No wasted words, front-loaded.

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 main functionality, parameter behavior, and cost. For a simple tool with 3 parameters and no output schema, it is mostly complete. Lacks details on edge cases like too many labels or text length limits.

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 no parameter descriptions. The description adds meaning: 'text' is input text, 'labels' is the label set (2-32), 'multi' enables multiple labels. This explains constraints and behavior beyond the schema's type/name.

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 classifies text into one or multiple labels using a constrained label set (2-32 labels). The verb 'classify' and resource 'text' are clear, but it does not differentiate from sibling tools like 'generate' or 'extract'.

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 guidance on the 'multi' parameter for single vs. multi-label classification and mentions cost. However, it does not specify when to use this tool versus alternatives, nor does it give prerequisites 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?

The description discloses that the tool is paid (~$0.0003), which is important cost information. However, with no annotations provided, it lacks details on whether the tool modifies state or has side effects. The 'derive' verb suggests a read-only operation, but this is implicit.

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 compact sentences with no filler. It front-loads the purpose and includes key details about network options and cost.

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 covers the core function and cost but omits the return value format, error handling, and prerequisites like that the script must be compiled (likely from covenant_compile). For a simple derivation tool, it is adequate but not fully informative.

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%, leaving the description to explain parameters. The description mentions that network is 'mainnet' or 'testnet-10' but does not explain the required 'script_hex' parameter format or how to obtain a compiled script. This is insufficient compensation.

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 action: deriving a covenant P2SH address from a compiled script. It specifies the two supported networks and distinguishes itself from sibling tools like covenant_compile or covenant_build by focusing on address derivation.

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 a compiled script and need an address, but does not explicitly state when to use this tool versus alternatives like covenant_build or covenant_compile. No direct guidance on exclusions or prerequisites.

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

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

No annotations exist, so the description bears full responsibility. It discloses that the tool is paid (~$0.0003) and that mainnet involves real KAS movement, implying it is a mutation. However, it lacks details on failure modes, rate limits, or authentication 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 two sentences long and front-loads the action and object. It wastes no words and includes critical notes about mainnet and cost. A slightly more structured format could improve readability.

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

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

Given no output schema and no annotations, the description should cover more. It mentions cost and prerequisite but does not describe return values, error handling, or what happens upon success/failure. For a broadcast tool, this is a significant gap.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the 'transaction' parameter as 'RpcTransaction JSON from covenant_build', but does not explain the 'network' parameter (only mentioned indirectly via 'MAINNET'). This leaves one parameter under-documented.

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 uses a clear verb 'Broadcast' and specifies the resource as 'signed covenant tx (RpcTransaction JSON from covenant_build)'. It distinguishes from sibling tools like covenant_build and covenant_check by implying this is the final step. However, it could be more explicit about the overall purpose.

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 explicitly states when to use this tool: after covenant_build and after running covenant_check first. It warns that mainnet moves real KAS. It does not mention when not to use it or alternatives, but the prerequisite is clear.

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

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

With no annotations, the description discloses key behaviors: it never signs, returns broadcast-ready tx, fee accounting, pre-verify if fully authorized, and a cost (~$0.001). Missing details on authentication or state changes, but 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?

The description is detailed yet efficiently structured, using lists for input/output fields. Slightly lengthy but well-organized, with the purpose stated upfront.

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 5 parameters, no output schema, and nested object complexity, the description covers input/output formats, return values (tx, rpc_transaction, fee, pre-verify), and cost. Could detail the return structures more but overall adequate.

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% (generic array items), but the description adds detailed semantics for inputs and outputs, including optional fields, signatures, and covenant structure. This fully compensates for the schema gap.

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

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

The description clearly states it assembles a covenant spend transaction, listing input and output specifications. It distinguishes from sibling tools like covenant_broadcast or covenant_compile by focusing on building the tx.

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 specifies when to use (to build a covenant spend tx) and notes it never signs, but does not explicitly state when not to use or provide alternatives. The guidance on input/output structure is clear.

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

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

With no annotations, the description carries full burden. It discloses that the tool is 'Local', 'pre-verify', and 'Paid (~$0.0005)', implying a safe read-only operation. It also describes the return structure. However, it does not explicitly state that it has no side effects or potential error conditions.

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. First sentence states purpose and benefit. Second explains inputs and output. 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?

Complexity is moderate (covenant pre-verify). Description covers the return structure and one parameter. Missing details on transaction format and error handling, but overall adequate for an agent to understand the tool's role.

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% (no descriptions in schema). The description explains 'entries' as spent UTXOs and references covenant_utxos, but does not describe the 'transaction' parameter format or constraints. Partial coverage only.

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 'Local txscript pre-verify of a signed covenant tx BEFORE broadcast', using a specific verb ('pre-verify') and resource ('covenant tx'). It distinguishes from sibling tools like covenant_broadcast by emphasizing pre-broadcast verification.

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?

Description tells when to use ('BEFORE broadcast') and how to provide inputs ('entries are the spent UTXOs (covenant_utxos output plugs in directly)'). It does not explicitly state when not to use or suggest alternatives, but the context is clear enough.

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 the burden. Discloses outputs, cost, and a limitation (not proven on-chain). Could mention more about error behavior or rate limits, but covers key 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 plus a note, all essential. No extra words, front-loaded with the main action and outputs.

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 compile tool with simple parameters and no output schema, description is fairly complete: purpose, example, cost, caveat. Could address maximum size or timeout, but generally sufficient.

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 has 0% description coverage; description adds meaning by explaining constructor_args with a concrete JSON example and implying source is the Silverscript code. Could detail array items further.

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 compiles a Silverscript covenant, listing specific outputs (script hex, ABI, hardened template hash, P2SH address). Distinguishes from siblings like covenant_build or covenant_check.

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 a practical example for constructor_args and warns about cost and the note that compilation is not on-chain proof. However, lacks explicit when-to-use vs 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?

No annotations are provided, so the description carries full burden. It discloses that the operation is a live inspection (non-destructive) and that it requires payment (~$0.0003). This gives a clear behavioral profile. However, it does not mention potential errors or rate limits.

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 three sentences: purpose, optional filter, and cost. Every sentence adds value. There is no redundant information, making it easy to scan.

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 moderate complexity (3 params, no output schema, no annotations). The description covers the purpose, key parameters, and cost. It does not explain the return format or pagination, but for a simple live UTXO set inspection, the provided information is mostly sufficient.

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% description coverage, so the description must compensate. It explains the address parameter as 'covenant address' and the covenant_id as an optional filter, adding meaning beyond the schema. However, the network parameter is not explained, leaving a gap. Overall, it adds moderate value.

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 the live UTXO set locked under a covenant address, which is a specific resource. It mentions the optional filter by covenant_id. While it distinguishes itself from sibling tools like kaspa_utxos, it does not explicitly call out alternatives.

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 the tool should be used when needing covenant UTXOs, and notes the optional covenant_id filter. However, it provides no guidance on when not to use it or explicit exclusion criteria. The paid nature is mentioned but not contextualized as a usage consideration.

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 the burden. It discloses paid cost (~$0.0003 in KAS) and a limit of 64 texts. However, it does not mention that the operation is stateless, read-only, or any side effects, which 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?

Single sentence with no fluff, covering key aspects: action, limit, model, dimensions, cost. 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 single-parameter tool with no output schema, the description covers purpose, limit, model, and cost. Missing return format (e.g., 2D array of floats) but otherwise complete enough.

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

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

With 0% schema description coverage, the description adds meaning by specifying the limit (up to 64 texts) and the output characteristics (768-dim, nomic-embed-text). It does not describe input constraints like text length or format.

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 'embed' and resource 'texts', with details about dimensionality (768-dim) and model (nomic-embed-text). This distinguishes it from sibling tools like classify or generate.

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 use for embedding text with a limit of 64 texts and a cost, but no explicit when-to-use or alternatives among siblings. The paid nature is a usage hint but not comparative.

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 must disclose behavioral traits. It mentions it is paid and provides a cost estimate, and emphasizes that output is guaranteed to match the schema. However, it lacks details on error handling, performance, or limitations such as token limits or failure modes.

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

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

The description is two sentences long, front-loading the core purpose and key differentiator (schema-constrained decoding). Every sentence adds value, and 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?

Given the tool has three parameters (two required), nested objects, and no output schema, the description is moderately complete. It explains the core functionality and cost but omits details about the 'instruction' parameter, example usage, or return value structure.

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%, meaning no parameter descriptions exist in the schema. The description adds no detail about the parameters beyond their existence implied in the purpose. The 'instruction' parameter is not mentioned at all, leaving its meaning unclear.

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 extracts structured data as JSON matching a provided schema, using a specific verb ('Extract') and resource ('structured data from text'). It distinguishes itself from siblings like 'classify' or 'summarize' by emphasizing schema-constrained 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 structured extraction when a JSON schema is provided, but does not explicitly state when to use or avoid this tool, nor does it mention alternatives among the listed siblings. The cost hint provides some context, but guidance is minimal.

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 present, so the description must fully disclose behavior. It mentions GPU execution and approximate costs but omits key operational details like error handling, statefulness, rate limits, or authentication requirements. The return type is vaguely 'completion text' without structure.

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 verbose paragraph that mixes action, tier details, and costs. While front-loaded with the verb, it could be more concise by structuring as a bulleted list. Each sentence provides information but the density reduces readability.

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

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

Given the parameter count (4), lack of output schema, and no annotations, the description covers the main functionality and tier options. However, it lacks guidance on system prompt behavior, max_tokens limits, and error handling. It is adequate for simple use but incomplete for advanced scenarios.

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 the description must compensate. It adds significant value by enumerating valid 'tier' values (chat, llama, reason, think, code, kaspa-expert) with associated capabilities and costs. However, parameters 'system' and 'max_tokens' are not explained, and 'prompt' lacks format details.

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 'run a prompt' and the resource 'GPU model tier', listing specific model names (chat, llama, etc.) and explicitly says 'Returns the completion text'. This distinguishes it from sibling tools like classify or embed_text.

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 model tier details with cost estimates, guiding which tier to pick for different tasks (fast, budget, reasoning, code). It implies usage for text generation but does not explicitly exclude when not to use or compare to alternatives beyond listing sibling tool names.

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 404 behavior until completion, 24-hour retention, and that it's free. This is useful behavioral context beyond basic read 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?

Extremely concise: two clear sentences with no filler. Front-loaded with purpose and output structure. 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?

Given a single parameter and no output schema, the description lists the output fields and provides key behavioral constraints (404, 24h retention, free). Lacks examples or error handling details, but adequate for a simple fetch 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 coverage is 0%, and the description adds no extra meaning for the single parameter (job_id). It does not explain format, example, or how to obtain the job_id.

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

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

The description uses a specific verb ('Fetch') and identifies the resource ('finished proving job's result') with explicit fields. It distinguishes itself from siblings like job_status and prove_submit.

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 (after job is finished) via '404 until done' and notes results kept 24h. It does not explicitly state when not to use or compare to alternatives, but the context is clear.

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

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

In the absence of annotations, the description adds valuable behavioral context, stating that the tool is free and returns status, queue position, and cost. It implies a read-only poll operation, though it does not explicitly confirm 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?

The description is extremely concise—a single sentence that front-loads the core action and outputs without unnecessary words or repetition. 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?

For a simple tool with one parameter and no output schema, the description covers the essential return fields (status, queue position, cost). It lacks details on pagination or error states but is adequate for polling a single job.

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 0% description coverage, and the tool description only references the parameter implicitly ('a proving job'). It does not explain the format of 'job_id' or how to obtain it, leaving the agent to infer its meaning.

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

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

The description clearly states the tool's purpose: polling a proving job for status, queue position, and cost. It uses specific verbs ('Poll') and resources ('proving job') and lists returned statuses, distinguishing it from sibling tools like 'job_result' or 'prove_submit'.

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 given on when to use this tool versus alternatives like 'job_result' or other status tools. The description does not mention prerequisites, context, or situations where it should not be used.

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 behavioral traits: paid nature ($0.00015 in KAS), direct node query, no indexer/API key. Since no annotations exist, description covers major aspects. Lacks details on error handling or response format but sufficient for a simple read-only tool.

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

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

Two sentences, no wasted words. Front-loaded with purpose, followed by key differentiators and cost. Ideal length 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?

Complete enough for a single-parameter balance query. No output schema exists, but the return value (balance) is implicitly numeric. Could mention format or units, but not essential given simplicity. Sibling context is not leveraged.

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

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

With 0% schema coverage, description adds meaning by specifying the address must be a Kaspa MAINNET address. The single parameter is well-described, though additional format details (e.g., prefix) could help but are not critical.

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 retrieves balance of a Kaspa MAINNET address. It specifies the source (node) and uniqueness (no indexer, no API key). Distinguishes from sibling tools like kaspa_utxos or kaspa_tx_status by focusing on balance.

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?

Description implies when to use (for balance queries) but provides no explicit guidance on when not to use or alternatives. No comparison to other kaspa_* tools, despite siblings existing for other purposes (e.g., fee estimates, UTXOs).

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?

Without annotations, the description carries the burden. It discloses that the data is current and mentions a cost ('Paid (~$0.00015)'), but does not specify behavioral details like caching, rate limits, or idempotency. This is adequate but leaves 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?

The description is a single sentence, very concise. It front-loads the key action ('Current...feerate buckets') and includes additional context (cost). No wasted words, though a slightly more structured format could improve readability.

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

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

Given no parameters and no output schema, the description covers the basic purpose and output context. However, it does not describe the exact format of the returned feerate buckets or how they are structured, which might be needed for tool 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?

There are no parameters, and schema coverage is trivially 100%. The description adds value by explaining the meaning of the output (feerate buckets, units, cost), which goes beyond the empty 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 provides 'Current Kaspa mainnet feerate buckets', specifying the currency (sompi) and metric (per gram of tx mass). It differentiates from sibling tools as none of them appear to be fee-related.

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 given on when to use this tool versus alternatives. It simply describes what it does without contextualizing its usage or prerequisites.

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

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

Discloses that the tool is paid ($0.00015 in KAS), a key behavioral trait. Since no annotations are provided, the description carries the full burden, and it adds important cost context. Lacks details on potential failures or side effects, but adequate for a simple read-only 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?

Extremely concise: one sentence summarizing the tool's output plus a brief cost note. No wasted words, front-loaded with key metrics.

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?

Lists the returned metrics but does not describe the output format or structure. Without an output schema, the description could be more precise about how the data is presented. Adequate but 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?

No parameters exist, and schema coverage is 100%. Baseline of 4 applies per guidelines.

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 returns Kaspa mainnet status metrics like DAA score, block count, difficulty, and node sync state. Distinguishes from sibling Kaspa tools (balance, fee estimate, etc.) that serve different purposes.

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 versus alternatives. Does not mention any prerequisites 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?

With no annotations, description carries full burden. It discloses paid nature, and the ambiguity of 'accepted-or-unknown'. However, it does not specify the return format or error handling, so slightly incomplete.

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 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?

Lacks output description; agent doesn't know what the tool returns (e.g., boolean, status string). For a status check, this is a notable gap, especially 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?

Only one required parameter (txid), self-explanatory. Description does not add detail about format or constraints, but with schema coverage 0%, baseline is 3, and no additional value is provided.

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 checks the mempool status of a Kaspa transaction, distinguishes from confirmation by pointing to kaspa_utxos, and includes cost information.

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 tells when to use (check mempool), what absence means, and suggests using kaspa_utxos for confirmation, providing clear guidance on when to switch 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 burden. It discloses the cost (paid) and the output fields, but fails to mention potential error conditions, rate limits, or authentication needs.

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 only: first defines purpose, second adds cost. No unnecessary words, entirely focused.

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 one-parameter tool with no output schema, the description covers the return type and cost. Missing minor details like error handling or address format, but sufficient for typical 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?

Schema coverage is 0%, so the description must compensate. It adds that the address is for the Kaspa mainnet, but does not specify format, network prefix, or provide examples.

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 returns the UTXO set for a Kaspa mainnet address, including specific fields (scriptPublicKey, covenant_id). This distinguishes it from sibling tools like kaspa_balance or covenant_utxos.

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 the tool is paid and expensive (~$0.0003 in KAS), implying cost awareness, but does not explicitly guide when to use this tool versus alternatives like kaspa_balance or covenant_utxos.

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?

Given no annotations, the description carries full burden. It discloses return values, minimum deposit, confirmation speed, and local saving. It could mention potential side effects like session overwriting.

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 efficient with about four sentences, front-loaded with the main purpose, and contains no unnecessary 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 zero parameters and no output schema, the description adequately explains the tool's role and usage. It could mention failure conditions or prerequisites, but overall it's 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?

No parameters exist, so baseline is 4. The description adds no parameter info, but none 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 explicitly states it opens a prepaid payment session, returns a session key and deposit address, and explains the process. This is specific and distinct from sibling tools like use_session or session_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?

It clearly describes when to use (to obtain a deposit address for prepaid KAS balance) and states it's free and automatic. However, it doesn't explicitly mention when not to use or provide 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?

No annotations are provided, so the description carries the burden. It states the tool is 'free' and describes querying accepted coins and schemes, implying a read-only operation. It could explicitly note it has no side effects, but the description is sufficiently transparent about what the tool does.

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 and well-structured, front-loading the purpose and then listing payment methods. While every sentence adds value, it is slightly verbose; a bit more conciseness would improve it.

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 zero parameters and no output schema, the description provides a complete picture: what the tool does, its output (coins and schemes), how it relates to sibling tools, and the free nature. No missing information for effective 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?

There are zero parameters, and schema coverage is 100%. The description adds value by explaining what the tool returns (list of coins and schemes) and how that output is used in the broader payment context, compensating for the lack of output 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 lists 'which coins and schemes this gateway accepts for payment.' It uses a specific verb (lists/which accepts) and resource (payment options), and distinguishes from sibling tools by explaining how each payment method works and when to use 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?

The description explicitly provides usage guidelines: it explains three ways to pay (prepaid session, per-call, covenant channel), mentions alternatives like open_session and pay_per_call, and gives context for when each method is appropriate.

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 the description carries full burden. It describes the complete workflow: pay on-chain, call with details, gateway verifies and returns result. Lacks details on failure modes but is generally transparent.

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 concise with three sentences, front-loading the purpose and then the parameters. Could be slightly more structured but 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?

Covers the essential steps for a complex payment flow. Mentions the return value ('real result'). Could include more on error handling, but adequate for an agent to understand usage.

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 must compensate. It explicitly links each parameter to its source: endpoint and request_body from the 402, scheme and payment_id from the chosen offer, and txid from the payment. Adds critical meaning beyond schema 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?

The description uses a specific verb 'complete' and resource 'per-call coin payment'. It explains the context (after a 402 with pay_per_call_offers) and lists the required parameters, distinguishing it from a prepaid session.

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: after a paid tool returns 402 with pay_per_call_offers. Also mentions the alternative prepaid session, providing clear guidance on choosing this tool over its sibling.

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. It discloses the paid nature (~$0.01), the output (image_id as verification key), and reusability. While it does not discuss side effects or failure modes, the cost and outcome transparency is strong for a simple upload 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 a single sentence that front-loads the action and key details (upload, return value, cost). Every word is necessary and informative, 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 (single parameter, no output schema), the description adequately covers what the tool does, its inputs, outputs, and cost. It could mention size limits or overwrite behavior, but for most use cases it is sufficiently 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 description provides meaningful context for the single parameter program_b64 beyond the schema's minimal 'Program B64' title. It specifies base64 encoding and that it comes from risc0-build, which compensates for the 0% schema description coverage.

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 (upload), the resource (RISC Zero program binary), the format (base64), and the result (returns content-addressed image_id). It also distinguishes from siblings by specifying it's a one-time upload for reuse across proofs, which is a unique purpose.

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 explicitly state when to use this tool versus alternatives like prove_preflight or prove_submit. It implies usage for uploading a program before proving, but lacks direct guidance on selection criteria 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?

No annotations provided. Description discloses paid nature and non-proving execution, but lacks details on side effects (e.g., state mutation, credit consumption) or whether it's 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?

Extremely concise (two sentences), 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?

No output schema, but description mentions output fields. However, lacks parameter explanations and error handling details, which are needed for full self-containment.

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%. Description does not explain the two parameters (image_id, input_b64) or their purpose, missing critical guidance for correct invocation.

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 verb 'execute a guest WITHOUT proving' and specific output (cycle count, price quote). Distinguishes from siblings like prove_submit by emphasizing it's a pre-flight step.

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 advises 'Run this first' with rationale about proving cost scaling, and mentions cost (~$0.002). Does not explicitly name alternatives, but implication is clear.

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

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

With no annotations, the description carries full burden. It discloses that the tool queues a job, returns cost, and for max_kas it refuses if over cap. Does not mention any side effects, but it is a submission tool and the behavior seems fully described.

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 fluff. The first sentence is concise but uses arrow notation which might be unclear. Second sentence adds essential guidance. Well structured for quick reading.

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 no annotations, the description covers the submission flow and price behavior. However, it omits the required image_id parameter and does not describe the return format beyond job_id and cost_kas. Adequate but not fully 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?

Only two of four parameters (quote_id, max_kas) are explained in the description. The required 'image_id' is not mentioned, and 'input_b64' is also missing. Schema coverage is 0%, so description partially compensates but leaves gaps.

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 that the tool queues a proving job and returns job_id and cost_kas. Differentiates from siblings like prove_preflight, job_status, and job_result by mentioning the flow of using quote_id or max_kas. Could be more explicit about the verb 'submit' but sufficient.

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 on how to use the tool: pass either quote_id or max_kas, then poll job_status and fetch job_result. Implicitly tells when to use each option (preflight vs skip). Does not explicitly state when not to use, but covers the main usage pattern.

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?

Since no annotations are provided, the description must convey behavioral traits. It discloses that the tool fetches public pages, returns title and markdown, and allows distillation. However, it omits details on error handling, rate limits, or what happens with non-public pages, leaving some behavioral aspects unclear.

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, containing only two sentences that cover purpose, optional behavior, and usage context. It is front-loaded with the core action and outcome, making it efficient for an AI agent to parse quickly.

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 the lack of an output schema, the description explains the return values (title, clean markdown, and optionally key-fact bullets). For a tool with only two parameters, it provides sufficient context about inputs and outputs, though it could mention potential limitations like size or access issues.

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 needed to compensate. It does add meaning for the 'distill' parameter ('adds key-fact bullets') but does not elaborate on 'url' beyond its presence in the schema. This provides some semantic value but not full compensation.

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 (fetch), resource (public web page), and outputs (title + clean markdown). It also explains the optional distill mode. This differentiates it from the listed sibling tools, none of which perform the same function.

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 explicitly states when to use the tool: 'when you have no web access of your own'. It also mentions the cost, providing context for decision-making. However, it does not specify when not to use it or mention any 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?

No annotations are provided, so the description must convey behavior. It clearly indicates the tool retrieves information (services, reputation, address) and notes it is 'Free.' This implies a read-only, non-destructive action, though it could be more explicit about being 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?

Two concise sentences. The first sentence front-loads the primary purpose and output, while the second adds a note about cost. No unnecessary 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 single-parameter retrieval tool with no output schema, the description covers the main purpose and key outputs (services, reputation, address). It lacks details on error cases or limits, but is sufficient given simplicity.

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 no description for the parameter 'payee_pubkey', and schema coverage is 0%. The description clarifies that the parameter is used to identify the provider, adding meaning beyond the raw 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 it retrieves full detail on one provider by payee pubkey, listing services, reputation, and address. The name 'registry_provider' aligns with this, and it distinguishes from sibling tools like 'registry_search' which likely searches for providers.

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 specifies the input (payee pubkey) and implies usage when you have a specific pubkey and want comprehensive provider details. It mentions 'full detail' suggesting it is more thorough than alternatives, but does not explicitly state when not to use it or provide 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 are provided, so the description carries the full burden. It discloses that the tool is free, returns results ranked by reputation, and lists the returned fields. It does not mention rate limits or authentication, but for a read-only search tool this is adequate.

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 four sentences, front-loaded with the main purpose. Every sentence adds value 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 four parameters and no output schema, the description explains both input filtering and output fields. It lacks details on pagination or ordering beyond reputation-first, but overall it provides sufficient context for an AI 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?

The schema has 0% description coverage, but the description adds significant meaning to each parameter: capability with examples, max_price_usd as USD price, min_reputation_kas with context of settled KAS volume chain-verified. This compensates fully for 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 the tool discovers providers in a marketplace, with specific filtering and ranking. It distinguishes from sibling tools like 'registry_provider' by focusing on search and discovery.

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 clear context for use (discovering providers, filtering by capability/price/reputation) and implies when to use it. It does not explicitly state when not to use or mention alternatives, but the context is sufficient for an agent.

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 adds a cost hint (Paid ~$0.001 in KAS) but does not disclose other behaviors like data handling, rate limits, or whether it is read-only. It adds some value beyond schema but is not comprehensive.

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 plus a cost note. It front-loads the main purpose and each word contributes value. No unnecessary information.

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

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

For a simple tool with 2 parameters and no output schema, the description covers the basic operation and cost. However, it does not mention the expected output (rewritten text) or confirm that the entire text is rewritten. It is adequate but leaves 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%, so description must compensate. It mentions instruction can cover tone/format/length, which adds meaning to the parameter. However, it does not explain the 'text' parameter beyond being the input. Some semantics are added, but not exhaustive.

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 'rewrite' and the resource 'text', and specifies it is done per an instruction covering tone, format, length, etc. This distinguishes it from sibling tools like summarize or classify.

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 rewriting text with style/format modifications, but lacks explicit guidance on when to choose this tool over alternatives (e.g., summarize, extract). No when-not or prerequisite information 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 provided, the description carries the full burden of behavioral disclosure. It mentions paid cost and secret collection name but omits critical traits like what happens on duplicate documents, whether the replace parameter affects existing data, rate limits, or auth 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?

Two concise sentences with no fluff; each sentence provides essential information: the core action and critical usage notes (security, cost).

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 no annotations, the description covers the basic usage but lacks details on return values, error behavior, or idempotency. For a simple indexing tool, it is minimally adequate but not 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?

Schema description coverage is 0%, so the description adds value by specifying the document format (id, text, meta?) and that collection is a 'named server-side collection'. However, it does not explain the 'replace' parameter, leaving some semantic gaps.

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 'Store documents' with a specified format and purpose ('for semantic search'), distinguishing it from siblings like 'search_query' which likely handles querying. However, it does not explicitly differentiate from other storage-related tools like 'catalog'.

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

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

The description provides a security tip and cost information but lacks guidance on when to use this tool versus alternatives (e.g., 'catalog' or 'registry'). No explicit when-not or alternative tools 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?

No annotations, so description carries full burden. Mentions cost and output format, but does not disclose auth needs, rate limits, or side effects. Semantic search is read-only, but this is implied, not explicit.

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, front-loaded with purpose and output, then cost. No unnecessary 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 simple search tool with no output schema, it covers purpose, prerequisite, cost, and output type. Lacks parameter details, but schema provides types. Adequate for agent 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%. Description explains 'collection' (indexed collection) and 'top_k' (top-k matches), but 'q' (query) is not described. Partially compensates for two of three 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?

The description clearly states the tool performs semantic search on a previously indexed collection and returns top-k matches with scores. This distinguishes it from siblings like search_index (indexing) and registry_search.

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?

Indicates prerequisite (indexed collection) and cost (~$0.0003 KAS), implying when to use. Does not explicitly state when not to use or list alternatives, but context is sufficient.

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 bears the transparency burden. It discloses the tool is a read-only check and outlines the return fields. While it adds value beyond the empty schema, it could be more explicit about non-destructiveness and potential error states.

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 plus a two-word remark. Every word serves a purpose, and the most important information is front-loaded.

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 omits important context such as the need for an active session or error handling. Given the tool's simplicity, the description is adequate but not fully 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?

There are no parameters, so the description is not required to add parameter semantics. Baseline for 0 parameters is 4, and the description appropriately focuses on what the tool returns.

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 'Check the current payment session' and lists the specific information returned (deposit address, deposited/spent/remaining KAS). This distinguishes it from sibling tools like open_session (create) and use_session (use), making the purpose unambiguous.

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 no guidance on when to use this tool versus alternatives. It mentions 'Free' but does not explain if there are prerequisites (e.g., an active session) or contrast with other session-related 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, so the description carries the burden. It mentions the cost (~$0.001 in KAS) and input limit (max_words), but does not disclose idempotency, error handling, or side effects. The cost detail adds value.

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 plus a cost note. Every word earns its place, and the key information (action, inputs, constraint, cost) is front-loaded.

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, no parameter descriptions in schema, and 3 parameters, the description is incomplete. It omits the output format, error conditions, and detailed parameter usage (e.g., required fields, text vs URL rules).

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 must compensate. It states 'summarize text or a public URL' and mentions max_words, but does not clarify the relationship between the 'url' and 'text' parameters (mutually exclusive? both optional?), nor their expected 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 verb 'Summarize' and the resources (text or public URL), along with a key constraint (max_words). However, it does not differentiate from sibling tools like 'extract' or 'read_url', though the action is distinct enough.

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 basic usage (summarize text/URL with max_words) but offers no guidance on when to use this tool vs alternatives, no exclusions, and no prerequisites.

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

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

Discloses that it attaches a session key, returns current balance, and is free. No annotations present, so description carries full burden. Lacks details on idempotency or error cases but is fairly transparent.

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

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

Two front-loaded sentences, zero waste. Every sentence adds value without repetition.

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

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

Covers purpose, usage context, return value, and cost. Lacks error conditions but is complete given the tool's simplicity.

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 has 0% description coverage, but the description explains that the single parameter is a session key from open_session, adding meaning beyond the schema 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 uses specific verb 'attach' and resource 'existing k402 session key', clearly stating the tool's purpose. It distinguishes from siblings like open_session (creates) and session_status (checks 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?

Explicitly tells when to use: after reconnecting or to carry session across clients. Provides context but does not explicitly mention when not to use or alternatives, though sibling tools imply alternatives.

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