PAYNE Commercial Truth & Machine Revenue Exchange

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

With empty annotations, the description carries the full disclosure burden and does well: it reveals the data is read via RPC with source attribution and that a fallback mechanism exists. This tells the agent important non-obvious behavior (source dependency, resilience) beyond what any structured field provides.

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?

A single front-loaded sentence with zero waste: verb and resource come first, with the attribution/fallback behavior appended compactly. Every word 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 simple zero-parameter read with no output schema, the description covers purpose and behavioral notes (RPC source, fallback) sufficiently. Only the return format is unspecified, which is minor for such a simple 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?

Zero parameters, so the rubric baseline is 4. There is nothing to describe; the RPC-source attribution detail adds relevant context about how the result is obtained even though no inputs exist.

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 ('Read') and resource ('current Base mainnet block number'), making the tool's job unambiguous. It is distinct from the sibling base_* tools which read different resources (transactions, balances, nonces), though it doesn't explicitly name those alternatives.

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

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

Usage is implied — it's a read of block number on Base mainnet — but there is no explicit when-to-use guidance or exclusion relative to sibling tools like base_transaction or base_nonce. For a zero-parameter singleton read, this is adequate but not explicit.

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

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

Annotations are empty, so the description carries the full burden. It transparently explains the return data and what it does not return, but it does not disclose edge-case behavior (e.g., what happens when there's no contract code) or side effects, though none are expected for a read-only check. Adequate but not rich.

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?

A single, efficient sentence that leads with the core purpose and flows into specifics without wasted words. Every element adds value and the clarity benefits from its brevity.

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

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

For a simple one-parameter read-only tool, the description covers the operation and return values sufficiently. It lacks explicit edge-case handling (e.g., no-code addresses), but the scope is modest and the description meets the core needs without omission of essential details.

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 effectively explains the parameter's role: the address is on Base and is being checked for contract bytecode. This adds context beyond the schema's raw pattern and type, clarifying the purpose and network context of the 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?

The description clearly states the action ('check'), the resource ('Base address'), and the specific outcome (has contract bytecode), followed by what is returned (byte length, prefix, SHA-256 hash). It distinguishes itself from sibling tools by noting it does not dump full code, making it distinct from any potential code-fetching alternative.

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

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

The description implies when to use this tool (to check for contract bytecode) and hints at a lightweight alternative to dumping full code, but it does not explicitly name sibling tools or state when-not-to-use it. The usage context is clear from the phrasing, but exclusions or comparisons are left to inference.

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

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

With no annotations, the description must carry full behavioral disclosure. It only mentions that it 'flag unlimited-like approvals', but does not explain what that means (e.g., whether it returns a boolean, a numeric threshold, or a warning), what the output format is, or any side effects (though it's likely read-only, it isn't stated). Critical behavioral details are missing.

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, efficient sentence with no filler. It is front-loaded with the core action and the unique flagging behavior. It loses a point because being too terse contributes to the lack of context, but conciseness itself is exemplary.

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 lack of annotations, output schema, and parameter descriptions, this description is far from complete. It does not explain the 'unlimited-like' flag meaning, return values, error conditions, or specific network requirements beyond 'Base'. An agent would need to inspect other sources to call this 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?

Schema coverage is 0%, so the description must explain the parameters. It mentions 'owner-to-spender', which hints at the owner and spender parameters, and 'ERC-20' implies the token, but it does not explicitly describe each parameter's meaning, required format, or how they relate. This is insufficient for an agent to correctly construct inputs without opening 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 states the specific action ('Read an ERC-20 owner-to-spender allowance') and the resource (allowance on Base), and adds a distinctive behavioral trait ('flag unlimited-like approvals'). This clearly distinguishes it from sibling tools like base_erc20_balance, which reads balances, not allowances.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention base_erc20_balance or any other sibling, nor does it give context about typical use cases (e.g., checking approval limits before a transfer). The agent is left to infer when to choose this 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?

With empty annotations, the description carries the full burden. 'Read' signals a non-mutating operation, and the listed output fields (decimals, symbol, atomic amount, formatted amount) disclose what the call returns. It does not discuss failure modes or address validation, but for a simple read this is adequate.

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

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

Single sentence, front-loaded with the action and resource, then compactly lists return fields. No redundant 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 two-parameter read tool, the description covers the operation, chain, and return fields. However, it omits explicit parameter semantics and any error/edge-case behavior, so it is adequate but has clear gaps.

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

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

Schema description coverage is 0%, and the description does not explain the two required parameters 'token' and 'owner'. It only implies an ERC-20 balance without mapping token/owner to their roles, so the agent must rely on the parameter names and regex patterns alone.

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

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

The description uses the specific verb 'Read' with the resource 'ERC-20 balance on Base' and enumerates the returned fields (decimals, symbol, atomic amount, formatted amount). This clearly distinguishes it from sibling tools like base_native_balance and base_erc20_allowance.

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

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

No explicit when-to-use or alternative routing is provided. The term 'ERC-20' implies use for token balances rather than native Base balance, but the description never states when to prefer this over base_native_balance or base_erc20_allowance.

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

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

With no annotations, the description must carry the behavioral burden. It signals a read-only operation and mentions output units, but it does not disclose the response shape, behavior for invalid addresses, or any RPC/network caveats. There is no contradiction with annotations because annotations are empty.

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 with no filler. It packs the resource, network, and output units into minimal text, every word earning 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 simple one-parameter read operation, the description is largely complete: it states the resource, network, and units. It lacks an explicit response format and alternative-tool guidance, but the low complexity and lack of output schema make those gaps relatively minor.

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

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

Schema coverage is 0%, but the only parameter is 'address' and its regex fully constrains the format. The description's phrase 'an address native ETH balance' clarifies that the address is the account being queried, which meaningfully supplements the schema despite the low 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 states a specific verb ('Read'), a clear resource ('address native ETH balance'), a network ('Base mainnet'), and output units ('wei and ETH'). It also differentiates from sibling tools like base_erc20_balance by specifying native ETH rather than a token 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 gives clear context about what this tool reads and on which network, so an agent can infer it is for native ETH rather than ERC-20 tokens. However, it does not explicitly name alternatives or state when not to use this tool, leaving some routing to inference.

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

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

With empty annotations, the description carries the behavioral burden. 'Read' correctly conveys a non-mutating operation, and 'latest' indicates current-state behavior, but the description does not disclose return format, edge cases, or address type constraints beyond what the schema implies.

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 one short sentence with no wasted words. The verb is front-loaded, and every remaining word adds purpose or scope without repeating schema or annotation information.

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

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

For a simple single-parameter read operation with no output schema, the description is largely sufficient: it conveys the chain, the input, and the conceptual return value. It does not state explicit output typing or usage caveats, but the low complexity makes the overall context adequate.

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

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

The schema provides only a regex pattern for the required 'address' parameter with 0% description coverage. The description adds meaningful semantic grounding by clarifying that the address is a Base address and that the tool returns its latest transaction nonce, compensating for the sparse 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 the verb 'Read' and a specific resource, 'latest transaction nonce', for a Base address. This clearly differentiates it from sibling tools that target block numbers, balances, or transaction details.

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 it should be used when an agent needs the current nonce for a Base address, but it gives no explicit when-to-use, when-not-to-use, or alternative guidance. The usage context is inferred 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?

No annotations are present, so the description carries the behavioral disclosure burden. It does state that the operation is a read and lists the returned fields, but it does not mention failure modes such as non-ERC-20 addresses or tokens missing the decimals method. This is minimally transparent but incomplete.

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

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

The description is a single sentence with no filler, front-loading the core action and resource before listing the additional outputs. Every word contributes useful information.

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

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

For a one-parameter read tool, the description names the input, network, and expected output fields, which is mostly sufficient for invocation. However, with no output schema and no annotations, it leaves the exact result shape and edge-case behavior unspecified, such as how a missing decimals value is handled.

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 only provides an address pattern for 'token' with no description, so the description must compensate. It frames the parameter as an ERC-20 token on Base whose total supply is read, clarifying both the input context and what will be returned. It stops short of explicitly saying 'token is the contract address', but the schema pattern and wording make that evident.

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 ('Read'), names the exact resource ('ERC-20 total supply'), and identifies the network ('Base') plus the accompanying outputs. This clearly distinguishes it from sibling tools like base_erc20_balance and base_erc20_allowance.

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 imperative phrasing 'Read an ERC-20 total supply on Base' gives clear context for when the tool should be selected. It does not explicitly mention alternatives or exclusions, but the resource and network are specific enough that an agent can route to it without confusion.

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

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

Annotations are empty, so the description bears full responsibility. It says 'read', implying read-only, but doesn't disclose it explicitly. It also doesn't mention error handling, network implications, or whether the entire receipt is returned. The field list is a useful hint but not enough to understand side effects or safety.

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

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

The description is a single sentence, front-loads the verb and resource, and lists the receipt fields in a compact way. Every word adds value, and there is no redundant phrasing.

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 one-parameter read tool with no annotations or output schema, the description covers the core purpose adequately but omits any mention of typical edge cases like a non-existent transaction or large log data. More importantly, it doesn't clarify that this is a safe, read-only operation, which would set appropriate expectations. It's the minimum viable description.

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 only provides a name and pattern for `hash`, and the description's field list (status, value, gas...) implies the hash is a transaction hash, providing helpful context. However, the description doesn't directly describe the `hash` parameter or formats. Since the parameter is simple and the description adds some context, this is a pass.

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 verb ('Read and summarize'), a specific resource ('a Base transaction plus receipt') and the exact receipt fields covered ('status, value, gas, fee, logs and contract creation'). This distinguishes it from the sibling 'base_*' tools, but it doesn't explicitly name an alternative, so it loses one point.

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

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

The description gives no guidance about when to use this tool versus siblings. While the 'base_' prefix suggests a family, there's no explicit mention of alternatives or conditions. The agent must infer from the tool name and schema.

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

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

Annotations are empty, so the description must disclose behavior, but it only restates the purpose. It does not reveal whether the operation is read-only, whether it requires network access, what constitutes a 'material change', or what the output looks like. For a diffing tool, one might expect context about case sensitivity, text normalization, or whether the change detection is semantic vs. lexical. None of that 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 a single, well-structured sentence that front-loads the core action ('Compare two versions') and then enumerates the relevant economic terms. There is no fluff or repetition; every word contributes to understanding the tool's purpose and scope.

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

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

For a simple two-parameter tool, the description is reasonably complete in conveying intent. However, it does not address edge cases (e.g., empty input, identical strings) or output semantics. Since there is no output schema, one might expect the description to explain the return value, but it doesn't. Given the tool's simplicity, the lack of return-value documentation is a minor gap, but the absence of input format details (plain text, markdown, etc.) prevents a higher score.

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

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

Schema description coverage is 0%, so the description must explain the parameters. The phrase 'two versions of commercial text' gives an agent a rough idea that 'beforeText' and 'afterText' hold the original and new versions, but it doesn't specify constraints like text encoding, length limits, or required language. The schema already names the parameters clearly, so the description adds minimal value beyond the parameter names.

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

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

The description uses a specific verb ('compare') and resource ('two versions of commercial text'), and enumerates a concrete list of economic terms it detects changes in (pricing, fees, payout, commission, eligibility, renewal, restrictions, SLA). This leaves no ambiguity about the tool's function and it clearly distinguishes itself from siblings through the use of 'diff' in the name and the explicit scope of 'commercial text'.

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

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

The description gives no guidance on when to use this tool instead of a sibling. It does not state prerequisites, expected input format, or any conditions that would make this tool preferable. There is no mention of alternatives or exclusion criteria (e.g., 'if you need to search, use different_tool'), so an agent receives no help in routing.

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

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

With empty annotations, the description carries the full burden. It discloses that data is privacy-filtered, that it combines RDAP and DNS sources, and that risk signals are included. It does not state whether the operation is read-only, whether results are cached, or what failure/timeout behavior to expect, so transparency is partial.

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 definition is a single, front-loaded sentence with no filler. The fact list is dense and every phrase adds 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 lookup tool with no output schema, the description lists the major result categories and the required input, which covers most invocation needs. It omits when-to-use guidance and behavioral details such as response shape or timeout handling, but the core call surface is represented.

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

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

Schema description coverage is 0%, so the description must explain parameters. It clarifies that 'domain' refers to a public domain and implies a hostname format, but it does not explain the optional timeoutMs parameter beyond the schema's numeric bounds. Since one of two parameters is left semantically unexplained, the description only partially compensates.

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 precise operation ('combine privacy-filtered RDAP and DNS facts') and names the resource scope ('a public domain') plus concrete fact categories: registrar, age, expiry, DNSSEC, nameservers, MX, SPF, DMARC, and risk signals. This is enough to distinguish domain_intelligence from unrelated sibling tools like base_erc20_balance or web_read.

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 a clear use case: fact-gathering for a public domain. It differentiates from opportunity/verification siblings by scope, but it never states when to prefer this tool over alternatives like web_read or probe, nor does it give exclusions or prerequisites. Guidance is implied rather than explicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states this is a read-only discovery tool that never submits bids, which is a key limitation. It also describes the output behavior (normalized, ranked notices). However, it does not disclose potential rate limits, authentication requirements, or error behaviors, but for a search tool this is reasonably transparent.

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

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

The description is two concise sentences, with the core action (search SAM.gov) front-loaded. It includes the key constraint (discovery only) without extraneous detail. Every word contributes value, making it highly 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?

While the description covers the tool's purpose and main output, it does not explain the parameters or their semantics, which is critical for an agent to use the tool correctly. There is no guidance on how limit or lookbackDays affect results, what timeoutMs controls, or any prerequisites. Given the tool has 4 parameters and no output schema, more detail is needed for 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 schema description coverage is 0%, meaning the schema itself provides no parameter descriptions beyond type and constraints. The tool description does not mention any of the four parameters (query, limit, timeoutMs, lookbackDays) or explain their meaning, usage, or impact on results. This is a significant gap; the description fails to compensate for the schema's lack of documentation.

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 exactly what the tool does: it searches SAM.gov contract opportunities by title/query, returns normalized open notices ranked by relevance and deadline urgency. It also explicitly says it is discovery only and never submits a bid, which distinguishes it from transaction-like tools. The purpose is clear and specific.

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

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

The description notes that the tool is 'Discovery only; never submits a bid,' which implies it should be used for research rather than action. However, it does not explicitly state when to use this tool versus alternatives like opportunity_changefeed or web_read, nor does it provide exclusion criteria. The context is somewhat clear but lacks direct guidance on choice among 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 are empty, so the description carries the full burden of behavioral disclosure. It does reveal ranking criteria such as probability-adjusted expected gross profit and time-to-cash, but it does not state whether the tool is read-only, whether it performs any external action, what it returns, or what side effects it might have.

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 opens with the verb and resource. The list of ranking criteria is dense but relevant and not padded. Every word 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?

This is a complex tool with two parameters, nested objects, no output schema, and no annotations. The description only conveys ranking intent and criteria; it omits output structure, route representation, the meaning of 'signal', and any behavioral/usage context. It is not sufficient for reliable invocation.

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

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

The schema provides zero coverage: 'routes' is an array with an empty item schema and 'signal' is a generic object. The description partially clarifies 'routes' by naming direct service, marketplace work, referral, data/API, product, and other monetization routes, but it says nothing about how these are represented or what 'signal' means. With 0% schema coverage, this is insufficient.

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 verb ('Rank') and a concrete resource ('monetization routes'), and enumerates the route categories and ranking criteria. It is easy to distinguish from sibling tools by task, though it does not explicitly contrast itself with any sibling.

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 on when to use this tool versus alternatives, no prerequisites, no exclusions, and no workflow context. An agent cannot determine whether this should be called before or after other tools, or what conditions warrant its use.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It states the tool emits events, which suggests a read-like operation, but does not mention side effects, permissions, rate limits, or whether the tool modifies any state. The description also doesn't clarify if events are returned synchronously or trigger side effects. This is a significant gap for a potentially complex changefeed tool.

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

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

The description is a single, well-structured sentence. It front-loads the core action (compare and emit) and then specifies the event types and sources. There is no redundant phrasing or filler. It efficiently communicates the tool's essence without unnecessary detail.

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

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

The tool has no output schema, so the description should explain the shape and meaning of the emitted events. It mentions event types but not their structure or payload. It also doesn't clarify what constitutes a 'change' or how the comparison works, nor does it provide example usage. Given the complexity of comparing snapshots from multiple sources, the description is under-specified, making it difficult for an agent to invoke correctly without additional context.

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

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

Schema description coverage is 0%, so the description must explain the two parameters, 'previous' and 'current'. It only says 'compare opportunity snapshots', which implies both are snapshots but doesn't specify the structure, required format, or what each represents beyond that. The description adds minimal meaning beyond the schema's 'array' type, leaving the agent unsure what to pass.

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

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

The description clearly states the tool's purpose: compare opportunity snapshots and emit events for changes. It specifies the action (compare/emit), the resource (opportunity snapshots), and the specific event types (NEW, CHANGED, REMOVED_OR_CLOSED). This distinguishes it from similar tools like commercial_terms_diff (which diffs terms) or federal_opportunity_search (which searches), making the purpose immediately obvious.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It doesn't mention scenarios like 'use when monitoring commercial sources' or contrast with search or diff tools. The context is implied by the event types, but no clear usage direction is given. This leaves the agent to infer when this tool is appropriate.

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

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

Annotations are empty, so the description must fully disclose behavioral traits. It does not state whether the tool is read-only, what it returns (e.g., pass/fail, detailed report), how failures are signaled, or any side effects. The verb 'Check' implies a non-mutating operation, but this is not explicit. With zero annotation support, the description leaves critical behavioral unknowns.

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

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

The description is a single sentence and thus concise, but it tries to list many gate types without elaboration. The structure is acceptable, but the brevity comes at the cost of essential details. It is not overly verbose, but it is under-specified rather than optimally concise.

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

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

Given the complexity of the tool (checking multiple gates) and the absence of both an output schema and any annotations, the description is severely incomplete. It does not explain the expected payload structure, the response format, or the implications of passing/failing a gate. An agent cannot reliably invoke this tool without additional undocumented assumptions.

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 only parameter 'payload' is a generic object with no defined sub-properties and 0% schema description coverage. The description never explains what should be included in the payload, leaving the agent completely in the dark about the required input structure. Since the tool's entire input is this opaque payload, the description fails catastrophically to compensate for the schema gap.

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

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

The description clearly states the tool's function: checking multiple gate conditions (approval, attribution, duplicate/collision, consent, eligibility, compliance) before a handoff. It uses a specific verb 'Check' and names the resource context (referral/partner-program), which distinguishes it from generic utilities. However, it overlaps conceptually with sibling gate tools like personalization_evidence_gate, so it doesn't fully differentiate itself.

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

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

The description provides a temporal context ('before an introduction or lead handoff'), implying when to use it. However, it does not mention any alternatives, exclusions, or conditions for when not to use it. While the purpose suggests it's a prerequisite gate check, there's no explicit guidance on choosing it over sibling tools that may also perform checks.

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

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

With no annotations, the description must carry the behavioral disclosure burden. It clearly states that it checks claims and blocks unsupported ones, but it does not explain what 'block' returns or how it signals pass/fail, nor whether the tool mutates state. This is adequate but not fully transparent.

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

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

A single sentence that is dense but not bloated: it states the action, the target, the evidence source, the blocking behavior, and the timing. Every clause 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 simple two-string tool with no output schema, the description covers the core inputs and the intended gate behavior. It does not detail the return contract or what exactly happens when a claim is blocked, but the semantics are inferable for an agent deciding whether to call it.

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

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

Schema coverage is 0% and the schema only names draft and evidenceText. The description compensates by mapping 'personalized ... copy' to draft and 'supplied evidence' to evidenceText, making both parameters meaningful beyond their names.

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

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

The description names a specific action ('fact-check' and 'block') and a specific resource ('personalized sales, recruiting, partnership, or outreach copy'). It clearly distinguishes this from sibling tools like verify_commercial_truth or commercial_terms_diff by focusing on pre-send personalization copy validation.

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 a clear context of use: before an automated send, when there is personalized copy and supporting evidence. It does not explicitly name alternatives or exclusion conditions, but the timing and purpose are unambiguous.

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

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

With no annotations, the description carries the full burden. It discloses that the probe is free and checks reachability and stale-risk, which is useful. But it does not describe what the output looks like (e.g., reachability status, stale-risk score), error behavior, or any side effects, important for an unannotated tool.

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

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

The description is a single, front-loaded sentence with zero redundancy. It leads with the purpose, lists target types, and ends with usage context, all in efficient wording. Every element earns its place.

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

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

The tool is simple (one parameter, no output schema), but the description omits any hint of the return value or what constitutes a 'stale-risk' indication. For a probe, knowing the response format is important. It covers purpose and usage well but lacks completeness on outputs.

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

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

Schema coverage is 0% since no property descriptions exist, so the description must compensate. It gives context on appropriate URLs (public job, RFP, grant, etc.) which implies the format, but it does not explicitly explain the 'url' parameter beyond its type. The usage context partially fills the gap.

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

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

The description uses a specific verb ('probe') with a clear resource (public commercial URLs) and scope (reachability and stale-risk). It differentiates from 'full verification' which likely refers to the sibling verify_commercial_truth, and lists multiple URL categories, leaving no ambiguity about what the tool targets.

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 buying full verification' explicitly situates this as a preliminary step, giving clear context for when to use it. However, it does not name the alternative tool (e.g., verify_commercial_truth) or state when NOT to use it, leaving some inference required.

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

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

With no annotations, the description carries the full burden. It does disclose a key behavioral trait: the tool returns reverify-before-action guidance rather than a bare score. However, it omits details such as whether the tool performs a network fetch, how freshness is determined, or whether it is strictly read-only, so the disclosure is only partial.

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 entire description is one efficient sentence with no filler. The verb, object, and outcome are front-loaded, and the list of decision types adds concrete value without redundancy.

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

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

The tool has no output schema and no annotations, so the description must explain both inputs and return behavior. It describes the output only as 'reverify-before-action guidance' without specifying format, thresholds, or interpretation, and it lacks parameter semantics. This leaves an agent without enough information to reliably interpret the result.

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

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

Schema description coverage is 0%, so the description must explain parameters. It never mentions claimClass at all, and url is only indirectly referenced as 'web evidence'. This leaves one of the two parameters completely undefined and the other only implied, so the description does not compensate for the schema gap.

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

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

The description uses the specific verb 'Score' and identifies the resource as 'web evidence' currency, clearly distinguishing it from sibling tools like web_read (which reads content) and verify_commercial_truth (which checks truthfulness). The additional phrase 'returns reverify-before-action guidance' clarifies its assessment-oriented purpose.

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

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

The description gives clear context for when to use the tool: any consequential decision such as applying, bidding, pricing, outreach, procurement, or partner routing. However, it does not explicitly list when not to use it or name alternative tools, leaving some selection reasoning to the agent.

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

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

With empty annotations, the description must carry the behavioral load, and it does: it states the tool verifies liveness, checks deadline and economics, and flags contradictions. The RELEASE/HOLD return contract is explicit. It stops short of describing what 'verify' entails operationally (e.g., staleness rules), but the behavioral profile is clear and non-destructive.

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

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

The purpose is front-loaded and the sentence is reasonably tight, but the run-on enumeration of offer types (job, RFP, grant, auction, marketplace listing, partner program, pricing page) adds length without much marginal value. It earns its place but could be trimmed.

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 annotations, a single undocumented param, and no output schema, the description must carry everything. It explains the verification scope and the RELEASE/HOLD verdict, but never defines what the url parameter means, what a contradiction looks like, or the shape/payload of the verdict. Adequate but incomplete.

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

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

Schema coverage is 0% and the description never names 'url' explicitly, leaving the single parameter's role implicit. An agent must infer that url points to the offer being verified. With one required param and zero coverage, the description should link the parameter to the verification target but does not.

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 the exact object of verification (live status of a job, RFP, grant, auction, marketplace listing, partner program, or pricing page), what gets checked (deadline, economics), and the concrete return verdict (RELEASE or HOLD). That is a crisp, unambiguous statement of purpose.

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

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

The description explains what the tool verifies but never differentiates it from closely overlapping siblings such as verify_deadline_eligibility, source_freshness_score, or commercial_terms_diff, all of which perform a subset of this work. An agent cannot tell when to route here versus to those tools, so usage guidance is thin.

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

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

With empty annotations, the description must carry the burden of behavioral disclosure. 'Gate' implies some form of allow/deny but is unclear; no mention of whether it's read-only, what happens with invalid URLs, or the nature of the output. This is minimal beyond the stated extraction/gating.

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, compact sentence with the primary action ('extract and gate') front-loaded, followed by a list of relevant attributes. It avoids redundancy, though the structure is flat with no distinction between high-level and low-level 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?

For a single-parameter tool, the description omits essential context: expected output format, how the gating result is returned, whether it mutates state, or how the URL should be sourced. The complexity of the task (checking multiple criteria) is only implicitly hinted, leaving an agent without enough information to reliably invoke it.

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

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

Schema coverage is 0%—the description does not explain what the 'url' parameter represents beyond being a URI. It fails to clarify that the URL points to the opportunity listing from which data is extracted. This is a critical gap for an agent to invoke the tool correctly.

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

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

The description clearly identifies the tool's core function: extracting and gating submission deadlines, eligibility factors, and disqualifiers for various opportunity types. It distinguishes itself from siblings like federal_opportunity_search (which searches) by focusing on verification, though it doesn't explicitly name an alternative.

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

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

No guidance is provided on when to use this tool versus similar ones, nor any exclusions or prerequisites. An agent cannot tell if this should be called before or after searching for an opportunity, or what conditions warrant use.

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

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

Without annotations, the description must disclose behavioral traits. It mentions the output is 'bounded' (implying maxChars) and 'clean' (suggesting content filtering), and lists output components (metadata, links, JSON-LD, content hash). However, it does not address potential behaviors such as redirects, JavaScript execution, error handling, or rate limits, leaving some transparency gaps.

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

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

The description is a single, tightly worded sentence that conveys the essential information without redundancy. It is front-loaded with the verb 'Fetch' and follows with the resource and output details, making it highly concise and well-structured.

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 absence of annotations and output schema, the description is sparse. It lists output components but does not explain the return format, error conditions, or edge cases. The description is adequate for a simple fetch tool, but it lacks sufficient detail for an agent to fully anticipate behavior in all scenarios.

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

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

The schema provides no descriptions for parameters (0% coverage), and the description does not explain the parameters. Though 'bounded' hints at maxChars and 'clean' hints at filtering, the description does not clarify the meaning or effect of url, maxChars, or includeLinks. This fails to compensate for the missing schema documentation.

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 ('Fetch a public URL') and specifies the output format ('bounded clean markdown-ish text with metadata, links, JSON-LD, and content hash'). It also indicates the intended use ('for agent research and verification'), making the tool's purpose unambiguous.

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

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

The description does not provide any explicit guidance on when to use this tool versus alternatives. It only mentions a general purpose ('agent research and verification'), but lacks comparisons to sibling tools or specific conditions that would favor this tool over others.

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

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

Annotations are empty, so the description carries the full burden of behavioral disclosure. The description mentions 'unpaid' and 'preflight,' implying no payment is made and likely no side effects. It also lists 'simulation verdict,' which suggests a safe, non-destructive action. However, it does not explicitly state that the tool is read-only, makes no external mutations, or has no side effects. It also doesn't mention authentication, rate limits, or error behavior. Given the safety of a preflight operation, a 3 is fair—it adds some behavioral context but not full transparency.

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 one sentence and front-loads the primary action ('Run an unpaid Coinbase/CDP x402 configuration preflight'), then lists output elements. There is no waste or redundancy. It could be slightly better structured by separating the parameter details, but as-is it is concise and efficient. Given the lack of parameter docs, it is still appropriately sized for a 3-parameter 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 is incomplete for an agent to call the tool correctly. It does not explain the meaning of the three parameters, the expected output format beyond a high-level list, or any constraints like authentication or rate limits. With a 0% schema description coverage and no output schema, the description must supply this context, but it does not. The tool appears simple, but the missing parameter semantics make it insufficiently complete.

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

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

Schema description coverage is 0%, meaning the input schema has no descriptions for 'method,' 'resource,' or 'timeoutMs.' The tool description does not compensate: it explains the tool's purpose but offers no meaning for the parameters. An agent must infer that 'resource' is the x402 endpoint, 'method' is the HTTP method to simulate, and 'timeoutMs' is the request timeout. This is a significant gap for a 3-parameter tool with zero schema documentation, so the description adds minimal value beyond the parameter names.

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

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

The description clearly identifies the action: run an unpaid x402 configuration preflight. It names the specific protocol (Coinbase/CDP x402) and the context (before an agent spends), and lists the output components (required checks, simulation verdict, warnings, payment requirements). It is specific enough to distinguish from sibling tools, which are mostly read-only blockchain queries or verification tools. However, it does not explicitly differentiate itself from a hypothetical similar preflight tool, so it gets a 4 rather than a 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?

The description says to run this 'before an agent spends,' which provides clear guidance on when to use it. It implies a trigger condition (prior to spending) and the tool's role as a safety check. It does not explicitly state when not to use it or name alternatives, but the context is clear enough to suggest the intended invocation point. This meets the 'clear context, no exclusions' bar for a 4.

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