SALT19 Agent Utility Grid

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

The description discloses paid execution ('Price: $0.50 via x402'), the challenge-then-signature flow, and the at-most-once retry contract enabled by a stable _salt19_operation_id. This goes beyond the annotations' idempotentHint=true by explaining how to actually achieve idempotency, though it does not fully describe payment-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?

Core behavior is stated first in a single sentence, followed by a compact payment and retry note. There is slight redundancy between 'preserve it across retries' and 'A stable _salt19_operation_id is required and makes semantic retries at-most-once,' but the overall description is efficient and 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?

With an output schema present and annotations covering idempotency and non-destructiveness, the description covers the key operational requirements: cost, challenge/signature order, and retry semantics. Missing use-case differentiation and fuller semantics for context and required_standard are minor gaps that do not block a competent agent.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds real semantics for _salt19_operation_id and _x402_payment_signature, but claim, context, evidence, required_standard, and _salt19_handoff_id remain only generically described in the schema itself.

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

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

The description opens with a specific verb ('Map') and a clear resource ('an autonomous agent claim or output to supplied evidence'), then enumerates the exact verdicts returned. This makes the tool's purpose unmistakable and distinguishes it from generic verifier siblings like agent-plan-verifier, even without naming 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?

It provides clear operational context for x402 payment and idempotent retries, and implies use when you have a claim and evidence to assess. However, it never states when to prefer this over agent-plan-verifier, verify-decision-receipt, or other verification tools, nor does it list exclusions or alternative conditions.

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 goes beyond the annotations by revealing the paid x402 flow: price, challenge, payment signature, operation ID, retry semantics, and at-most-once behavior. This is exactly the kind of side-effect and authentication context the agent needs, and it does not contradict the provided annotations.

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

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

The description is front-loaded with the purpose, then delivers payment and retry instructions in a few sentences. It is appropriately sized for a paid tool with payment semantics, though the repeated operation-id guidance could be tightened.

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 paid gate tool with an output schema, the description covers the payment challenge, signature step, retry behavior, and operation ID contract. The only meaningful gap is the contradictory required/optional phrasing around _salt19_operation_id, which keeps it from being fully unambiguous.

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 100% schema coverage, the baseline is 3, and the description does add useful guidance around _salt19_operation_id and _x402_payment_signature. However, it is internally inconsistent: 'A stable _salt19_operation_id is required' is immediately followed by 'recommended but optional', which could mislead the agent about whether the field must be supplied.

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

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

The description names a concrete verb and resource: 'inspect a supplied unified diff' and then enumerates the exact risk surfaces it evaluates, such as security-sensitive surfaces, destructive operations, and rollback risk. It also gives the boundary ('before an agent merges or deploys'), making it distinct from sibling preflight or verification tools even without naming one.

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 clearly says to use this tool 'before an agent merges or deploys', which gives the agent a concrete decision point. It does not explicitly mention alternatives or exclusions, but the intended scenario is specific enough for a capable agent to select it among the sibling tools.

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

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

Annotations already declare idempotentHint=true and readOnly=false; the description adds important behavioral context by disclosing the $0.50 price, the challenge-then-signature flow, and at-most-once retry semantics. The wording around 'required' vs 'recommended but optional' for _salt19_operation_id is slightly ambiguous, but it still goes well beyond the annotations.

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

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

The description is compact and front-loads the core decision output, price, and retry protocol. Every sentence serves a purpose, though the relationship between 'required' and 'recommended but optional' could be phrased more cleanly to avoid a mild internal tension.

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 paid, retry-sensitive nature and the presence of an output schema, the description covers the essential operational protocol: cost, challenge handling, operation id preservation, and the decision output. It is complete enough for an agent to invoke correctly, aside from not clarifying how it relates to sibling preflight tools and the slight optionality 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?

Schema description coverage is 100%, so the baseline ismet. The description adds real value for _salt19_operation_id and _x402_payment_signature by explaining their lifecycle across challenge, retries, and payment, which the schema does not convey. It does not elaborate on target/constraints, but those are already adequately described in the schema.

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

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

The description opens with a concrete action: return a bounded GO, WARN, or BLOCK decision with evidence and a portable SALT19 verification receipt, scoped to 'before an autonomous coding agent installs or adopts software.' This clearly states what the tool produces and when it applies, though it does not explicitly differentiate itself from similarly named preflight siblings.

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

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

It gives a clear invocation context ('Before an autonomous coding agent installs or adopts software') and adds operational guidance for the x402 flow: generate and preserve a _salt19_operation_id, then add _x402_payment_signature after the challenge. It does not mention exclusions or alternative sibling tools, so it stops short of a full routing guide.

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

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

Annotations already convey idempotent, non-read-only, and non-destructive hints. The description adds valuable operational behavior beyond those annotations: the $0.75 x402 payment requirement, the challenge-signature flow, the need to preserve _salt19_operation_id across retries, and the at-most-once semantic. The 'required' vs 'recommended but optional' wording around _salt19_operation_id introduces mild confusion, but it does not contradict the annotations.

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

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

The description is front-loaded with the primary purpose, and the following sentences cover payment and retry semantics without excessive length. It is slightly repetitive around _salt19_operation_id, and the required-versus-optional phrasing could be tightened, but overall each sentence contributes useful 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 paid verification tool with an output schema and six parameters, the description covers the essential purpose, result type, payment flow, and idempotent-retry contract. The output schema already exists, so not detailing return values is acceptable. It does not discuss alternatives or exclusions, but that gap is already reflected in the usage-guidelines score.

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

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

Schema coverage is 100%, and the schema already explains _salt19_handoff_id, _salt19_operation_id, and _x402_payment_signature in detail. The tool description reinforces the operation-id and payment-signature behavior but does not add much meaning beyond the schema for goal, plan, or constraints. Baseline of 3 is appropriate because the schema carries the parameter documentation burden.

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

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

The description states a specific verb ('Verify') and resource ('an autonomous agent plan before execution'), and enumerates the exact areas checked: missing preconditions, destructive steps, unsafe ordering, goal misalignment, constraint violations, and repair actions. It also names the bounded GO/WARN/BLOCK result, which clearly differentiates it from sibling output-verifier and preflight/gate tools.

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

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

'Before execution' gives clear context for when to use the tool, and the payment/retry instructions clarify the operational sequence. However, it does not explicitly mention when not to use it or name any sibling alternatives, so it stops short of full routing guidance.

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

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

The description adds meaningful behavioral context beyond annotations: it discloses the $0.01 x402 payment requirement, notes that ERC-20 metadata is best-effort, and clarifies that contract state is checked 'currently.' This supplements the idempotent and non-destructive annotations usefully.

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 compact and front-loaded with the core behavior, followed by pricing and a compatibility note. Every sentence provides useful information without padding.

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

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

For a relatively simple inspection tool, the description covers the essential purpose, output highlights, pricing, and an important optional parameter. The lack of an output schema is partially mitigated by stating that code size and ERC-20 metadata are returned, though exact response shape is not specified.

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 high (75%), and the schema documents the optional SALT19 and x402 parameters. The description adds a little clarity by emphasizing that _salt19_operation_id is recommended for x402 compatibility, but it does not substantially deepen understanding of the address parameter beyond what the schema already implies.

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

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

The description states a specific action and resource: 'Inspect whether a Base address currently has deployed bytecode and return code size plus best-effort ERC-20 metadata.' This clearly distinguishes the tool from sibling balance/status/allowance tools.

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

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

The usage context is implied by the description: use this when you need to know if a Base address has deployed bytecode or obtain ERC-20 metadata. However, it does not explicitly say when not to use it or mention alternatives such as base-token-balance or base-transaction-status.

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 says 'Read a live ERC-20 allowance', which strongly implies a read-only operation, but the annotations declare readOnlyHint=false. This is a direct contradiction in the tool's safety profile. The description does add useful context like price, payment method, and return format, but the contradiction forces a score of 1.

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

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

The description is three tight sentences with no filler. It front-loads the action and resource, then gives return details, price, and the key x402 parameter guidance. Every sentence carries operational 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 tool with no output schema, the description adequately states what is returned ('current block and raw token units'). It also communicates the paid nature and the optional salt ID. It does not fully explain the x402 challenge flow, but the input schema's description of _x402_payment_signature covers the required behavior, so the definition is reasonably complete.

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

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

Schema description coverage is 50%, and the three required address parameters have no schema descriptions. The description partially compensates by explaining their role in the allowance query, and it adds guidance that _salt19_operation_id is recommended but optional. The x402-related optional parameters are already described in the schema.

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

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

The description names a specific action ('Read'), a specific resource ('ERC-20 allowance on Base'), and the exact scope ('an owner/spender pair'). It also states the return value ('current block and raw token units') and a differentiator ('without an API key'), making it easy to distinguish from sibling tools like base-token-balance or base-contract-state.

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 clearly implies the use case: when you need an ERC-20 allowance on Base for a specific owner/spender pair. It does not explicitly name alternative tools or state when not to use it, but the context is specific enough that an agent can route correctly.

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

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

The description discloses meaningful behavioral details beyond the annotations: it is a live read, returns raw units with best-effort metadata, requires payment via x402, and works without signup/API key. The annotations already cover idempotency and non-destructiveness, so the added payment and metadata caveats are valuable context. No contradiction with annotations.

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

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

Two sentences with no filler. The core operation is front-loaded, followed by the payment constraint and the optional operation-id recommendation. Every clause adds decision-relevant 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 paid read tool with five parameters and no output schema, the description gives a solid high-level contract: raw units plus best-effort decimals/symbol metadata. The x402 workflow is covered in the schema descriptions, and the annotations cover idempotency/safety. Slightly more detail about output formatting or error cases would improve completeness, but the description is adequate for an agent to invoke the tool correctly.

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

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

The schema describes the three x402-related parameters well, but token_address and owner only have regex patterns and no semantic description. The description adds that token_address refers to an ERC-20 token and that decimals/symbol metadata is returned, but it does not explicitly define owner as the wallet holder or explain how raw units map to decimals. Overall the description partially compensates for the 60% schema 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 specifies the verb 'Read', the resource 'ERC-20 token balance on Base', and the output 'raw units plus best-effort token decimals/symbol metadata'. This distinguishes it from sibling tools like base-wallet-balance and base-token-allowance without needing to open their schemas.

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

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

The description gives useful context: it requires no signup or API key and costs $0.01 via x402. However, it does not explicitly say when to choose this tool over base-wallet-balance, base-token-allowance, or other siblings, nor does it state exclusions. Usage is implied from the resource name rather than explicitly guided.

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 adds useful behavioral context beyond the annotations, especially the $0.01 x402 payment requirement and the recommendation to preserve _salt19_operation_id. Annotations already mark the tool idempotent and non-destructive; the description aligns with those and does not contradict them. It stops short of describing not-found or timeout behavior, but the core cost and return behavior are disclosed.

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, with the action and output front-loaded. The price and operation-id note are compact and add value without repeating schema details.

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

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

With no output schema, the description usefully specifies the three possible return states and the block/gas evidence. It is missing edge-case behavior (e.g., unknown transaction hash) and the exact x402 challenge flow, but the core decision an agent needs—what statuses to expect—is covered well enough for a simple lookup 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 75%, so most parameters are already documented in the schema. The description adds meaningful guidance that _salt19_operation_id is recommended but optional for standard x402 compatibility, but it does not deepen the meaning of transaction_hash beyond the overall tool purpose.

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 ('Check') and clearly identifies the resource ('current Base transaction receipt state'). It also enumerates the exact returned statuses (PENDING, CONFIRMED_SUCCESS, CONFIRMED_REVERTED) and the included evidence, making it easily distinguishable from sibling tools like base-token-balance or base-wallet-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?

The description clearly implies when to use the tool: to check the current status of a Base transaction, likely after submission. It does not explicitly name alternatives or exclusion conditions, but the resource and output are specific enough that an agent can confidently select this tool among the listed siblings.

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

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

Adds valuable behavioral context beyond annotations: the $0.01 x402 price, the no-API-key access path, and live-at-latest-block semantics. The annotation says readOnlyHint=false, but the disclosed payment side effect makes this non-contradictory; idempotent and destructive hints are already annotated.

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

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

Two tight, front-loaded sentences with no filler. It states purpose, scope, pricing, and the key optional parameter in the minimum words needed.

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, scope, price, and no-API-key access, but does not describe the full x402 challenge/payment flow or the output format/units, and there is no output schema to fill that gap. The schema hints at the challenge flow, but return semantics remain underspecified.

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

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

Schema already documents three optional protocol parameters with clear descriptions; the description adds that address is the wallet being queried and that _salt19_operation_id is recommended but optional. With 75% schema coverage, it compesates only partially for the undocumented address parameter.

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

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

States a specific verb and resource: 'Read a wallet's live native ETH balance on Base at the latest block'. The 'native ETH' qualifier clearly distinguishes it from sibling token/allowance/state tools, so an agent can select it confidently.

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

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

Gives clear context: use when you need a native ETH balance on Base with no API key and are willing to pay via x402. It doesn't name alternatives explicitly, but 'native ETH' implicitly excludes token-balance and transaction-status 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?

The description adds meaningful behavior beyond annotations: the call costs $0.01 via x402, the decision is deterministic, it uses SHA-256 commitments, and a stable operation ID enforces at-most-once semantic retries. It also explains the first-call-challenge-then-signed-retry flow without contradicting the readOnlyHint, openWorldHint, or idempotentHint annotations.

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

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

The description is compact and front-loaded: main purpose, price, and then the retry/signature workflow in clear order. Every sentence contributes, and there is no boilerplate or restatement of the tool name.

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 paid, multi-parameter decision tool, the description covers the core function, trigger timing, cost, idempotency, and required signature flow. It could further explain WARN vs BLOCK semantics or explicitly distinguish itself from commerce-verify and related siblings, but the presence of an output schema reduces the need for return-value detail.

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 descriptions are mostly generic ('Input parameter X'), but the tool description supplies the missing domain meaning: request corresponds to the request, payment_required to the accepted payment offer, and policy to the machine spending policy. It also gives strong operational guidance for _salt19_operation_id and _x402_payment_signature, exceeding what the schema alone provides.

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

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

The first sentence names a concrete action and resource: binding the request, accepted payment offer, and machine spending policy into a deterministic GO/WARN/BLOCK decision before paying an x402 challenge. It also communicates the expected output shape and clearly separates this decision-gate tool from verify/receipt-oriented siblings.

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

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

The phrase 'Before an autonomous agent pays an x402 challenge' gives an explicit trigger for calling the tool, and the retry/signature instructions describe a clear workflow. It does not explicitly name alternatives like commerce-verify or x402-payment-preflight or state when not to use it, so it falls just short of full guidance.

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

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

Beyond the annotations, it discloses that the tool persists data, costs $0.04, is later Merkle-batched for inclusion proofs, and uses a stable operation id for at-most-once retries. This substantially enriches the readOnlyHint=false and idempotentHint=true annotations. No contradiction with the annotations is present.

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

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

The description is dense but efficient: purpose, price, idempotency contract, and signature flow are packed into four sentences. A small deduction is warranted because the 'required' vs 'recommended but optional' wording around _salt19_operation_id is slightly redundant and could confuse; the main purpose is nevertheless 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?

The tool is complex com 11 parameters and five required fields, and several required objects like delivery, settlement, and payment_payload are only described as 'Input parameter X' in the schema. The tool description gives a high-level mental model and cost/idempotency details, but it does not fully explain how to construct those required objects or how this tool relates to commerce-verify and x402-payment-preflight, leaving invocation partially underspecified.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by tying request, policy, payment, settlement, and delivery to the Commerce State Root evidence and by explaining the retry/signature flow for _salt19_operation_id and _x402_payment_signature. However, several parameters such as target_salt19_operation_id and _salt19_handoff_id receive no additional semantic explanation beyond the schema.

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

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

The description uses a specific verb-resource pair: 'Verify an x402 commercial state and persist a signed Ed25519 Proof402 receipt.' It also names the receipt's contents and later Merkle-batching, so the agent can distinguish it from read-only verify or preflight siblings even without opening the schema.

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

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

It gives actionable when-to-call guidance: generate a stable _salt19_operation_id per purchase, preserve it across retries, and add _x402_payment_signature after satisfying the challenge. It does not explicitly state when not to use it or name alternatives such as commerce-verify, so it stops short of a full routing contract.

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

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

Beyond the annotations, the description discloses the paid nature of the call, the challenge-then-signature sequence, and the at-most-once semantic-retry behavior tied to a stable operation id. The 'required ... optional' phrasing for _salt19_operation_id is slightly fuzzy, but it is consistent with the idempotentHint and does not contradict readOnlyHint=false or openWorldHint=true.

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

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

Three dense sentences front-load the purpose, then add cost, the retry-preservation workflow, and the idempotency guarantee. There is no filler and every sentence contributes actionable information for an agent.

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

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

Given the high complexity of 11 parameters, nested objects, and an output schema, the description provides the non-obvious protocol context needed to invoke the payment flow correctly. It does not explain optional correlation parameters such as _salt19_handoff_id or target_salt19_operation_id, but those are optional and the schema already defines their shapes.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds real meaning for _salt19_operation_id and _x402_payment_signature, but most other parameters such as policy, expected_delivery, target_salt19_operation_id, and _salt19_handoff_id are left to generic 'Input parameter' schema descriptions, and the description does not compensate for their protocol semantics.

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

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

The description opens with a precise verb and object: 'Verify that an x402 v2 payment payload, settlement evidence, original request, accepted offer, spending policy, and delivered response are mutually bound.' This focuses on a specific verification job and clearly distinguishes commerce-verify from commerce-decision and commerce-receipt siblings, whose purposes are decision and receipt generation rather than cross-artifact binding 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?

It gives actionable workflow guidance: generate one _salt19_operation_id per purchase, preserve it across retries, add _x402_payment_signature after satisfying the challenge, and expect a $0.02 x402 charge. It does not name alternative tools or provide explicit when-not-to-use conditions, so it stops short of a 5.

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

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

Beyond annotations, the description discloses the paid x402 flow, the need to generate and preserve _salt19_operation_id, the at-most-once retry semantics, and the requirement to include _x402_payment_signature after the challenge. This is substantial behavioral context that annotations alone do not provide.

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

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

The purpose is front-loaded and the payment instructions are relevant, but there is slight redundancy around _salt19_operation_id being required versus recommended/optional. Overall, the description is dense and useful without being bloated.

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 paid decision tool with an output schema and annotations, the description covers the essential operational flow: what the tool decides, what factors it considers, what the verdicts are, how payment works, and how to make retries idempotent. Nothing critical is missing for an agent to invoke it correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds real meaning for the payment-related parameters: how _salt19_operation_id should be generated and preserved, and when _x402_payment_signature should be omitted versus included. This justifies a score above baseline, though package/version semantics remain mostly delegated to the schema.

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

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

The description names a concrete job—decide whether an npm dependency is safe to install or adopt—and specifies the exact return vocabulary (GO, WARN, or BLOCK). It also lists the evaluation criteria (vulnerabilities, license, maintenance, etc.), which clearly distinguishes this from related package/decision tools.

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

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

It gives a clear use context: coding agents evaluating npm dependencies or packages for installation/adoption. It does not explicitly mention when not to use it or compare it to sibling tools like dependency-upgrade-go-no-go, so it falls short of a 5.

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

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

Beyond the annotations, the description discloses the $0.20 price, the x402 payment challenge-and-signature flow, and the at-most-once semantic retry contract tied to _salt19_operation_id. These are significant behavioral details that an agent needs before invoking the tool and are not available from annotations or schema alone.

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

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

At roughly 70 words, the description is concise and front-loads the core output categories in the first sentence before explaining payment mechanics. It is dense but not bloated; all sentences earn their place, though restructuring into bullets would slightly 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 the 9-parameter complexity and presence of an output schema, the description covers the essential caller-facing context: cost, payment challenge, idempotency, and the scope of the returned guidance. It leaves some input semantics (runtime, framework, constraints) implicit, but the listed output compatibility boundaries help infer their 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 100%, so the baseline is 3. The description adds real meaning to _salt19_operation_id and _x402_payment_signature by explaining their roles in purchase and retry flow, but it does not elaborate on runtime, framework, or constraints parameters beyond implying they affect compatibility boundaries.

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

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

The description names a specific verb ('Compare') and resource ('current and target npm versions') and enumerates the distinct decision outputs: GO/WARN/BLOCK, UPGRADE/DEFER/BLOCK guidance, bounded semver risk, OSV security implications, recommended tests, and NOT_PROVEN compatibility boundaries. This clearly differentiates it from the sibling 'dependency-go-no-go' by focusing on npm version upgrades.

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 the tool (when evaluating an npm dependency upgrade with current and target versions) but does not explicitly state when to prefer it over siblings like dependency-go-no-go or npm-package-intel. The detailed x402 payment and retry guidance is procedural rather than tool-selection guidance.

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

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

Annotations already declare the tool is read-only and idempotent; the description adds that routing is free, requires no payment, and returns schema plus x402 preflight next step. This is useful behavioral context beyond the structured annotations and matches the read-only, non-destructive profile.

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 compact and front-loaded with the core identity 'FREE START-HERE ROUTER.' Each sentence earns its place: what to provide, what to expect in return, and the free/no-payment constraint.

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 input types, the output components, and the no-payment condition, while the output schema handles return-value documentation. It is complete for routing use, though it could add one sentence on when not to use it or how direct sibling calls compare.

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 100% description coverage for all three parameters, including maxLength and defaults. The tool description reinforces what 'need' is for but adds no semantic detail about max_price_usd or prefer_fresh_state beyond what the schema already provides.

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

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

The description clearly identifies the tool as a 'START-HERE ROUTER' with a specific role: given a described need, it returns the best SALT19 tool, pricing, schema, alternatives, and next step. This distinguishes it from sibling tools that perform concrete data-fetching or verification operations.

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

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

The description gives clear context for when to use it: whenever the agent needs routing to the best tool for a fresh external fact, live state, developer intelligence, or bounded decision. It emphasizes 'START-HERE' and that no payment is required for routing, but it does not explicitly state when to skip this router and call a known sibling 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?

The description adds useful behavior beyond annotations: the $0.01 x402 price, reliance on current external repo state, and recommendation of _salt19_operation_id. Although readOnlyHint is false, the description does not claim to be purely read-only; the paid x402 flow explains the side effect. No annotation contradiction.

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

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

Two tight sentences: the first front-loads purpose and scope, the second conveys pricing and payment compatibility guidance. No filler or redundant restatement of the title.

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

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

For a paid facts-retrieval tool, it covers the core purpose, data scope, example facts, cost, and x402 operation-id hint. With no output schema, the listed facts provide a rough return-shape expectation. Minor gaps remain around repo format and error behavior.

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

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

Schema coverage is 75%, so most parameters are already described. The description mostly restates the optional/recommended nature of _salt19_operation_id but does not compensate for the undocumented required repo parameter, such as expected format or 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?

States a specific verb and resource: 'Return current public GitHub repository facts', with concrete examples like archive state, license, stars, forks, branch, and latest push. The phrase 'without the premium adoption decision' further distinguishes it from decision-oriented sibling tools.

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

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

Clearly frames the intended use: retrieving basic public GitHub facts rather than making an adoption decision. It does not explicitly name alternatives like repo-adoption-go-no-go, but the exclusion is clear enough to route most agents.

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 price, x402 payment challenge flow, the need to preserve _salt19_operation_id across retries, and the resulting at-most-once semantic. These details go well beyond the annotations, which only indicate idempotency and non-destructiveness. No contradiction with annotations exists.

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 and front-loaded with the tool's core purpose, followed by payment and idempotency details. It earns its sentences. The only structural weakness is a slight tension between saying _salt19_operation_id is 'required' and then 'recommended but optional,' which could confuse an agent if read 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?

Given the output schema exists and annotations carry safety hints, the description supplies the missing operational context: cost, x402 challenge flow, signature requirement, and idempotent retry semantics. An agent has enough information to correctly invoke the tool and handle the payment handshake.

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 already documents all four parameters, and the description adds crucial operational meaning for _salt19_operation_id and _x402_payment_signature: generate once, preserve, omit on first call, include after challenge. The repo parameter format is still somewhat generic, but the description's use case makes its intent 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 states a specific verb and resource: 'evaluate whether a public or open-source repository is safe and maintained enough to adopt,' and lists concrete signals like license, maintenance, release freshness, and activity. This clearly distinguishes it from fact-fetching siblings like github-repo-facts and decision-oriented tools like repo-adoption-go-no-go.

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

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

It provides a clear use case: coding agents performing due diligence before adopting a repository. It also explains the payment flow and idempotent retry behavior. However, it does not explicitly name alternatives or give when-not-to-use guidance, so it misses the top bar.

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?

Adds meaningful behavior beyond annotations: payment price, x402 challenge/signature flow, and at-most-once semantics tied to preserving _salt19_operation_id across retries. This deepens the idempotentHint=true annotation without contradicting readOnlyHint=false.

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 information-dense and front-loads the purpose, but the x402/payment guidance is somewhat repetitive and the operation-id lines read as contradictory ('required' vs 'recommended but optional'). It earns its place but could be tightened.

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 purpose, the payment protocol, and retry semantics, while the output schema covers return values and the schema covers parameter definitions. For a tool with 7 params and an output schema, this is largely complete, though it omits guidance on runtime_overhead_ratio and _salt19_handoff_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?

Schema coverage is 100%, so the baseline is 3. The description adds semantics for _salt19_operation_id and _x402_payment_signature (generate once, preserve, include after challenge), but it does not clarify the meaning or units of the three required numeric parameters, which have only tautological 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 explicitly states it estimates model memory requirements and checks whether a quantized LLM fits available GPU VRAM, with a clear use case ('before loading or local inference'). The verb-resource pairing is specific and none of the sibling tools overlap with this model-memory fit 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?

It gives clear context for when to use: before loading or running local inference. It does not name alternatives or exclusions, but none of the listed siblings are obvious substitutes, so the 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?

Annotations already cover idempotency and non-destructiveness; the description adds the live-registry source, version-selection behavior, the $0.01 x402 payment expectation, and the optional operation id for retry compatibility. The readOnlyHint=false annotation is not contradicted because the paid x402 flow implies a financial side effect, which the description discloses.

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 no filler: the first sentence delivers purpose and differentiation, and the second covers the key payment/operation-id detail. The most decision-relevant 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?

The description explains the core purpose, pricing, and version behavior, but with no output schema it does not enumerate what 'facts' are returned (e.g., license, maintainers, dist-tags). The x402 challenge/retry flow is left to the schema parameter descriptions rather than the tool summary, leaving minor gaps for an agent invoking a paid 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 60%, and the three salt/x402 parameters already have their own schema descriptions. The tool description adds the missing semantic context for package and version by clarifying that the version is optional and that 'latest or requested' version is returned, which is important behavior not present in 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 states a specific verb and resource: 'Return live npm registry facts' for the 'latest or requested package version.' It also differentiates itself from the higher-priced vulnerability/adoption layer, which aligns with the sibling npm-package-intel tool, so an agent can identify what this tool is and is not.

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 phrase 'without the higher-priced vulnerability and adoption decision layer' gives clear context for when this tool is appropriate: when basic registry facts are needed, not vulnerability or adoption analysis. It does not explicitly name sibling alternatives or provide a when-not-to-use list, but the contrasting language is sufficient direction.

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

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

Annotations only indicate non-read-only, idempotent, and non-destructive intent. The description adds substantial behavioral context: the $0.05 x402 cost, the challenge/signature payment handshake, and the at-most-once retry semantics tied to a stable operation id. The contradiction between '_salt19_operation_id is required' and 'recommended but optional' slightly muddles the disclosure, preventing a 5.

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

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

The purpose is front-loaded and the sentences are mostly short. However, the last two sentences about _salt19_operation_id are redundant and mutually contradictory, saying it is 'required' and then 'recommended but optional' for standard compatibility. This weakens the structure and means not every sentence earns its place.

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

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

The x402 payment flow is complex, and the description does cover payment, retries, and signature handling while an output schema exists to document return values. But it never clearly states the first-call-returns-challenge / second-call-returns-result sequence, and the operation-id requirement conflict leaves ambiguity about the exact call contract. For a paid tool with this many parameters, a bit more precision is needed.

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

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

Schema coverage is 100%, but the schema descriptions are weak tautologies like 'Input parameter package for the npm-package-intel tool'. The description compensates by explaining the meaning and lifecycle of _salt19_operation_id and _x402_payment_signature, including when to omit or include the signature. It does not add much for package/version, but the tool purpose already gives context.

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?

Opens with a specific verb and target: 'Check whether an npm package is deprecated or vulnerable before installing it', then enumerates concrete signals such as vulnerabilities, license, maintenance, freshness, dependency health, and package.json risk signals. This clearly identifies what the tool does and helps distinguish it from related siblings like npm-package-facts.

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 anchors usage to a clear moment: 'before installing it'. It also provides operational guidance for the paid flow: generate one _salt19_operation_id per purchase, preserve it across retries, and add _x402_payment_signature after satisfying the challenge. However, it does not explicitly mention alternatives or when-not-to-use conditions, so it stops short of a 5.

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

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

Annotations already convey idempotency and non-destructiveness, so the description need not repeat those. It adds useful behavioral context by disclosing the $0.01 x402 price and the recommendation to include _salt19_operation_id for x402 compatibility. However, it does not explain the expected challenge/payment flow or what happens when no alerts exist, which would be more transparent for a paid 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 filler. The main purpose is front-loaded, and the payment/x402 compatibility note is the only additional information included. Every sentence earns its place.

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

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

For a tool with no output schema, the description gives only a minimal promise of 'compact structured JSON' and does not describe the alert payload shape, empty-result behavior, or the x402 challenge-retry sequence. The schema covers the optional payment-related parameters, but an agent would still need to infer some call sequencing. It 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?

The schema leaves `area` and `limit` without field descriptions, and the overall schema description coverage is 60%. The description compensates partially by clarifying that `area` is a U.S. state or territory and that results are compact structured JSON. It also adds rationale for `_salt19_operation_id`. Still, `limit` behavior and the exact meaning of the area code format remain implicit.

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

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

The description opens with a specific verb ('Return'), a clear resource ('current U.S. National Weather Service active alerts'), and a precise scope ('for a state or territory'). It also specifies the output format as compact structured JSON, making the tool's function immediately apparent and distinct from the unrelated sibling tools.

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

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

The description provides clear context for when the tool should be used: whenever current NWS active alerts for a specific state or territory are needed. It also signals the payment prerequisite via x402 and recommends the operation ID, which helps an agent prepare the call. It does not explicitly name exclusions or alternative tools, but no close weather-alert alternatives appear among the siblings.

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

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

Beyond the annotations, the description discloses substantial behavioral context: a $0.35 x402 price, the challenge/signature payment flow, the need to preserve _salt19_operation_id for at-most-once semantic retries, and explicit UNKNOWN/NOT_PROVEN boundaries for claim types. This meaningfully enriches what the annotations alone convey about idempotency and open-world behavior.

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

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

The description is organized purpose-first, then payment and idempotency mechanics. It is somewhat dense and repeats operation_id guidance across multiple sentences, but each sentence contributes useful information and there is no filler.

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

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

Given the presence of an output schema, return-value documentation is unnecessary. The description covers purpose, evidence sources, uncertainty boundaries, cost, payment protocol, and retry semantics, so an agent has sufficient context to invoke the tool and complete the full payment flow correctly.

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

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

Schema coverage is 100%, and the tool description adds practical semantics for the x402 parameters (generating operation IDs, preserving them across retries, adding the payment signature after challenge). The repo parameter's schema description is a tautology, but the tool description's emphasis on 'public GitHub' provides enough context for the agent to infer it expects a repository identifier.

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

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

The description states a specific, non-tautological purpose: it produces a 'Repository adoption decision' based on public GitHub maintenance, archive, license, and repository-health evidence. This clearly differentiates it from sibling tools like dependency-go-no-go or github-repo-facts, which target different subjects or evidence.

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 no explicit guidance on when to use this tool versus alternatives. It mentions the intended audience ('autonomous coding agents') but does not say when a preflight or facts-only tool would be more appropriate, nor when this decision tool is the right choice. No exclusions or alternative routing are provided.

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

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

The description discloses that this is a telemetry tool, implicitly indicating that submitted data is sent externally. It adds an important safety boundary: 'Never submit private keys, payment signatures, or secret wallet material.' This goes beyond the annotations, which only report non-read-only, non-idempotent, and non-destructive hints without explaining actual behavior.

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

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

Two sentences with no filler. The core purpose is front-loaded, and the safety caution about secrets is directly actionable. Every clause earns its place, and the description is appropriately sized for a relatively simple telemetry tool.

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

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

The description covers the core purpose and the critical security constraint, which is good for an optional telemetry report. However, with no output schema and no mention of whether the call returns a result, is fire-and-forget, or has requirements around decline_reason, an agent still lacks full context about what happens after invocation. It is adequate but not 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 only 11%, and the description does not compensate by explaining any of the nine parameters. The description alludes to payment capability and decline reasons but never maps those concepts to the actual params like supports_x402, decline_reason, max_purchase_usd, or supported_networks. Parameter names and enums are somewhat self-explanatory, but the low coverage leaves too much for the agent to infer.

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

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

The description states a specific verb ('reporting') and a clear resource ('whether a client can use x402/Base/USDC or why it declined'). This distinguishes it from sibling tools like x402-payment-preflight and report-x402-authorization-progress, which focus on different phases. The title reinforces the purpose without 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 implies the tool is for contributing telemetry about x402 payment capability, but it does not explicitly state when to use it versus related sibling tools. It says 'Free cooperative telemetry tool' which suggests usage context, but no when-not-to-use guidance or alternative routing 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?

Annotations already indicate idempotentHint=true and readOnlyHint=false; the description complements this by emphasizing that only stage metadata should be reported and that sensitive values must never be included. This adds data-handling context, but it does not disclose other behavioral traits such as side effects, failure modes, or whether external telemetry is transmitted.

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, minimal filler, and the core action appears in the second sentence right after a concise scoping phrase. It loses a point because the first sentence is a noun phrase rather than a direct action statement, slightly reducing scannability.

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?

This is a 7-parameter telemetry tool with no output schema, no parameter descriptions, and minimal behavioral disclosure. The description is enough to understand the high-level intent but not enough to know expected return values, error handling, or how to fill several fields correctly.

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

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

With 0% schema description coverage, the description must compensate, but it only names what not to send and refers generically to 'stage metadata.' It does not explain handoff_id, stage, error_code, signer_kind, client_timestamp, signer_available, or sdk beyond what their property names and enums already imply.

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 identifies a specific action ('Report ... telemetry') and a specific resource ('local buyer authorization path'), which lets an agent distinguish it from handoff and preflight siblings. It falls just short of a 5 because it does not explicitly contrast with any sibling or say what makes it 'cooperative' in operational terms.

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 phrase 'for the local buyer authorization path' gives useful context about when this telemetry call belongs. However, it does not state exclusions, prerequisites, or mention alternatives, leaving the agent to infer when to use this tool versus other x402-related siblings.

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

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

Annotations already establish readOnly, idempotent, and non-destructive behavior. The description adds meaningful behavioral context: 'FREE,' 'discoverable,' 'live x402 prices,' and 'Fresh-State acquisition roles,' which go beyond the annotations and help the agent understand the data freshness and scope.

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

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

The description is a single, front-loaded sentence that states the core value proposition first ('FREE catalog/pricing surface') and packs the key return items and purpose into the remainder without wasted words.

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

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

For a read-only, no-required-param pricing query with an output schema and clear annotations, the description covers what the tool does, why to use it, and its free status. The only notable gap is parameter-level guidance, which is minor for this 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 description coverage is 0%, so the description bears the burden of explaining the parameters. It does not explain 'tier' or 'max_price_usd,' though 'budget' hints at price filtering. The enum values are visible in the schema, but the description adds no semantic meaning beyond that.

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 ('Returns') and names concrete resources: SALT19 products, live x402 prices, schemas, and Fresh-State acquisition roles. It also clearly frames the tool as a free catalog versus paid calls, distinguishing it from cost-incurring siblings.

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

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

It explicitly says the tool is for budgeting 'before choosing a paid call,' giving a clear use case and timing. It does not name specific sibling tools or state when not to use it, but the free-vs-paid framing provides adequate context.

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

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

The description adds valuable behavior beyond annotations: it discloses the $0.01 x402 price, the 'live' nature of the feed, the presence of source dates and units in the result, and the recommended optional operation id. It does not detail retry/challenge flow, but the schema already documents the payment-signature field.

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

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

Two tight, front-loaded sentences: function first, then cost and x402 compatibility guidance. Every sentence earns its place and no filler is present.

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 paid, live-data retrieval tool with no output schema, the description gives the price, the payment method, the output ingredients, and the optional operation id. The schema covers the required cik and payment chaining fields. A remaining gap is the lack of explicit linkage between 'selected facts' and the concepts parameter, but an agent can still invoke the tool correctly.

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

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

With schema_description_coverage at 60%, the schema already explains the x402/payment parameters, and the description reinforces operation-id usage. However, the description does not explicitly map 'selected' to the concepts parameter or explain CIK/concept selection behavior beyond the schema constraints.

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

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

The description states a clear verb and resource: return selected latest SEC XBRL company facts from EDGAR's live companyfacts feed, including source dates and units. It is specific enough to distinguish from sec-recent-filings, but it never explicitly names alternative siblings, so it stops short of full 5.

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

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

There is no guidance about when to choose this tool versus sec-recent-filings or the other fact-lookup tools. The description implies its niche through the 'companyfacts' wording but offers no exclusions, prerequisites, or alternative-selection logic.

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

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

Annotations already provide idempotentHint=true, destructiveHint=false, and openWorldHint=true. The description adds useful context about the live feed, normalization for agents, and the $0.01 x402 payment requirement. However, it does not explain the implications of readOnlyHint=false for a tool that ostensibly only returns data, nor the payment challenge flow.

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 short and front-loaded with the core purpose. The price and operation_id sentence are useful but partially duplicate the schema's own description of `_salt19_operation_id`, so the structure is good but not maximally tight.

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

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

With no output schema, the description should explain what shape the normalized filings take, but it only says 'normalized for agent consumption.' It also omits `limit` semantics and provides no differentiation from sec-company-facts. The price and source are helpful, but significant context an agent needs to invoke this correctly is missing.

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

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

Schema coverage is only 60%, and the two undocumented parameters include `limit`, which has no schema description and is not mentioned in the tool description. The description adds some semantic context for `cik` ('company CIK') and repeats the operation_id recommendation, but it does not compensate for the missing guidance on `limit`.

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 a specific action ('Return'), a specific resource ('recent SEC EDGAR filings for a company CIK'), and a source ('live SEC submissions feed'). It does not explicitly contrast with the sibling tool sec-company-facts, so it stops short of a full 5, but the resource type is specific enough for an agent to form an initial expectation.

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

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

There is no guidance about when to choose this tool over sec-company-facts or other SEC-related tools. The description mentions price and an optional operation ID, but does not state conditions, exclusions, or 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?

Beyond the annotations, the description discloses the $0.03 x402 price, the challenge-and-payment-signature flow, and the requirement to preserve a stable _salt19_operation_id for at-most-once semantic retries. It also states what the tool checks, providing behavioral context that annotations do not cover.

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

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

The description is front-loaded with the central purpose and then gives essential payment and retry instructions. It is compact and each sentence earns its place, though the operation-ID guidance is somewhat redundant with the schema descriptions, preventing a 5.

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

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

For a paid external preflight tool, the description covers purpose, checks performed, cost, payment flow, and retry semantics. An output schema exists, so detailed return-value documentation is not required here. It does not define what 'healthy and safe' means as a threshold, but that is likely expressed through the 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 description coverage is 100% and the input schema already contains detailed descriptions for _salt19_operation_id and _x402_payment_signature. The main description mostly restates that guidance, adding only emphasis that a stable operation ID is required for at-most-once retries. This is helpful but not a substantial new layer of parameter 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 states a specific verb and resource: inspect a URL before an autonomous agent calls it, and preflight or verify a website or external API endpoint. It enumerates concrete checks (HTTP status, redirects, latency, security headers), which clearly distinguishes it from sibling tools like github-repo-preflight or x402-payment-preflight.

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 usage context: use this tool before calling a URL to verify the endpoint is healthy and safe. It does not explicitly list when-not-to-use conditions or name alternatives, so it stops short of a 5, but the context is sufficiently directive.

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

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

It discloses meaningful behavior beyond the annotations: it removes scripts/styles/navigation noise, returns bounded Markdown, includes canonical URL and provenance, and has a $0.01 x402 price. IdempotentHint and destructiveHint already cover retry safety; no contradiction with annotations.

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

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

Two sentences with no filler. The first sentence states the core operation, transformation, and output; the second provides pricing and the optional operation-id recommendation. It is front-loaded and every sentence earns its place.

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

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

For a paid x402 tool with no output schema, the description adequately names the return components and cost, while the input schema covers the payment handoff fields. Minor gaps remain around max_chars defaults and the exact provenance structure, but an agent has enough to invoke it correctly.

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

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

Schema description coverage is 60%, with three x402/salt fields already described. The description reinforces _salt19_operation_id as recommended and hints at max_chars through 'bounded', but it does not explain max_chars behavior or default, and url has no description in the schema or the tool description.

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

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

The description names a specific action ('Fetch'), a clear resource ('a public web page'), and a concrete outcome ('LLM-friendly Markdown plus canonical URL and fetch provenance'). It also mentions noise removal and output bounding, which distinguishes it from sibling tools like url-http-preflight.

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

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

The description provides clear context: use this when you need a cleaned, bounded Markdown version of a public web page, with a stated price. It does not explicitly contrast with sibling tools such as url-http-preflight or explain when not to use it, but the intended use case is evident.

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 a paid invocation ('Price: $0.01 via x402'), flags the recommended SALT19 operation id for compatibility, and notes the response is 'compact live event state.' These are useful behavioral details beyond the annotations, and the readOnlyHint=false is plausibly explained by the payment side effect rather than data mutation.

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

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

Three short sentences with no filler: the core query purpose is front-loaded, and the payment and compatibility guidance are isolated after it. Every sentence earns its place.

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

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

With no output schema, the description should explain more about what an agent will receive; 'compact live event state' is vague about fields or format. The payment and parameter guidance is adequate, but the return-shape gap prevents full contextual 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?

The description maps 'lookback window' to hours and 'minimum magnitude' to min_magnitude, adding meaning the schema does not provide for those fields. However, it does not mention 'limit,' and the x402/SALT19 parameters are already documented in the schema, so the semantic coverage is partial rather than complete.

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

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

The description states a specific verb ('Query'), resource ('recent USGS earthquake events'), filtering criteria ('lookback window and minimum magnitude'), and return style ('compact live event state'). It is immediately distinguishable from all listed siblings, none of which cover earthquake data.

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

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

The description gives clear context: use this when you need recent USGS earthquake events filtered by time and magnitude. It does not explicitly list when-not-to-use cases or name alternatives, but no sibling tool competes for this purpose, so the usage 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?

Goes well beyond the readOnly/idempotent/non-destructive annotations by explaining exactly what verified=true proves and, critically, what it does not prove. This prevents an agent from over-interpreting the result and is genuinely useful behavioral disclosure.

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 short and front-loaded with the core semantics. The second sentence's compatibility note adds useful context, but the parameter-like phrasing of '_salt19_operation_id' creates slight confusion and keeps it from being perfectly clean.

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 one documented parameter and an output schema present, the description provides enough context for normal invocation. The only notable gap is the unresolved relationship between _salt19_operation_id and the actual input schema, which leaves an ambiguity about whether additional inputs are accepted.

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 fully documents the single id parameter, so parameter description is not necessary. However, the description introduces '_salt19_operation_id' as recommended but optional even though the schema contains only id and has additionalProperties:false, which could mislead an agent into passing a disallowed parameter.

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

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

States a specific action ('verify') on a specific resource ('SALT19 decision receipt') and clarifies it is an integrity lookup. It also distinguishes itself by defining verified=true as 'stored evidence still matches its recorded digest' and explicitly denying that it proves software safety.

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?

Clearly frames when the tool is appropriate ('Free integrity lookup') and what its result does and does not mean, which is strong contextual guidance. It does not explicitly name sibling alternatives such as find-salt19-tool or commerce-verify, so there is no direct when-not comparison.

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 adds meaningful behavioral context beyond the annotations by stating it 'never signs or moves buyer funds' and that it creates a live challenge plus correlation ID. This reinforces the readOnlyHint and idempotentHint=false without contradicting the structured annotations, though it does not discuss challenge expiration or other lifecycle details.

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

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

The description is compact and front-loaded with the core purpose and outputs, and the second sentence adds a valuable safety boundary. The word 'Free' adds little functional signal and could confuse agents into thinking cost is relevant, but overall the structure is tight 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?

With four parameters, no output schema, and several closely related sibling tools, the description covers core behavior but not enough to fully orient an agent: parameter roles are unexplained and usage boundaries versus preflight/reporting tools are absent. It provides a useful high-level picture but not complete invocation guidance.

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

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

Schema description coverage is only 25%, and the tool description does not explain product, session_id, operation_id, or how arguments should be structured beyond what little the schema provides. The description mentions a 'concrete paid request' but does not connect that to the parameters, so an agent would have to guess key input semantics.

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

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

The description states a specific verb-resource-purpose: it generates a live PAYMENT-REQUIRED challenge, returns REST and MCP retry templates, and creates a correlation ID. It is clearly distinguishable from related siblings like x402-payment-preflight and report-x402-authorization-progress, which focus on preflight/checking rather than handoff challenge generation.

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 phrase 'for a concrete paid request' implies when the tool should be used, but the description never explicitly contrasts it with alternatives such as x402-payment-preflight or report-x402-authorization-progress. There is no when-not-to-use or 'use X instead' guidance, leaving the agent to infer selection 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?

The annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is partially covered. The description adds meaningful behavioral context beyond the annotations: the tool queries a 'live' price, performs an 'optional public wallet-balance sufficiency' check, and 'without signing or moving funds' clarifies exactly what side effects are absent.

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, well-structured sentence that front-loads the main purpose and then lists return categories and safety boundaries. Every clause earns its place, and there is no redundant repetition of the tool name or schema fields.

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

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

For a tool with 7 parameters and no output schema, the description gives a useful high-level summary of return categories but not enough detail about how parameters affect behavior or what the actual response shape looks like. It is adequate for understanding the tool's role, but an agent would likely need to inspect schemas or examples to confidently invoke it with the right combination of fields.

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

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

Schema description coverage is only 14%, so the description must compensate for undocumented parameters, but it does not. It references 'optional public wallet-balance sufficiency' which maps to wallet_address, but it never explains product, max_price_usd, supports_x402, supported_assets, supported_networks, or autonomous_spend_allowed. The schema itself is mostly silent, leaving an agent without enough parameter-level guidance.

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

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

The description names an explicit purpose ('buyer-side compatibility preflight') and a specific resource (SALT19/x402 payment), and states what it returns: live price, Base/USDC requirement, optional wallet-balance sufficiency, and next action. It also signals a key boundary by saying it does not sign or move funds, which distinguishes it from authorization or execution tools like x402-authorization-handoff.

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 phrase 'buyer-side compatibility preflight' clearly implies this tool should be used before any signing or fund movement, and 'without signing or moving funds' reinforces the safe preflight context. However, it does not explicitly name sibling tools or state when not to use it, leaving some routing to inference rather than explicit guidance.

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