OnchainDiligence

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

Discloses parallel execution, independent results, and a disclaimer about no verified link. Adds value beyond readOnly and openWorld 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?

Single concise paragraph, no wasted words, effectively front-loaded with the main function.

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?

Adequately describes the combined function and use case, but lacks details on result structure since no output schema exists.

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% with clear descriptions. Description adds no additional detail beyond what's 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?

Description clearly states it combines sanctions screening on a crypto wallet and UK Companies House KYB lookup. It distinguishes from sibling tools like screen_wallet and verify_uk_company by offering a combined call.

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

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

Explicitly states it's built for compliance agents vetting a counterparty with both an on-chain wallet and a UK company. Implies not to use if only one check is needed, but lacks explicit exclusion.

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

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

Annotations only indicate readOnlyHint and openWorldHint, but the description adds substantial behavioral detail: it returns the complete signed receipt envelope or a structured not-found/unavailable reason, never guesses, and deliberately makes private and unknown IDs indistinguishable. This significantly exceeds what annotations provide.

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

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

Three sentences with every sentence earning its place: the action and resource come first, followed by pricing, return behavior, and privacy semantics. No redundant or vague 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 simple one-parameter lookup tool with no output schema, the description fully covers input requirements, output behavior, and the sensitive privacy distinction. Nothing material 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 100% and the parameter is already described, but the description adds the exact format 'OCD-RCP-XXXX-XXXX-XXXX-XXXX', the requirement for an exact ID, and the public-only scope. This goes beyond the schema's own example.

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 ('Look up') and resource ('public OCD receipt') with an exact ID, and clearly distinguishes public from private receipts. It does not explicitly differentiate from sibling tools like verify_receipt, so it misses full sibling differentiation.

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 when to use this tool: when you have an exact receipt_id and need a public receipt. It provides useful context ('Free, no payment', 'never a guess'), but it does not explicitly state when not to use it or name any alternative sibling 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 cover readOnly and closed-world, but the description adds meaningful context: deterministic evaluation, no wallet action, no signing, no chain read unless a separately requested preflight asks for it. It does not disclose what the result envelope contains or how a 'BLOCK'/'REQUIRE_APPROVAL' outcome is surfaced.

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 clauses, front-loaded with the cost and the verb, followed by the behavioral disclaimer. No filler.

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

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

The mutation-free nature is well covered and the safety profile is reinforced, but with a nested 0%-coverage schema, no output schema, and no disclosure of result shape, the definition leaves the agent guessing about what to populate and what to expect back.

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% across three top-level params and a deeply nested action/policy structure. The description names the policy axes conceptually (network/token/spender/value) but supplies no field-level meaning, no enum semantics (ALLOW/REQUIRE_APPROVAL/BLOCK), and no required-vs-optional guidance, so it only partially compensates for the empty 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?

States a specific verb (inspect), resource (ERC-20 allowance/revocation request), and the policy dimensions checked (network/token/spender/value). It is clearly distinguished from siblings observe_allowance (reads chain), preflight_allowance (simulates a transaction), and get_receipt.

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?

Clarifies the cost (FREE) and the no-side-effect/no-signing/no-chain-read profile, which routes agents to preflight or observe when those are needed. It does not explicitly name the sibling alternatives or state when-not-to-use beyond the preflight caveat.

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=true and openWorldHint=false, but the description adds genuinely useful context: 'No wallet action, no signing, no chain read' clarifies the operation is purely local/deterministic ('Deterministically inspect'), and 'FREE' signals no cost. It stops short of describing what the inspection returns or how policy failures surface.

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 with no filler, and the core purpose (deterministic policy inspection of a bridge request) is front-loaded. Leading with 'FREE' is slightly informal but informative about cost.

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

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

For a tool with nested-object inputs and no output schema, the description covers side-effect safety but omits the outcome: it never says what inspection produces (pass/fail, violation details) or what acknowledge_unconstrained does. Annotations cover the safety profile, but the result semantics are a real gap.

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

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

Schema description coverage is 0% and the two parameters are complex nested objects (action with 9 required fields, policy with 10 fields including acknowledge_unconstrained). The description adds no explanation of what 'action' or 'policy' mean, nor of the null-vs-array semantics or the purpose of acknowledge_unconstrained.

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?

Uses a specific verb (inspect) and resource (a Circle CCTP V2 Base-to-Ethereum native-USDC bridge request) and states the scope precisely. However, it does not distinguish itself from siblings like observe_bridge and preflight_bridge, which an agent would need to choose between.

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?

'Against explicit policy' implies this is a policy-evaluation tool with no side effects, giving enough context to infer usage. But it never states when to pick this over observe_bridge or preflight_bridge, leaving the routing decision implicit.

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

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

The description goes well beyond the readOnly/openWorld annotations: it discloses that the operation is free, purely deterministic, makes no external calls, performs no sanctions screening, does not cryptographically sign, returns no receipt, and that the receipt field is always null. This is rich, accurate behavioral context.

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 most important facts (FREE, deterministic, no external evidence) and uses three sentences to cover purpose, comparison, and limitations. It is slightly repetitive about the missing receipt, but every sentence carries meaningful 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?

Given no output schema, the description clearly communicates the decision semantics and the absence of a receipt, which are the critical behavioral outputs. It does not specify the exact response shape or error behavior, but it is sufficiently complete for an agent to decide whether to invoke it and what to expect.

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 mentions the key decision dimensions (amount, network, asset, recipient, resource) and refers to structured policy, but gives no concrete guidance on the policy fields, formats, or the acknowledge_unconstrained flag. Since schema description coverage is reported as 0%, the description only partially compensates for the missing parameter-level guidance, though the schema itself is detailed.

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 free, deterministic inspection of a proposed payment against a policy, and names the exact decision semantics returned (ALLOW / REQUIRE_APPROVAL / BLOCK). It also distinguishes itself from the sibling preflight_payment by explicitly excluding external evidence, sanctions screening, signing, and receipts.

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 states precisely when to use this tool: to sanity-check a proposal before deciding whether the paid preflight is worth paying for. It names the alternative (POST /x402/preflight-payment / preflight_payment) and explains what the paid version adds, making the choice between siblings 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 already declare readOnlyHint=true and openWorldHint=false; the description reinforces this and adds genuinely new behavioral context by specifying there is no wallet action, no signing, and no chain read, plus a 'FREE' cost signal. It stops short of describing determinism guarantees or the outcome shape of the check.

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 with the cost/safety signal front-loaded ('FREE') followed by the scope and the non-effects. Nothing is wasted, though the brevity comes at the cost of the parameter and result detail the tool needs.

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?

There is no output schema and the input schema has 0% field description coverage over nested objects, so the description carries the full burden. It never says what a successful or failed inspection returns (verdict, violations, pass/fail) or how policy fields are interpreted, leaving a validation tool's most important contract unstated.

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 both parameters are nested objects with several undocumented subfields. The description only gestures at 'explicit policy' and 'submit request' without explaining the action/policy split, the meaning of max_amount_wei, exact_staker, allowed_networks, or acknowledge_unconstrained.

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 (inspect), a specific resource (a narrow Ethereum Lido stETH submit request), and the thing it checks against (explicit policy). It is clear what the tool does, but it never distinguishes itself from the sibling observe_staking and preflight_staking, which an agent must choose between.

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?

Implied usage is present: 'against explicit policy' and 'No wallet action, signing, or chain read' tell the agent this is a pure, offline policy check. However, no alternative is named and no when/when-not condition is given relative to observe_staking or preflight_staking, so routing is 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?

Annotations already declare readOnlyHint and a closed-world profile, so safety is partly covered. The description adds genuine value by disclosing that the check is deterministic, costs nothing ('FREE'), and involves no signing or wallet action — traits not present in the annotations.

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

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

Two tightly packed sentences, front-loaded with cost and the key constraint, with no filler. Every clause carries 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 no-output-schema tool with a deeply nested two-parameter input, the safety/cost framing is complete but the input semantics are entirely unaddressed and the sibling disambiguation is absent, leaving the agent under-equipped on the mechanics of calling 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 description coverage is 0% and both params (action, policy) are complex nested objects with many sub-fields. The description only gestures at 'policy' without explaining any field semantics (e.g., allowed_routers, acknowledge_unconstrained, atomic amounts), so it fails to compensate for the coverage 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?

States a specific verb ('inspect'), resource ('swap'), and unusually precise scope ('narrow Base USDC-to-WETH direct Uniswap V3'). However, it does not distinguish itself from the sibling swap tools observe_swap and preflight_swap, leaving the agent to infer the boundary between inspect/observe/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?

'Against explicit policy' + 'No wallet action or signing' implies this is a validation step, but there is no explicit when-to-use or when-not statement versus observe_swap or preflight_swap. Usage is only weakly implied.

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=true and openWorldHint=true, so the safety profile is partly covered. The description still adds real value by asserting 'OCD never executes the transaction' and by naming the three independent checks it performs, which tells the agent this is a passive verification with no side effects on-chain.

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 dense sentences with no filler; the inputs are front-loaded and the non-execution guarantee is placed last where it reads as a boundary statement. Domain jargon ('OCD', 'canonical-USDC', 'safe-head finality') is left undefined, which costs a little clarity but not length.

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-only inspection tool with no output schema and open-world reads, the description covers what is checked but not what a caller gets back or how failure/absent-finality is surfaced. It is adequate but leaves the agent guessing about return shape and the source of the required artifact.

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 carry parameter meaning. It partially does: 'artifact' is characterized as a signed OCD allowance preflight artifact and 'transaction_hash' as a submitted Base transaction hash. It never explains how to obtain the artifact, hash format, or whether the artifact is optional in practice.

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 (inspect) and enumerates exactly what is inspected: the canonical-USDC Approval event, Base safe-head finality, and historical allowance state. It implicitly distinguishes itself from the preflight tools by operating on an already-submitted transaction, but never names the close sibling inspect_allowance to remove the 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 opening clause establishes the operating context precisely: it runs given a signed OCD allowance preflight artifact plus a submitted Base transaction hash, i.e. post-submission rather than before it. No exclusions or explicit 'use X instead' routing against inspect_allowance or the preflight siblings is offered.

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 and openWorldHint, so safety is covered. The description adds real behavioral context beyond that: source-only observation yields an evidence gap, never a completion verdict, which tells the agent how the tool reports partial states.

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

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

A single dense sentence, but front-loaded with inputs before the action and the evidence-gap caveat. Every clause carries information; no filler.

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

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

No output schema exists, so the description must hint at results, and it does by describing verification/reconciliation outcomes and the evidence-gap reporting behavior. For a 3-param cross-chain observation tool this is nearly sufficient, with only return-format detail 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 0%, so the description must carry the parameter burden and largely does: it explains the signed preflight artifact, the Base depositForBurn hash (source_transaction_hash), and the Ethereum receiveMessage hash that may not exist yet (destination_transaction_hash, matching the single required param). It lacks format expectations but conveys availability semantics the schema 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?

States a specific verb (observe, verify, reconcile) over a specific resource (CCTP bridge across Base and Ethereum) and names the artifacts involved. It is clearly distinguishable from siblings like inspect_bridge or observe_swap, though it never explicitly contrasts itself with them.

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

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

The line about source-only observation being reported as an evidence gap rather than completion implies this is a post-bridge-verification step, but no explicit when-to-use, prerequisites, or alternatives (e.g., preflight_bridge, inspect_bridge) are named. Usage is inferable 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?

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds real context beyond them: it performs *independent* inspection against canonical chain data, checks finalized-head finality, and clarifies "OCD never stakes ETH," which tells the agent this tool has no staking side effects. It still omits failure modes (e.g., unfinalized tx, reorgs) and any auth/rate-limit notes.

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 dense sentences with no filler; the inspection target and the non-staking guarantee are front-loaded. The enumerated list of checked items is information-dense but earns its place. Slightly packed for a single clause chain, but not padded.

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 carries the burden of implying return content, and it does by naming exactly what is inspected (Submitted event, sender/value, shares, finality). No completion-time caveats (pending tx, mismatched artifact) are mentioned, which is the main remaining gap.

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

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

Schema description coverage is 0% and the artifact parameter is an untyped empty schema, so the description must carry the load — and it does: the artifact is a *signed OCD staking preflight artifact* and the other input is an Ethereum transaction hash. That is meaningful disambiguation the schema does not provide.

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: independently inspects the canonical Lido Submitted event, transaction sender/value, minted shares, and finalized-head finality. An agent can tell it is a read-only chain observation tool. It never explicitly distinguishes itself from the sibling inspect_staking or preflight_staking, so it falls short of 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 prerequisite is implied by "Given a signed OCD staking preflight artifact and Ethereum transaction hash," which tells the agent what inputs the workflow expects. However, there is no explicit statement of when to choose this over inspect_staking, verify_receipt, or the other observe_* siblings, so the usage boundary is only inferred.

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=true and openWorldHint=true, so safety and external-chain reach are covered structurally. The description adds a genuinely important behavioral fact beyond annotations: that the tool inspects Base finality/safe-head and that OCD does not execute. It does not cover authentication for the independent inspection service, rate limits, or what failure of finality looks like. With annotations carrying the safety profile, a 3 is appropriate.

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

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

Two sentences, front-loaded with inputs followed by the inspection target, then a short boundary statement. No filler; the only weakness is that packing three inspection targets into a dense clause slightly reduces 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?

No output schema exists, yet the description gives no indication of what inspection results look like (per-check booleans, finality status, calldata match). For a verification tool with an opaque artifact parameter and no output schema, an agent has enough to attempt a call but not enough to interpret the result or anticipate failure modes.

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 only hints at the two parameters' roles ('signed OCD swap preflight artifact and Base transaction hash') without explaining the artifact's type, encoding, or what makes it 'signed', nor the tx hash format. The required-only schema leaves 'artifact' opaque, and the description does not compensate for the 0% coverage 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?

States a specific verb (inspect) and resource (Uniswap V3 exactInputSingle calldata, ERC-20 transfers, Base safe-head finality) given two specific inputs. It explicitly distinguishes itself from the preflight_swap sibling and from execution: 'OCD never executes the swap.' An agent can tell this is post-transaction independent observation rather than preflight construction.

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?

Implied usage is clear (observe after a swap preflight, given an artifact and tx hash), and the read-only inspection stance is stated, but the description names no alternative sibling or condition for choosing observe_swap over inspect_swap or get_receipt. No exclusions or prerequisite failure modes are given.

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=true and openWorldHint=true, but the description adds the critical caveat that 'ALLOW is policy only, never wallet authority' and that it returns a signed portable allowance artifact. This is meaningful behavioral context an agent cannot derive from annotations. It does not, however, describe deny/block behavior or what the artifact is consumed by.

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 tight, front-loaded sentences with no filler; the caveat sentence is deliberately punchy. Minor deduction for unexplained jargon ('OCD', 'signed portable allowance artifact') that costs the reader without adding immediate 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?

For a tool with a deeply nested policy schema, no schema descriptions, and no output schema, the description omits almost all policy semantics and the meaning of the returned artifact. It nails the purpose and timing but leaves too much of the invocation contract unstated.

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% with three nested-object parameters (action, policy, options) containing many subfields and enums. The description only loosely maps 'approve or revoke' to the intent enum and 'Base USDC' to token/network, leaving policy fields (allowed_tokens, unlimited_allowance, max_allowance_atomic, revoke_only, acknowledge_unconstrained) and options entirely undocumented.

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

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

States a specific verb (preflight/evaluate) and resource (Base USDC ERC-20 allowance approve/revoke action), and pins the timing 'BEFORE an agent asks its wallet to approve or revoke'. It is clearly distinguishable from siblings like inspect_allowance (read state) and preflight_payment (different resource).

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 'Call BEFORE an agent asks its wallet to approve or revoke' gives an explicit trigger condition, effectively telling the agent when this tool belongs in the flow rather than inspect/observe. It stops short of naming an alternative for reading current allowance state or stating when-not to call.

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 (readOnlyHint, openWorldHint), the description adds crucial semantic context: 'ALLOW is policy only, never wallet authority' and that it returns 'a signed portable bridge artifact.' This clarifies that a positive result is not authorization to execute, which is important behavioral information. It does not describe rate limits, error behavior, or what a DENY result entails.

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, each earning its place: the first establishes timing and scope, the second states the purpose and return, the third adds a critical caveat. It is front-loaded with the most actionable information (when to call).

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 a complex nested input schema, 0% schema coverage, and no output schema, the description is too thin. It provides purpose and a key semantic warning but omits any explanation of the required 'action' or 'policy' fields, leaving an agent unable to confidently construct a valid invocation without inspecting the raw 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 0% and both parameters are nested objects with many sub-properties. The description only mentions 'policy' in passing and gives no meaning for the 'action' object or any of its fields. With the schema providing no descriptions, the description fails to compensate, leaving an agent with no semantic guidance for constructing correct inputs.

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 ('evaluates strict policy' for a bridge) and resource ('Base USDC to Ethereum via Circle CCTP V2'), which clearly separates it from preflight_swap or preflight_payment. However, it does not explicitly name or contrast with sibling tools like inspect_bridge or observe_bridge, leaving some ambiguity for an agent choosing between preflight and inspection tools.

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

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

It explicitly says to call this 'BEFORE an agent asks its wallet to bridge,' giving clear temporal context. It does not state when not to use it or name alternatives (e.g., 'do not use after a bridge is submitted' or 'use inspect_bridge for existing transactions'), so it stops 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 readOnlyHint and openWorldHint annotations, the description discloses meaningful behavioral facts: funds are never touched, the receipt is independently verifiable, ALLOW does not guarantee execution, and this is only policy evaluation. This prevents a dangerous misreading of ALLOW as authorization. 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?

Three tight sentences front-load the most important information (call timing, result type, safety boundary) and every sentence earns its place. There is no fluff or repetition of schema content.

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

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

Despite having no output schema, the description clearly states the return shape (signed preflight receipt, verdicts, reasons) and the side-effect profile. The tool's nested-object complexity is addressed by the schema, while the description supplies the critical temporal and trust context needed for correct use.

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

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

The description adds a high-level mapping to policy constraints (max amount, allowed networks/assets, expected recipient, allowed origins), which helps the agent understand the policy object's intent. However, it does not document the action object, options, or references, so with 0% top-level description coverage it only partially carries the parameter-explanation burden; the schema's nested descriptions provide the remaining detail.

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

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

The description names a specific verb ('preflight'), a specific resource ('an autonomous payment' evaluated against policy), and the concrete result (signed receipt with ALLOW/REQUIRE_APPROVAL/BLOCK). It also distinguishes itself from actual payment authorization by explicitly stating the wallet/x402 client separately authorizes execution.

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

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

It gives a clear temporal trigger ('Call BEFORE an agent authorizes an autonomous payment') and a clear exclusion boundary ('Policy evaluation only: OCD never holds, moves, or authorizes funds'). It does not explicitly route to alternative sibling tools by name, 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety/read profile is covered. The description adds genuinely non-derivable context: the output is a signed portable artifact and ALLOW conveys policy, not wallet authority. It omits auth prerequisites, failure modes, and the fact that the artifact is meant to be carried downstream.

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 the invocation timing front-loaded and zero filler. Every clause adds information an agent needs (when to call, what it returns, how to interpret ALLOW).

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

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

No output schema exists, and the description partially compensates by characterizing the returned artifact and ALLOW semantics. However, for a 2-parameter tool with nested objects and 0% schema documentation, the description leaves the entire input contract unexplained, which is a real gap for correct 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?

Schema description coverage is 0% and the two required parameters are nested objects with constrained fields (kind const STAKE, protocol const lido-steth-submit, policy sub-fields), yet the description explains none of them. 'Strict policy' only faintly gestures at the policy object; action fields like staker, network, input_asset and max_amount_wei are undocumented anywhere.

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 ('preflight'/call before) and resource (ETH staking to Lido stETH) and what it returns ('a signed portable staking artifact'). It implicitly distinguishes itself from the inspect_/observe_ siblings by prescribing use before wallet submission, though it never names 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?

Gives explicit timing guidance ('Call BEFORE an agent asks its wallet to submit ETH to Lido stETH') and clarifies the meaning of an ALLOW result ('policy only, never wallet authority'). It stops short of naming which sibling to use instead when the agent is inspecting or verifying rather than preflighting.

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 readOnlyHint/openWorldHint annotations, it discloses the return value ('signed portable policy artifact') and a critical semantic caveat ('ALLOW is policy only, never wallet authority'). This adds genuine context the annotations do not carry. It still omits what a DENY looks like or any rate constraints.

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?

Only two sentences, with the most important instruction ('Call BEFORE...') front-loaded. Every sentence carries signal; the compression is appropriate for a preflight guard.

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 complex nested inputs and no output schema, the description covers intent, timing, and the authority caveat, but leaves the action/policy parameter mechanics and the DENY path undocumented. Adequate minimum but with 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% for two large nested objects (action and policy, each with many required sub-fields). The description explains the overall framing but nothing about the action/policy split, the required sub-fields, or their constraints, so it fails to compensate for the coverage 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 names a specific action and resource scope: it evaluates a narrow Base USDC-to-WETH direct Uniswap V3 swap and returns a signed portable policy artifact. That scope distinguishes it from preflight_allowance and preflight_payment. Minor deduction because terms like 'OCD' and 'policy artifact' are jargon an agent must infer.

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 explicit timing guidance ('Call BEFORE an agent asks its wallet to execute...'), which is the key decision point for a preflight tool. It does not name the alternative preflight/inspect siblings 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 already declare readOnlyHint=true and openWorldHint=true. The description transparently discloses the output format (scored candidate matches with matched name, SDN type, program), the scope (screening aid, not determination), and the limitation that weak AKAs are excluded. No contradictions 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?

The description is concise at three sentences, front-loading the main purpose. It is well-structured: first the action, then output, then scope/limitations. Minor improvement could be breaking into bullet points for readability, but overall 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?

Given no output schema, the description adequately explains the return format (scored candidates with matched name, SDN type, program). It covers important constraints (weak AKAs excluded, need for secondary identifiers). For a screening tool with simple parameters, this is 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?

Schema description coverage is 100% for both parameters, so baseline is 3. The description does not add significant new meaning beyond the schema's descriptions for 'name' and 'threshold'. The schema already explains the threshold range and default. The description's context aligns but does not enhance parameter 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 clearly states the verb 'fuzzy-match' and the resource 'person or company name against the OFAC SDN list'. It specifies it screens primary names and strong aliases, distinguishes from weak AKAs, and clarifies it is a screening aid, not a determination. The purpose is distinct from sibling tools like 'screen_wallet' or 'verify_uk_company'.

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

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

The description explicitly states when to use: for AML/KYC/sanctions compliance. It provides clear exclusions: weak AKAs are not screened, and a match is not a final determination, requiring secondary identifiers. However, it does not explicitly compare to sibling tools or state when not to use 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 already declare readOnlyHint=true and openWorldHint=true. The description adds valuable behavioral nuance: it reflects current status including delistings, and returns only a boolean with no case-level detail. This exceeds what annotations alone disclose and sets correct expectations about output granularity.

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 sentences, front-loads the core action and oracle, then adds output behavior and a practical usage trigger. Every sentence contributes meaningful information without redundancy or filler.

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

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

For a single-parameter read-only tool with no output schema, the description is complete: it names the data source, explains dynamic status changes, specifies the boolean return type, and tells the agent when to call it. The schema covers address format, so nothing essential 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 description coverage is 100% and the schema already documents the address as an EVM wallet address with 0x + 40 hex format. The description repeats 'EVM wallet address' but adds no new semantic detail beyond the schema, so the baseline score of 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 description uses a specific verb ('Sanctions-screen') and resource ('EVM wallet address') against a named oracle (Chainalysis), and clearly distinguishes the output as a sanctioned/not-sanctioned boolean. This differentiates it from sibling tools like screen_name and verify_us_company without needing to inspect 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 clear when-to-use guidance: 'Call before sending USDC or other funds to an address, for AML compliance and counterparty due diligence.' It does not explicitly name alternative tools or state when not to use it, but the context is strong enough for an agent to select it appropriately.

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 readOnlyHint annotation, the description discloses the online trust model, the fact that the server fetches the signing-key registry, the convenience-vs-trust tradeoff, and the free/no-payment nature. It also exposes the operational difference between lookup-based and direct-envelope verification, which is genuinely useful behavioral context.

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 core outcome and then covers input modes and trust caveats without excessive fluff. Each sentence adds information, including the offline alternative, though the trust-model explanation is somewhat longer than strictly 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?

For a simple read-only, two-parameter tool with no output schema, the description covers invocation modes, input constraints, result categories, and the key trust caveat. Nothing critical is missing for an agent to decide whether and how 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 100%, so the baseline is already 3, but the description adds meaningful semantics: receipt_id triggers a lookup with a public-required condition, while envelope is verified directly without requiring publication. It reinforces mutual exclusivity and clarifies the envelope's shape ({schema, receipt, proof}), going beyond the bare 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 states a specific verb ('checks'), a specific resource ('receipt'), and names the three possible outcomes ('VALID, INVALID, or UNVERIFIABLE') with a reason code. This clearly distinguishes it from sibling verification tools like verify_uk_company and verify_us_company, which target different entities.

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 concrete usage guidance: use receipt_id for a public lookup or pass an existing envelope for direct verification, and notes the public requirement and that no publication is needed. It also mentions the offline package as a stronger trust alternative, though it does not explicitly name sibling tools like get_receipt as alternatives or state exact conditions for when to prefer them.

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 carry readOnlyHint=true, and the description aligns with that. It adds behavioral context beyond annotations by identifying the authoritative government source and listing the returned data categories, which is useful for calibration.

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

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

Three sentences, each earning its place: the first names the source and subject, the second lists returns, and the third states the business purpose. No filler or redundant restatement of the 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?

With no output schema, the description compensates by naming the expected return fields and use case. It is complete for a one-parameter read-only lookup, though it omits edge-case behavior (e.g., not-found handling), which is 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 100% and the lone companyNumber parameter is already described with format guidance. The description's 'Given a UK registration number' adds no new semantics beyond the schema, so a mid-range baseline 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 description opens with a specific verb+resource: 'UK company KYB lookup via the official Companies House register,' and enumerates concrete return fields. It explicitly scopes to UK registration numbers, distinguishing it from the sibling verify_us_company.

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 states clear call context: 'to confirm a UK business is real, active, and who controls it, for KYB onboarding and counterparty due diligence.' It does not explicitly name a US alternative or state when not to use it, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint=true, and the description adds useful behavioral detail beyond that: ambiguous names return candidates and never a silent selection, and only SEC-registered public companies and funds are covered. This helps the agent predict edge-case behavior without contradicting any annotation.

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 stated in the first sentence. Each subsequent sentence adds distinct value: input forms, returned fields, ambiguity handling, scope boundaries, and intended use case. There is no filler or repeated 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?

Since there is no output schema, the description compensates by explicitly listing the returned fields: entity name, CIK, SIC industry, state of incorporation, exchanges/tickers, address, and latest SEC filing. It also covers ambiguity handling and scope exclusions, giving an agent enough information to call the tool and interpret its results 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 description covers 100% of the single parameter and already provides examples of ticker, CIK, and company name. The tool description restates that the query can be a ticker, CIK, or company name but adds no additional parameter semantics beyond the schema, so the baseline of 3 applies.

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-resource pair: 'US public company verification via SEC EDGAR', and enumerates both accepted inputs (ticker, CIK, company name) and returned fields. It also distinguishes itself from siblings by limiting scope to SEC-registered public companies and funds, and explicitly excluding private US companies.

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: 'Call for KYB and counterparty due diligence on listed US entities.' It also sets boundaries by stating coverage is limited to SEC-registered public companies and funds only. It does not explicitly name alternative tools like verify_uk_company, so it stops short of a full when-to-use versus alternatives statement.

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