nukez-mcp

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

No annotations provided, so description carries full burden. It reveals that the server computes SHA-256 and records the hash, but does not mention side effects, idempotency, or error conditions. Adequate but 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?

Two concise sentences with front-loaded purpose. No unnecessary words; every sentence adds value.

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

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

Despite having an output schema and 2 parameters with zero schema coverage, the description does not explain parameters, return values, or error handling. Incomplete for a tool that is part of a multi-step upload process.

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 description provides no information about parameters (filename, receipt_id). Agent must rely solely on schema names and types, which lack descriptions. Description does not compensate for this 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 confirms a file upload after sandbox curl, specifying the verb 'confirm' and the resource 'file upload'. It distinguishes from siblings like nukez_store and nukez_upload_chunk by indicating it is a post-curl 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 says when to use: after executing the curl command from nukez_store in sandbox mode. Does not explicitly state when not to use or provide alternatives, but the context is clear enough for a multi-step workflow.

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. It explains the two-step workflow (get URLs, PUT to upload_url, call nukez_confirm), states bytes never transit the server, and mentions GCS redirects. Missing details on error handling or authentication, but covers the core behavior well.

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

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

Three sentences: first defines purpose, second explains workflow, third gives usage guidance. No redundant information, front-loaded, and every sentence adds value.

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

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

Provides a good overview of the workflow and differentiation from peers, but lacks parameter-level detail crucial since the schema lacks descriptions. The existence of an output schema reduces the need for return-value detail, but the parameter gap leaves incompleteness.

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 does not explain individual parameters (filename, envelope, receipt_id, content_type) beyond the general purpose. The agent cannot infer what each parameter does from the description alone.

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

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

The description clearly states the tool creates a file entry and returns upload and confirm URLs for direct upload. It uses specific verbs ('Create', 'get') and resource ('file entry'), and distinguishes from the sibling tool nukez_store for small content.

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

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

Explicit guidance provided: use for large files from local/external sources; for small inline content (<4KB), use nukez_store instead. This tells when to use and when not, with an alternative.

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

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

With no annotations provided, the description carries full weight. It discloses critical behaviors: permanent deletion, irreversibility, and attestation invalidation. It does not mention whether multiple files can be deleted (implied by array parameter) or any permission requirements, but the key behavioral traits are 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?

The description is extremely concise: two short sentences, no redundancy, and front-loaded with the core action. The warning is a single sentence that adds essential context. Every word serves a purpose.

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

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

Given the complexity (3 parameters, sibling tools, output schema), the description is minimal. It covers the core action and a critical side effect but lacks parameter explanations. The output schema exists, so return value documentation is partially covered. However, for a robust tool with multiple parameters and side effects, the description could be more complete.

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

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

Schema description coverage is 0%, so the description must explain parameters. The description only mentions 'files' but does not clarify how to specify them (via filenames array), nor does it explain envelope or receipt_id parameters. The agent lacks guidance on how to use these additional parameters, especially receipt_id which might be related to attestation.

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 ('Delete files') and the resource ('from your Nukez locker'). It distinguishes the tool from siblings like nukez_store or nukez_create_file by focusing on deletion. The warning about permanence and attestation further clarifies the tool's specific 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 implies cautious use by warning that deletion is permanent and irreversible, and it mentions invalidation of attestation. However, it does not explicitly state when to use this tool versus alternatives (e.g., nukez_recall or nukez_remember). The warning serves as a de facto usage guideline, but explicit comparisons would improve clarity.

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

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

With no annotations, the description fully discloses behaviors: the server is keyless, pre-flight checks for Solana SPL, error handling with structured WRONG_DESTINATION error, indeterminate fall-through, and that the quote remains valid on failure. This is comprehensive and goes beyond basic expectations.

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

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

The description is a single dense paragraph containing all necessary information without redundancy. Every sentence adds value, but it could be more structured (e.g., bullet points) for easier parsing. It is appropriately sized for the complexity.

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

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

Given the complexity (payment recording with pre-flight checks, error handling), no annotations, and 0% schema coverage, the description covers purpose, usage, parameters, and behaviors thoroughly. An output schema exists, so return value details are not required.

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

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

The schema has 0% coverage, so the description must add meaning. It explains all four parameters: tx_sig (pass the signature), pay_req_id (auto-resolved from state), chain and pay_asset (identify the rail with examples, defaults to quote's choice). It does not explicitly map to property names but context is clear.

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 'Record an externally-executed on-chain payment' with a specific verb ('record') and resource ('on-chain payment'). It also positions itself as 'Step 2' in a sequence, distinguishing it from sibling tools like nukez_quote and nukez_confirm.

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

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

The description provides clear usage context: after executing a transfer yourself, pass the signature. It mentions auto-resolution from nukez_quote and defaults. However, it does not explicitly mention when not to use this tool or compare it to alternatives like nukez_verify.

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 two modes, returns receipt_id and hint, and mentions rehydration without re-paying. However, it lacks details on side effects, permissions, and 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 with compact information, conveying both modes and parameter usage. Slightly long second sentence but 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 complexity (6 params, two modes, output schema exists), the description covers main use cases and return values. Lacks error scenarios but sufficient for typical 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 has 0% description coverage. The description explains 4 of 6 parameters (pay_req_id, tx_sig, envelope, receipt_id) with context, but omits chain and pay_asset. Adds significant meaning but incomplete.

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

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

The description clearly states the tool is for confirming payment and provisioning a storage locker, describing two modes of operation. It is specific about the action but does not explicitly differentiate from sibling tools like nukez_setup or nukez_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?

Provides good usage guidance by explaining two modes with parameter combinations. It tells when to use each mode but does not explicitly state when not to use or contrast with alternatives.

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

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

With no annotations, the description provides extensive behavioral context: it returns a price breakdown and payment methods with detailed instructions on destination_kind and spl_transfer blocks. It does not explicitly state read-only status, but the quoting nature implies no side effects. The level of detail is high.

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 longer but front-loaded with the main purpose. It includes step-by-step instructions and technical details. Some redundancy exists (e.g., listing payment methods twice), but every sentence contributes to understanding the tool's behavior.

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

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

Given 4 parameters and a complex output (payment options with nested blocks), the description covers providers, destination handling, and workflow connection to nukez_pay. It does not detail the 'units' parameter or the exact format of the price breakdown, but an output schema exists to fill that gap.

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

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

Schema coverage is 0%, so the description must explain parameters. It mentions defaults and providers for the 'provider' parameter, lists pay_asset and pay_network as nullable with defaults, but does not explain 'units' or the semantics of pay_asset/pay_network in depth. The description adds value beyond bare 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 is 'Step 1' for getting storage pricing and payment options, explicitly distinguishing it from sibling tools like nukez_pay (step 2). It describes the output as 'price breakdown and every available payment method' with specific asset lists.

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 positions the tool as the first step in a workflow, instructing users to 'pick one, then sign+submit externally and call nukez_pay'. It lists providers but does not explicitly state when not to use the tool or compare with alternatives. The context is clear for a sequential workflow.

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 should disclose behavioral traits like read-only safety, but it does not state that the tool is non-destructive or any authentication requirements. It implies a read operation but with no explicit safety declaration.

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 brief and front-loaded with the main purpose. The note about envelope is separate but not excessive. Every sentence serves a purpose, though the clarity of the second sentence could be improved.

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 8 optional parameters, no annotations, and a complex operation, the description lacks completeness. It omits details about the limit parameter, the optional nature of receipt_id, and any prerequisite or output structure hints despite the presence of an output schema.

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

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

Schema coverage is 0%, so the description must explain all 8 parameters. It covers key, namespace, tags, query, prefix, envelope, and receipt_id, but misses the limit parameter entirely, and the explanation of receipt_id is contradictory. Envelope is mentioned only to say it's not needed.

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

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

The description clearly states the tool is for searching and retrieving memory records, with two modes and return types. However, it doesn't differentiate from the sibling tool nukez_retrieve, leaving potential ambiguity.

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

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

The description outlines two modes but offers no guidance on when to use this tool vs alternatives. The statement 'Just pass receipt_id' is misleading because receipt_id is optional in the schema.

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 important behaviors: cost scales with total locker bytes (re-downloads everything), and notes the endpoint is unauthenticated with receipt_id as public proof. Missing details on error handling 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?

Single paragraph, no fluff. Front-loaded with core function, then cost, usage guidance, and auth note. Every sentence serves a purpose.

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

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

Given simple parameter set and presence of output schema, the description covers usage context, performance trade-offs, and authentication. Could mention potential errors, but overall complete for functionality.

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. It explains receipt_id is 'public proof of ownership' but does not elaborate on format, requiredness (default null), or where to obtain it. Adequate but not fully compensating 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 the tool performs a byte-level integrity proof by re-downloading files, recomputing hashes, and comparing against persisted attestation. It distinguishes itself from the sibling nukez_verify by noting its slower, full-recompute nature.

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

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

Explicitly provides when to use: audits, post-migration sanity checks, or suspected drift. Contrasts with nukez_verify for routine checks. Names the alternative tool directly.

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 carries the full burden. It discloses that memories are indexed for search and requires two envelopes, but omits critical details: idempotency, overwrite behavior on duplicate key, error conditions, auth requirements, and what 'locker:write' implies. This is a significant gap for a mutation 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?

The description is reasonably concise but could be more structured. It front-loads the main purpose but includes envelope details in a dense block. At 4 sentences, it is efficient but could be improved with clear bullet points for param 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 8 parameters, 0% schema coverage, and an output schema, the description is incomplete. It does not explain return values (a receipt? status?), nor does it cover all parameters. For a tool of this complexity, the description falls short of providing a complete picture.

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 key, content, summary, and namespace, but fails to describe tags, receipt_id, supersedes, and the envelope parameter structure (despite mentioning envelopes in the description, the parameter type is not clarified). Several parameters are left undocumented.

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

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

Description explicitly states 'Store a structured memory record in your Nukez locker' and mentions indexing for recall, distinguishing it from siblings like nukez_recall. The verb 'store' combined with the resource 'memory record' provides clear 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?

Some guidance is provided: namespaces for organization, required parameters, and envelope construction. However, it lacks explicit when-to-use vs alternatives like nukez_store, and does not mention scenarios where this tool should be avoided.

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 describes the dual behavior (list vs download) but lacks details on side effects, permissions, error handling, or the meaning of other parameters like encoding and receipt_id. Basic behavior is clear but not thorough.

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

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

The description is two sentences with no fluff. The first sentence defines the purpose, and the second gives actionable usage. It is front-loaded and efficient.

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

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

The description covers the main functionality (listing and downloading) and the use of the filenames parameter, but it omits explanations for three of four parameters. The presence of an output schema helps, but the description alone is not fully complete for an agent to correctly invoke the tool with all parameters.

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 'filenames' parameter but ignores 'encoding', 'envelope', and 'receipt_id'. This leaves a significant gap for the agent to understand how to use all 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 lists files or downloads content from the Nukez locker, and it distinguishes between the two modes based on the filenames parameter. This differentiates it from sibling tools like nukez_store (upload) and nukez_delete.

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

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

The description provides explicit usage patterns: call with no filenames to list, or with filenames to download. It covers the primary use cases but does not include when-not-to-use or compare with similar siblings like nukez_recall.

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 fully disclose behavior. It reveals the multi-step process (wallet check, purchase, provisioning) and lists providers and payment chains. However, it omits details on error handling, destructiveness, idempotency, or cost implications, which would help the agent assess risk.

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

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

The description is concise at four sentences, front-loaded with the core purpose, then usage modes, then configuration details. Every sentence adds value without repetition or fluff.

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

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

Given the tool's complexity (multi-step setup, multiple providers, payment chains, two modes), the description covers essential aspects adequately. The presence of an output schema reduces the need to detail return values, but mentioning the output type (e.g., receipt_id) would improve completeness.

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 'provider' by listing options and 'receipt_id' by describing its role in rehydration. However, 'units' and 'envelope' are not explained beyond their names, leaving their purpose ambiguous.

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 as 'Set up Nukez storage' with a specific verb and resource, and distinguishes it from sibling tools like nukez_provision and nukez_pay by combining wallet check, purchase, and provisioning in a single call. It also explains two distinct usage modes: no-args full flow and receipt_id rehydration.

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

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

The description provides explicit guidance on when to use the tool ('Call with no args' or 'Call with receipt_id'), and lists supported providers and payment chains, aiding decision-making. However, it does not explicitly state when not to use it or compare to alternatives like nukez_provision for partial setup.

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 for behavioral disclosure. It states it works at any stage but does not explicitly say it is read-only, lacks side effects, or mention authentication requirements or rate limits. The minimal behavioral information 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?

The description is extremely concise: two sentences, each adding essential information without redundancy. Front-loaded with the core action, it wastes no 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?

Despite having an output schema and a simple parameter set, the description omits any explanation of parameters. It does not guide the agent on how to use envelope or receipt_id, leaving ambiguity. The tool's purpose is clear, but parameter usage is unaddressed.

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

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

The description provides no explanation for the two parameters (envelope, receipt_id). Schema coverage is 0%, so the description must compensate, but it offers no guidance on their purpose or when to use them.

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 'Check' and specifies the resources: wallet balance, locker state, and lifecycle stage. It distinguishes itself from sibling tools like nukez_confirm or nukez_provision by indicating it is a read-only status check that works at any stage.

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 notes that it 'Works at any stage — no active locker required,' providing clear context for when to use the tool. However, it does not mention specific alternatives or when not to use it, though the sibling list implies other tools for other actions.

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 batching reduces on-chain attestations and SOL fees, details each upload method's behavior, and warns against base64-encoding large files. With no annotations, it fully carries the transparency burden.

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

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

The description is well-structured with headings and numbered lists, front-loading the critical batching instruction. It is somewhat lengthy but each sentence adds value, earning a 4.

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 batching, multiple upload paths, error handling, and chunking fallback. It does not describe return values, but an output schema is present. For the complexity, it is substantially complete.

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

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

The schema already provides per-parameter descriptions, so baseline is 3. The description adds significant value by explaining upload priority, batching logic, and constraints like size limits, which are not in the schema.

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

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

The description clearly states the tool stores files in a Nukez locker and distinguishes it from siblings like nukez_upload_chunk by specifying the batching requirement and upload path priority.

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 instructs to batch all files in a single call and warns against looping, citing cost and speed implications. It also provides a numbered priority list for upload paths and directs to nukez_upload_chunk for fallback.

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 stateless relay, SHA256 verification, hash mismatch handling, and the return of job_id/file_id from first chunk. No annotations exist, so description carries full burden; covers critical behavior but lacks error recovery details.

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

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

Well-structured with a purpose statement, code block for preparation, and bullet points for chunk upload steps. Slightly verbose due to embedded script, but necessary for completeness.

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 full chunk upload workflow, error handling (hash mismatch), and stateless relay requirements. Output schema exists for return values. Minor gaps: does not explain optional parameters like receipt_id.

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 explains 6 of 9 parameters (data_b64, sha256, part_no, is_last, job_id, file_id) and their roles in the workflow. Remaining parameters (filename, receipt_id, content_type) are less explained but filename is self-explanatory.

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 uploads files in chunks when sandbox curl/network is blocked, with a specific procedure. Distinguishes itself from sibling tools by its unique chunked upload functionality.

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 when to use (network blocked) and detailed step-by-step instructions including a bash preparation script. Lacks explicit mention of when not to use or alternatives, but the context is strong.

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 describes the tool as cheap with sub-second typical latency, explains push adds 5-10s delay, and warns against calling repeatedly. No contradictions.

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

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

Well-structured with a clear opening sentence, then details on push, then usage guidance. No unnecessary words, each sentence adds value.

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

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

Given 5 parameters (none required), output schema present, and no annotations, the description covers core behavior, latency, push behavior, and alternatives. Complete enough for an agent to use effectively.

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 explains memory_key ('verify a specific memory record by key') and push ('triggers fresh on-chain attestation push'), but does not describe envelope, filename, or receipt_id 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 it performs 'fast structural verification of locker state' and lists returned items (merkle root, attestation status, per-file proof). It distinguishes from the sibling nukez_recompute_verify, which does byte-level proof.

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 push=True and that it's normally unnecessary because auto-reattest after mutations. Also mentions alternative nukez_recompute_verify for byte-level proof.

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