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 useful traits: the investigation is 'deterministic' and it 'audits on-chain transaction logs' to 'verify actual unauthorized wallet loss' rather than rubber-stamping, and it signs an EIP-712 verdict. However, it omits whether the signature is submitted on-chain, permission/auth requirements, and any failure or rejection behavior for a signing operation.

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 the purpose front-loaded and no filler. It is efficient, though the heavy domain jargon ('EIP-712 ExploitClaimVerdict', 'AgenticShieldPool.sol') requires prior context.

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 signing/mutation tool with no annotations and no output schema, the definition is domain-accurate but thin. It doesn't describe the verdict result, what happens after signing, or how the four required parameters interlock, leaving real gaps for an agent invoking it correctly.

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

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

Schema description coverage is 100%, so the schema already documents the category enum values, agentSafe, exploitedTxHash, attestationNonce, and authorizedMaxSpend. The description adds no parameter-level meaning beyond that (e.g., units, formatting, or relationship between nonce and attestation). Baseline 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 names specific verbs (audit, sign) and precise resources (forensic loss investigation, EIP-712 ExploitClaimVerdict, AgenticShieldPool.sol, on-chain transaction logs). It is far more specific than a sibling like inspect_code_ast_safety, though it never explicitly names a sibling it complements or supersedes. An agent can identify the domain, but the dual 'audit + sign' nature isn't resolved into one clear outcome.

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 explicit when-to-use, when-not-to-use, or alternative-tool guidance. The phrase 'verifies actual unauthorized wallet loss' implies the tool is for loss-claim adjudication, but the agent must infer the triggering conditions entirely. No mention of prerequisites such as a prior SecurityGate attestation flow.

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

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

No annotations are provided, so the description carries full burden. It mentions the dynamic nature and on-chain history basis, but does not disclose read-only nature, error handling, or any side effects. Adds some behavioral context but not comprehensive.

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

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

Two sentences, main purpose front-loaded. Second sentence repeats some terms (FICO-style, investment grade, lending capacity) and adds usage guidance; somewhat redundant but still 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?

Simple one-parameter retrieval tool with no output schema. Description enumerates the three returned components and includes clear use/exclusion guidance, making it adequate for agent 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 100% with a clear, detailed description of the agent_address parameter. The tool description adds no extra parameter meaning beyond the schema, which is acceptable given full 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?

States a specific verb 'Retrieves' with resource 'credit rating' and enumerates exact outputs (FICO score, investment grade, lending capacity). Explicitly distinguishes from security-focused siblings by naming them as 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?

Provides explicit when-to-use ('ONLY to evaluate financial creditworthiness') and when-not-to-use ('Do NOT use for security, injection, or code auditing') with references to respective security inspection tools.

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

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

With no annotations, the description carries the full burden and it does disclose key behavior: it evaluates qualification, returns an EIP-712 CreditCertificate, and is intended for on-chain submission on Polygon rather than executing the loan itself. It does not disclose failure or eligibility behavior or side effects, but the core behavioral profile is clear.

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?

Four dense, purposeful sentences with the core function front-loaded and no filler. The exclusion statements are compact and each sentence earns its place by clarifying when not to call the tool.

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

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

The description covers the purpose, output type, target contract and network, and usage boundaries, which is sufficient for selecting and invoking the tool correctly. It does not explain return-value details or failure modes, but the absence of an output schema is partially mitigated by stating what the certificate is for.

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?

Input schema coverage is 100%, so the parameters already have inline descriptions and defaults. The description adds broader context about loan use cases but no parameter-specific syntax or constraints beyond the schema, so a baseline 3 is appropriate.

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

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

States a precise action: evaluates uncollateralized credit loan qualification for an autonomous AI agent and returns an EIP-712 CreditCertificate for on-chain submission to AgentLendingPool.sol on Polygon. It names the resource, target contract, and network, and distinguishes itself from siblings (quote_agent_insurance, verify_agent_output). This leaves no ambiguity about the tool's role.

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 scopes when to use: only when an autonomous AI agent needs uncollateralized USDC capital for operational runway, staking deposits, or task execution. It also states two negative conditions with named alternatives, so an agent knows not to use it for insurance or prompt-injection scanning.

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 burden. 'Retrieves' indicates a read-only operation, and the content described (passport, risk classification) implies no side effects. However, it does not mention potential errors, rate limits, or explicit read-only guarantees, so a small deduction.

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

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

The description is concise and well-structured: two sentences, front-loading the primary function and then providing usage guidance. No redundant or unnecessary text.

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 complete for a simple tool with one parameter and no output schema. It lists the items returned (Compliance Passport, risk classification, etc.) and explicitly scopes usage, leaving no critical information 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?

The only parameter (agent_address) is fully described in the schema with a clear explanation of its format and purpose. The tool description adds no extra semantic nuance beyond what the schema already provides, so baseline 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?

Clearly states the tool retrieves an EU AI Act Compliance Passport and related data, with a specific verb and resource. Explicitly differentiates from siblings by specifying when to use and when not to use.

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

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

Provides explicit usage conditions: 'Use this tool ONLY when assessing regulatory compliance' and directs to alternatives for other cases (inspect_agent_output, get_agent_credit_rating).

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 burden and does well: it discloses the concrete return artifacts (v, r, s calldata and EIP-712 signatures), the target chains (Polygon, Base, Arbitrum), and the required execution context (Safe or Guard contract). It stops short of covering signing/key-handling expectations or determinism, so it is strong but not exhaustive.

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 clauses: purpose/artifacts first, then the positive usage constraint, then the negative constraint with the named alternative. No filler, and the routing information is front-loaded after the primary identity statement.

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 2-parameter tool with no output schema and no annotations, the description supplies purpose, scope, target networks, output form, and sibling routing. Remaining gaps (signing credentials, failure modes for exceeding risk_score_max) are minor but real.

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 both parameters (action_payload, risk_score_max) are fully documented in the schema with defaults and examples. The description adds no further parameter-level meaning (e.g., how risk_score_max is evaluated or what happens on rejection), 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?

States a specific verb (Generates) and precise artifacts (EIP-712 signatures, raw Solidity calldata v/r/s) plus a scope (smart contract-level on-chain agent guardrails) and supported networks. It is immediately distinguishable from sibling tools like inspect_agent_output and verify_agent_output.

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 encodes when to use ('ONLY when preparing on-chain smart contract transactions that require EIP-712 safety proof for an on-chain Safe or Guard contract') and when not to use it, naming the alternative ('use `inspect_agent_output` instead'). Preconditions and the excluded off-chain/text-audit cases are stated directly.

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

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

With no annotations, the description carries the full burden, and it discloses meaningful traits: it produces a cryptographic EIP-191/EIP-712 proof, it enables a fee rebate and 0s finality downstream, and it is not suited to high-throughput pre-flight screening. It stops short of stating side effects, determinism, cost/latency, or what happens when context_ground_truth is omitted.

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

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

Front-loads the core purpose and the when/when-not routing in the first and third sentences. The bracketed cost-rebate notice is promotional and interrupts the flow, though it does convey a genuine downstream incentive, so it earns only partial credit.

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 should cover returns; it names the attestation proof but not the response shape or failure modes. For a three-parameter inspection tool with clear routing and a stated attestation artifact, this is adequate but not fully complete.

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

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

Schema description coverage is 100%, so the schema already explains agent_output, context_ground_truth, and is_code. The description adds only an indirect signal ('against a reference context') and does not clarify that context_ground_truth is optional or how is_code changes behavior, so the baseline 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?

States a specific verb (inspect) and resource (agent outputs) with explicit scope: security + NLI hallucination verification against a reference context, plus an EIP-191 attestation. It also names the siblings it is not (verify_agent_output, inspect_code_ast_safety), so an agent can distinguish it without opening any schema.

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

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

Explicit 'Use this tool ONLY when...' conditions (deep hallucination verification, or needing a signed attestation before publishing), followed by two 'Do NOT use' clauses each naming the correct alternative and the condition that selects it. This is close to ideal 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?

With no annotations available, the description must carry behavioral disclosure. It states the tool is deterministic, a static AST parser, and intended for use prior to sandbox execution, which strongly implies it does not execute code and has no side effects. It does not mention output format or failure modes, but the core safety-relevant trait of non-execution and determinism is communicated.

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, front-loaded with the core purpose, followed by usage boundaries and alternatives. Every sentence earns its place, with no fluff or repetition of schema content. The structure is easy to parse.

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 a single-parameter, no-output-schema tool, and the description covers input, when-to-use, and exclusions. However, it never explains what the tool returns (e.g., a hazard report, verdict, or pass/fail), which is important because there is no output schema to fall back on.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning by broadening the accepted input to include 'shell scripts', which the schema's 'Python source code snippet' alone does not communicate. It also reinforces that the input is raw source code, not natural language, adding useful context beyond the schema.

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

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

The description opens with a specific verb-plus-resource construction: 'Deterministic Python Abstract Syntax Tree (AST) parser scanning for hazardous operations' and lists concrete hazards (subprocess, os.system, eval, exec, socket, token exfiltration). It also differentiates from siblings by explicitly stating the intended input domain and pointing to alternatives. This is 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?

It provides explicit when-to-use guidance ('ONLY when validating raw Python source code or shell scripts ... prior to sandbox execution') and a clear do-not-use case ('Do NOT use this tool for natural language text or generic agent messages'). It also names alternatives (`verify_agent_output` or `inspect_agent_output`), leaving no inference needed.

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

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

No annotations are provided, so the description carries the full burden. It discloses latency characteristics (<2ms), that it is deterministic, and that it is purely lexical/syntax-based (not semantic), which are meaningful behavioral traits. It does not describe the return shape or what action the caller should take on a positive detection, which keeps it from a 5.

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

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

Two tight sentences with the latency claim front-loaded and threat categories grouped efficiently. It is slightly dense with parenthetical example lists but nothing is wasted.

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 pre-execution inspection tool with no output schema and no annotations, the description covers purpose, timing, performance envelope, and detection scope. The main gap is what the inspector returns or what the caller should do on detection.

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

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

Schema description coverage is 100%, so the schema already documents the single command parameter with examples. The description adds only that inspection happens pre-execution, which is context rather than parameter syntax. Baseline 3 is appropriate.

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

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

States a specific verb (inspect) and resource (shell commands) with concrete scope and the sibling-distinguishing characteristic of being a lexical/syntax inspector rather than an output or AST inspector. The examples of what it detects make the purpose unmistakable.

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 terminal execution' clearly signals when to invoke it, and 'intercepts' implies a pre-execution gate. However, it never explicitly names alternatives like inspect_code_ast_safety or states when this lexical approach should be preferred over that AST-based sibling.

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 processing behavior beyond schema: verifying GPS geofence arrival within a default 500m tolerance, calculating a deterministic Merkle Root, and identifying SLA threshold breaches. However, it omits permissions, side effects, and whether the operation is read-only, leaving meaningful behavioral 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 single sentence is front-loaded with 'Audits cold-chain...' and every clause contributes specific scope. It is dense but contains no filler, though splitting it into shorter sentences would improve readability slightly.

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 complex tool with 5 parameters, no annotations, and no output schema, the description covers the core audit behavior and implies outputs (Merkle Root, SLA breaches). It lacks explicit return format details, but gives enough for an agent to understand invocation and purpose.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by naming sensor log contents (humidity, shock, E-Seal tamper status) that the schema example omits, and by confirming the default 500m geofence tolerance that maps to maxGeofenceMeters. This exceeds the schema's own 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 ('Audits') and resource ('cold-chain and transit environmental sensor logs') and enumerates key operations: temperature/humidity/shock/E-Seal audit, GPS geofence verification, Merkle Root calculation, and SLA breach identification. This clearly distinguishes it from logistics_verify_ebl and logistics_issue_pod_attestation, which handle different logistics artifacts.

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 state when to use this tool versus alternatives, nor does it include prerequisites or exclusions. Usage is only implied by the tool's purpose, matching the calibration MID case where lack of explicit when-to-use guidance scored 2.

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 behavioral burden and does disclose the key side effect: it autonomously unlocks freight/commodity escrow funds via an EIP-712 signature. However, it omits critical operational traits such as what happens when any verification fails, whether the signature is idempotent/repeatable, and any authorization requirements for the escrow contracts.

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 that front-load the verification scope before the consequence (signature issuance and escrow unlock). No filler, though the jargon density makes it heavier 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 complex, high-stakes signing tool with no output schema and no annotations, the description covers purpose and main side effect but leaves out failure semantics, auth requirements, and what the returned signature contains. Given the complexity and the absence of structured safety hints, it is only partially complete.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters and the baseline is 3. The description adds only loose linkage (geofence <500m maps to maxGeofenceMeters, telemetry Merkle root maps to sensorLogs) without clarifying formats or edge cases beyond the schema.

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

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

States a specific compound action: verifies four named conditions (terminal discharge, GPS geofence arrival, customs clearance, telemetry Merkle root) and issues an EIP-712 ProofOfDelivery signature. This distinguishes it from siblings like logistics_verify_ebl (verification only) and logistics_audit_telemetry, making the issuing/attestation role unmistakable.

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 this is the terminal step in a POD flow and hints at a prerequisite (blDocumentHash originates from logistics_verify_ebl), but it never explicitly states when to call this versus logistics_verify_ebl or logistics_audit_telemetry. Usage is inferable from context but not spelled out.

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 behavioral burden. It does disclose two non-obvious traits: the tool returns a cryptographic hash, and it has a paid two-tier pricing model tied to a Security-Gate-x402 signature. It does not say what happens on verification failure, whether it is read-only, whether external carriers/AIS providers are queried, or what error shape to expect.

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

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

Three dense sentences, front-loaded with the verification targets, then the output, then cost. No filler. The pricing clause is long but is materially useful information an agent must know before invoking.

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 six-required-parameter, no-annotation, no-output-schema tool, the description covers the output hash and the cost model but omits failure/negative-result behavior, which matters for a verification tool. Adequate but with clear gaps an agent would want filled.

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% with all six parameters documented with examples (e.g. MAEU123456789, KRPUS, 9876543), so the baseline is 3. The description adds no parameter-level detail beyond the schema, offering no format rules or cross-field constraints.

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

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

The description states a specific verb (Verifies) applied to three concrete resources with named standards: DCSA eBL v3.0, ISO 6346 container numbers, and AIS vessel IMO tracking. It also names the concrete output (blDocumentHash). It does not differentiate itself from siblings like logistics_audit_telemetry or logistics_issue_pod_attestation, 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?

Usage is only implied: 'for on-chain escrow creation' hints at when the hash is needed, and the dual pricing tier signals a payment-signature path. There is no explicit when-to-use, when-not-to-use, or named alternative among the many verify_*/audit_* 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?

With no annotations, the description carries the full transparency burden. It discloses that the tool produces a cryptographically signed EIP-712 PolicyQuote and describes the scope of coverage. However, it does not state whether issuing the quote has side effects, requires payment, or has any prerequisites.

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?

Every sentence earns its place: the first states the core action, the second gives precise when-to-use context, and the last two warn against misuse with explicit sibling alternatives. It is thorough without being bloated.

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

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

The tool has no output schema, but the description names the output artifact (a signed EIP-712 PolicyQuote), fully documents all parameters via the schema, and resolves sibling ambiguity. It is slightly light on what the caller should do with the returned quote, but it is complete enough 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 100%, and every parameter is already well documented with defaults and examples. The description adds contextual framing for the tool overall but does not need to add parameter-level detail, so the baseline 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 clearly specifies the verb ('Calculates... premium and issues... PolicyQuote'), the resource (actuarial underwriting for AI agent liability insurance), and the exact covered risks. It also distinguishes the tool from siblings by explicitly naming what it is not for.

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

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

The description provides explicit when-to-use guidance ('Use this tool ONLY when...') and explicit exclusions with named alternatives (`get_agent_loan_quote`, `inspect_agent_output`). This leaves no ambiguity about tool selection.

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 discloses the price source (sub-second Pyth Hermes oracle) and atomic execution against AgentEscrow and AgentTreasuryVault DMM, which is useful. However, it omits key traits for a financial mutation: required approvals/auth, gas and fees, slippage protection, order expiry, and irreversibility of a submitted trade.

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, purpose front-loaded, with the usage condition placed last. Some marketing-style naming ('Universal Agent-Native Exchange Solver', 'AgentTreasuryVault DMM') is heavier than needed but not obstructive.

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 6-parameter, write-path financial tool with no annotations and no output schema, the description covers purpose and execution venue but leaves the agent without settlement semantics, resulting intent status, or failure modes. It is minimally sufficient, not complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's pair enumeration and market/limit mention merely restate what the schema already documents, adding no syntax, format, or constraint detail beyond it (e.g. how limit_price interacts with the oracle price).

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?

Names a specific verb (submits) and resource (agent trade intent), plus the venue (Universal Agent-Native Exchange Solver on Polygon) and the instruments (ETH/USDC, BTC/USDC, SOL/USDC). The purpose is unambiguous, though it never explicitly contrasts itself with any sibling tool.

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 final sentence gives an explicit usage context: execute hedging swaps or trade digital assets programmatically. There are no exclusions or named alternatives, but none of the read-only sibling tools compete for the same job, so the guidance is adequate.

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 notes the tool is deterministic and ultra-fast (<5ms), and lists detection categories, implying a read-only scanning operation. However, it does not explicitly state side effects, permissions, or whether any action is taken, leaving some uncertainty about its behavior. Since annotations are absent, this information is helpful but not exhaustive.

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

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

The description is well-structured with a main function statement followed by usage and exclusions. It repeats key phrases like 'ultra-fast' and 'prompt injections, jailbreaks, and secret leaks' for emphasis but remains concise. It efficiently communicates the tool's niche 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?

Given the lack of an output schema, the description appropriately focuses on input and usage. It provides context such as determinism and speed, and it names alternative tools for different needs. While it doesn't detail the return format, that is not required without an output schema. Overall, it is complete for its intended 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 schema fully describes the 'text' parameter as the content to inspect, and the tool description adds specific secret types (OpenAI, Anthropic, private keys, etc.). This enriches the parameter semantics beyond the schema, clarifying what to look for. The description effectively complements the schema.

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

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

The description clearly states the tool's function: scanning for prompt injections, jailbreaks, and secret leaks in text. It specifies the types of secrets and the context (autonomous agent actions), distinguishing it from sibling tools. This provides a precise 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 explicitly says to use this tool for ultra-fast pre-flight screening and lists what it screens. It also provides clear exclusions and alternative tools for factual grounding and on-chain attestations, guiding when not to use it. This gives comprehensive usage guidance.

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