SALT19 Agent Utility Grid

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

Annotations cover the safety profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false), but the description adds substantial context the annotations don't: a $0.47 x402 price, the payment challenge/signature flow, and the at-most-once idempotency contract tied to a stable operation id. This is genuine value beyond structured data; it lacks only detail on failure/timeout 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 purpose and verdict set are front-loaded in the first sentence, and the payment mechanics are stated compactly. The second half pivots to x402 logistics, which dilutes focus slightly but each sentence carries operational 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?

An output schema exists, so return values need not be explained. The description supplies the payment/idempotency guidance needed to invoke a paid x402 tool correctly and covers the core verification flow, leaving only edge-case error behavior unspecified.

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

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

Schema description coverage is 100%, so the schema already documents all 7 parameters, setting the baseline at 3. The description reinforces the semantics of _salt19_operation_id and _x402_payment_signature, but adds no meaning for claim, context, evidence, or required_standard beyond what the schema provides.

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

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

States a specific verb+resource ('Map an autonomous agent claim or output to supplied evidence') and enumerates the exact output verdicts (SUPPORTED, PARTIALLY_SUPPORTED, NOT_PROVEN, CONTRADICTED). This clearly distinguishes it from sibling verifiers like agent-plan-verifier and agent-decision-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?

Describes the input situation (a claim/output plus evidence) and gives retry/payment procedure, but never states when to choose this over sibling verifiers (agent-plan-verifier, commerce-verify, agent-code-change-risk-gate). Usage is implied rather than contrasted.

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 destructiveHint=false, so the description correctly focuses on what annotations don't cover: the $1.22 x402 price, the at-most-once retry contract, and the payment-signature handshake. However, the closing lines ('required' then 'recommended but optional') muddy the behavioral contract for the operation_id.

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 well and the payment flow is relevant, but the final two sentences are redundant and internally contradictory, restating the same operation_id guidance in conflicting terms. That contradiction costs clarity against an otherwise efficient structure.

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?

An output schema exists, so return values need no explanation, and the description covers purpose plus the non-obvious x402 payment mechanics an agent must handle. It is nearly complete for this complexity, with the only gap being the ambiguous required-vs-optional status of the operation_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?

The schema has 100% description coverage, but the diff/context/constraints descriptions are generic placeholders that add no real meaning. The description does add genuine semantics for _salt19_operation_id (generate once, preserve across retries) and _x402_payment_signature (omit first, add after challenge), so it exceeds baseline slightly but leaves the three core input params (diff format, context, constraints) unexplained.

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

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

The description gives a specific verb ('inspect') and resource ('supplied unified diff') plus the exact risk surfaces it evaluates (security, destructive ops, constraint conflicts, rollback, breaking changes). It clearly frames itself as a pre-merge gate, which distinguishes it from siblings like agent-plan-verifier and agent-decision-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?

It states the trigger context clearly ('before an agent merges or deploys') and adds payment-flow guidance for when to include the signature versus omit it on the first call. It does not explicitly name a sibling alternative or state when NOT to use it, 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?

Annotations only supply generic hints (readOnly=false, openWorld=true, idempotent=true), so the description carries real weight and delivers: it discloses the $0.46 x402 price, the challenge-then-signature payment flow, and the at-most-once retry contract tied to the operation id. It falls short of 5 because the required-vs-optional status of _salt19_operation_id is stated inconsistently ('is required' then 'recommended but optional'), leaving the agent unsure of the actual contract.

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 correctly front-loaded, but the last three sentences circle the same _salt19_operation_id topic with partial repetition and a contradictory required/optional claim, which costs clarity. Two of those sentences could be merged into one without losing 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 tool with nested objects, an enum, six parameters, and a paid flow, the description covers the payment and retry mechanics well and an output schema exists to cover return values. What is missing is any mention of the constraints object (require_latest, require_license, max_days_since_push, max_vulnerabilities), which an agent must set meaningfully to get a useful decision.

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 nominally 100%, but the generated descriptions are boilerplate ('Input parameter "target" for the agent-decision-preflight tool'), so the schema adds little real meaning. The description usefully explains the two payment parameters and the operation-id lifecycle, but says nothing about target.repo vs target.package selection or the four constraint fields, so the baseline 3 is appropriate.

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

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

The first sentence states a specific verb and resource (return a bounded GO/WARN/BLOCK decision with evidence and a SALT19 receipt) plus the triggering moment (before an agent installs or adopts software). That is clear and actionable, but it never distinguishes itself from near-duplicate siblings such as dependency-go-no-go, github-repo-preflight, and repo-adoption-go-no-go, which appear to overlap heavily.

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?

Usage timing is implied by 'Before an autonomous coding agent installs or adopts software,' which gives an agent a reasonable trigger. However, no alternative is named and no when-not condition is given, which is a real gap in a sibling set containing at least three other go/no-go preflight 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 cover the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=true, openWorldHint=true), and the description adds genuinely new context: the $0.73 x402 price, the challenge/signature payment flow, and the at-most-once retry guarantee tied to the operation id. This is useful beyond what the annotations disclose, though it does not explain failure/result semantics.

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 efficient, but the payment boilerplate is somewhat verbose and repeats the operation-id guidance twice, culminating in a sentence that contradicts the earlier 'required' claim. Tightening would improve it.

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

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

With a rich input schema and an output schema present, return values need not be explained. The description covers purpose, timing, payment/auth requirements, and the idempotency contract, leaving little an agent needs missing — only the required/optional operation-id ambiguity detracts.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds operational meaning for _salt19_operation_id and _x402_payment_signature (generation, preservation, when to send), but it muddles them by calling the operation id both 'required' and 'recommended but optional,' which is confusing rather than clarifying.

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 (verify) and resource (autonomous agent plan) and enumerates the exact checks performed — missing preconditions, destructive steps, unsafe ordering, goal misalignment, constraint violations, repair actions — plus the bounded GO/WARN/BLOCK result. This distinguishes it from siblings like agent-decision-preflight and agent-code-change-risk-gate without opening 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 phrase 'before execution' clearly establishes the timing and context for using this tool. However, it names no alternatives or exclusions, so an agent cannot tell from the description alone why it should pick this verifier over the other preflight 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?

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?

Annotations cover idempotency (idempotentHint=true) and open-world behavior, but the description adds material context they don't: an explicit price ($0.21 via x402), the payment challenge/retry flow, and how a stable operation id makes retries at-most-once. This is genuine added value for a paid tool, though it doesn't cover auth failures or what the payment challenge response looks like.

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 core decision purpose is front-loaded, but the tail is padded: three sentences restate the same _salt19_operation_id guidance, and the description even contradicts itself by calling the id both 'required' and 'recommended but optional'.

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?

An output schema exists, so return values needn't be spelled out, and the description still notes the GO/WARN/BLOCK outcome. Combined with the payment-flow disclosure, an agent has enough to call and pay for it correctly, with only minor ambiguity around the optional-vs-required operation 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, and the schema already documents the _salt19_* and _x402_payment_signature fields in nearly identical terms. The description largely restates that guidance rather than adding new meaning for the payment parameters.

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

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

Specific verb and resource: 'decide whether an npm dependency or package is safe to install or adopt' with a stated outcome set (GO/WARN/BLOCK) and the signals used. It does not, however, distinguish itself from the sibling 'dependency-upgrade-go-no-go', which an agent could easily confuse with it.

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 scopes the audience ('for coding agents') and implies the decision context (install/adopt approval), but never states when to choose this over the closely related upgrade or repo-adoption go/no-go siblings, nor any when-not condition.

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 supply openWorldHint/readOnlyHint=false/idempotentHint=true, and the description adds genuinely non-redundant behavior: a $0.18 x402 cost, the challenge/retry payment flow, and an at-most-once idempotency contract tied to the operation id. It also discloses what is deliberately NOT proven (runtime, peer, migration, ecosystem compatibility), which is valuable boundary-setting. Minor inconsistency: the description calls `_salt19_operation_id` required while the schema marks it optional.

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

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

Front-loaded: the what-it-does sentence leads, followed by pricing and payment/idempotency mechanics, all of which earn their place for an x402 tool. It is dense but not padded; the only slack is the somewhat redundant restatement that the operation id is 'required' and 'makes semantic retries at-most-once'.

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?

An output schema exists, yet the description still usefully signals the result shapes, and it clearly covers the payment/authorization prerequisites an agent must satisfy — a real gap-closer for an x402 tool. What remains missing is guidance on how the tool relates to its close sibling `dependency-go-no-go` and what runtime/framework/constraints are meant to convey.

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 pure boilerplate ('Input parameter "package" for the tool'), so the schema adds no real semantics. The description explains the payment parameters (_salt19_operation_id stability, _x402_payment_signature timing), but leaves runtime, framework, and constraints — three of the nine params — entirely unexplained in both places.

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 specific verb (compare) and resource (npm current/target versions) and enumerates the concrete outputs (GO/WARN/BLOCK, UPGRADE/DEFER/BLOCK, semver risk, OSV implications, tests, NOT_PROVEN boundaries), so an agent immediately knows what it produces. It does not, however, distinguish itself from near-name siblings like `dependency-go-no-go`, `npm-package-facts`, or `npm-package-intel`, leaving the boundary implicit.

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?

Usage is implied by the phrasing 'Compare current and target npm versions', framing it as a pre-upgrade decision check, and the payment mechanics tell the agent when/how to call it for x402. But there is no explicit when-to-use vs. the `dependency-go-no-go` sibling, no stated prerequisical context (e.g. 'call before upgrading an npm dependency'), and no exclusions.

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

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

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?

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, openWorldHint=true, so the safety profile is partially covered. The description adds real behavioral context beyond annotations: pricing ($0.09 via x402), the challenge/retry flow, the at-most-once semantics of _salt19_operation_id, and the requirement to add _x402_payment_signature after the challenge. That is substantive beyond the annotations, though it doesn't describe what gets returned or failure conditions.

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

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

Front-loaded with the core purpose, which is good, but the second half is a dense, repetitive paragraph about payment-flow mechanics. The sentence 'A stable _salt19_operation_id is required and makes semantic retries at-most-once' is immediately followed by '_salt19_operation_id is recommended but optional' – the required/optional framing is repeated and slightly contradictory in tone, adding friction rather than clarity.

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

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

Output schema exists, so the description needn't explain return values. Given four parameters, x402 payment flow, and an open-world read-ish tool with a price, the description covers the critical invocation protocol (challenge, signature, operation id, pricing). It is close to complete for the task, with only minor gaps around failure/retry outcomes.

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 all parameters and their constraints are documented in the schema itself, giving a baseline of 3. The description adds operational meaning to _salt19_operation_id (generate once per purchase, preserve across retries) and _x402_payment_signature (add after satisfying the challenge), but it repeats rather than extends the schema descriptions and adds nothing for the required 'repo' parameter beyond what the schema names.

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

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

States a specific verb+resource+scope: 'GitHub repository due diligence ... evaluate whether a public or open-source repository is safe and maintained enough to adopt.' It enumerates the exact signals used (license, maintenance, release freshness, activity, project health, risk). Sibling repo-adoption-go-no-go is close in theme but the description's framing as a preflight evaluation with named signals distinguishes it reasonably.

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 context 'safe and maintained enough to adopt' implies when this tool is used, but there is no explicit when-to-use vs. when-not-to-use guidance and no routing to the nearby sibling repo-adoption-go-no-go or github-repo-facts. Usage is inferred from the scenario rather than stated.

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

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

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 cover safety profile (openWorldHint, idempotentHint, destructiveHint=false), and the description goes well beyond them by disclosing the $0.03 x402 price, the challenge/signature handshake, and the at-most-once retry contract tied to _salt19_operation_id. This is meaningful behavioral context an agent needs before calling. The one weakness is the self-contradictory framing of _salt19_operation_id as both 'required' and 'recommended but optional,' which muddies the at-most-once guarantee.

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 first sentence is well front-loaded and earns its place. The payment block, however, repeats itself and issues conflicting instructions on _salt19_operation_id ('required' then 'recommended but optional'), which adds length without resolving the ambiguity.

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?

An output schema exists, so return values need no explanation, and the description supplies the domain scope plus the x402 payment workflow that no annotation conveys. The main residual gap is routing against sibling tools, but for correct invocation the definition is essentially 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 100%, so the baseline is 3. The description reinforces the payment-flow semantics of _salt19_operation_id and _x402_payment_signature, but the two core domain parameters (package, version) carry only tautological schema text ('Input parameter ... for the tool') and get no meaning from the 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?

Specific verb+resource with enumerated scope: 'Check whether an npm package is deprecated or vulnerable before installing it,' listing the six risk dimensions covered. An agent immediately knows this is a pre-install risk assessment rather than a raw metadata lookup. However, it never names or contrasts with its closest sibling npm-package-facts, so differentiation is left to inference.

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 installing it' gives a usable trigger, but there is no explicit when-not guidance and no routing among the many related siblings (npm-package-facts, dependency-go-no-go, dependency-upgrade-go-no-go, repo-adoption-go-no-go). Usage is implied rather than stated, and an agent could easily pick the wrong preflight tool.

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

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

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 (which mark it as a non-destructive, idempotent, open-world call), the description discloses a concrete cost ($0.33 via x402), the payment handshake sequence (challenge, then _x402_payment_signature), and the at-most-once retry contract. That is meaningful behavioral context an agent cannot get from the annotations, though the return/proof semantics remain thin.

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

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

The purpose and scope boundaries are front-loaded, but the payment paragraph repeats _salt19_operation_id three times and ends on a confusing required-vs-optional contradiction. Several clauses do not earn their place, making it denser than necessary.

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, return values need not be explained. The description covers the decision purpose, the evidence basis, explicit UNKNOWN/NOT_PROVEN boundaries, and the full x402 payment lifecycle required to invoke it correctly, leaving no critical gap for the agent.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real semantics for the _salt19_operation_id (generate once per purchase, preserve across retries, enables at-most-once) and _x402_payment_signature (omit first call, add after satisfying the challenge). The one weak spot is the self-contradicting 'required... recommended but optional' phrasing around _salt19_operation_id, which muddies rather than clarifies.

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 decision verb and resource ('Repository adoption decision') and enumerates the exact evidence class used (public GitHub maintenance, archive, license, repository-health). It explicitly scopes out dependency, security, compatibility, integration, and project-fit claims, which distinguishes it from siblings like dependency-go-no-go and github-repo-facts without opening 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?

It implies the use case ('for autonomous coding agents') and draws clear boundaries by declaring that related domains (dependency, security, compatibility, integration, project-fit) are out of scope, which routes the agent to the relevant sibling tools. It stops short of naming a specific alternative or stating when-not-to-call this tool explicitly, so it is not a full 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?

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.