openfang-rail

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint=false, covering side-effect safety. The description adds meaningful behavioral detail by explaining the local checksum validation algorithm. It does not contradict the annotations, and the output schema covers return-value behavior.

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

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

A single, front-loaded sentence contains the essential verb, resource, and algorithm with zero filler. Every word earns its place.

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

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

For a simple, single-parameter validation tool with rich annotations and an output schema, the description is complete. The agent knows what to pass, what the operation is, and that it is safe/idempotent.

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 only parameter, aba_routing, is fully described as a '9-digit US bank routing number.' The tool description adds no additional parameter-level meaning beyond the algorithm context, 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 ('Validate') and a specific resource ('US ABA routing number'), and further distinguishes the tool by naming the exact checksum method ('(3,7,1)-weight mod-10 checksum'). This clearly differentiates it from sibling validators such as luhn_check or iban_check.

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

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

The description provides clear usage context: use this tool when validating a US ABA routing number. It does not explicitly state when not to use it or name alternative tools, but the intended scope is unambiguous for such a targeted validator.

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

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

Annotations already indicate readOnly and idempotent behavior. The description adds useful context by specifying the exact validation mechanism (mod-89 checksum), which clarifies the scope of validation and what the tool does beyond a simple presence 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?

The description is a single focused sentence that front-loads the action and key constraint. Every word contributes meaning, with no repetition of the title or extraneous details.

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

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

For a single-parameter, read-only validation tool with a complete schema and an output schema, the description is sufficient. It explains the purpose, method, and scope without needing to detail return values, which are covered by the output schema.

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

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

Schema coverage is 100% and already documents the abn parameter as an 11-digit Australian Business Number with spaces allowed. The description reiterates '11 digits' but adds no new parameter-specific information beyond what the schema provides.

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

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

The description clearly states a specific action ('Validate') on a specific resource ('Australian Business Number') and adds the method ('mod-89 checksum (11 digits)'). This distinguishes it from sibling validation tools like luhn_check or ean13_check.

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

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

The description implies when to use the tool: whenever an Australian Business Number needs checksum validation. However, it does not explicitly compare against alternatives or state when not to use it, so the guidance is only 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?

Annotations already declare readOnlyHint and idempotentHint, so the read-only nature is covered. The description adds value beyond the annotations by disclosing the preflight behavior that prevents payment during RPC outages and noting that return data includes raw units and decimals provenance, which is useful context not in the schema or 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 written sentences, with the core behavior front-loaded and the preflight guarantee earning its place. There is no filler 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?

For a simple read-only tool with two parameters, full schema coverage, and an output schema, the description covers the essential behavior, defaults, and a notable operational guarantee. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so the schema already documents both address and token_address. The description adds minor context (native ETH plus token, Base default, raw units) but does not materially expand on the parameter semantics beyond what the schema provides.

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

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

The description states a specific operation (on-chain balance snapshot) with explicit scope: native ETH plus one ERC-20 token, defaulting to USDC on Base. This clearly differentiates it from sibling erc20_balance, which likely covers only token balances, and from other validation/check tools.

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

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

The description makes the use case clear: when an EVM address's native ETH balance plus an optional ERC-20 token balance is needed, with a specific default token and chain. It does not explicitly name alternatives or exclusion conditions, so it stops short of a 5, but the context is strong enough for an agent to select it correctly.

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

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

The description adds operational detail beyond the annotations by disclosing 'one voucher, one settlement, one signed XDR-1 receipt' and flat pricing. This is useful context for an agent deciding whether to invoke the tool. There is no contradiction with the readOnlyHint, since payment/settlement is not described as mutating external data in the validation sense.

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

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

The description is two dense sentences with no filler: the first presents the action, scope, and batching model; the second gives the pricing rationale. Key information is front-loaded and every clause earns its place.

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

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

Given the simple single-parameter schema, the existing output schema, and annotations, the description fully covers batching capability, payment behavior, and the economic reason to use it. An agent has enough to select and invoke the tool correctly without missing critical context.

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

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

The input schema already provides 100% coverage for the single `items` parameter, including the `tool` enum and `value` descriptions. The description only restates the 'up to 50' limit and lists identifier types, adding no meaning beyond the schema, 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 opens with a specific action and resource: 'Run up to 50 identifier checks... in ONE paid call.' It also differentiates itself from the many individual sibling validator tools by emphasizing batching and the per-check cost advantage over single calls.

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

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

The description clearly signals batch use cases through 'up to 50 checks in ONE paid call' and '10x cheaper per check than single calls,' which implies choosing this over individual sibling tools for multi-item validation. It stops short of an explicit 'use individual tools for a single check' exclusion, but the context is clear enough.

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 signal read-only and idempotent behavior. The description adds meaningful extra context with 'Preflighted so you never pay during an RPC outage,' disclosing a preflight mechanism and cost-protection guarantee that the annotations do not convey.

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 short sentences deliver the core purpose and a valuable behavioral note with no wasted words. The essential return fields are front-loaded, and the preflight benefit appears second without bloating the description.

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, optional-parameter tool with an output schema, the description covers the purpose, the acceptable input, and an important usage safeguard. Nothing essential for selecting and invoking this tool correctly is missing.

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

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

The input schema fully documents the single optional 'block' parameter with format, tag options, and default behavior, so schema coverage is 100%. The description only loosely echoes this with 'or specified,' adding no substantive semantic detail 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 clearly identifies the tool as returning a Base block header with specific fields (number, timestamp, transaction count, base fee) for the latest or specified block. This precise resource-and-verb framing distinguishes it from the many validation and balance-check siblings.

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

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

The description establishes a clear context: use this to get block header information on Base, optionally for a specific block. It does not name alternative tools or explicit exclusions, but the scope is clear enough for an agent to route to it correctly.

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

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

The annotations already declare readOnlyHint and idempotentHint, so the description's main added value is clarifying that existence is not verified. That is a meaningful behavioral boundary beyond what annotations provide, though no further details about edge-case behavior are given.

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

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

A single sentence with no filler. It front-loads the action and resource, then adds the critical boundary ('not existence') in a parenthetical. Every word earns its place.

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

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

For a single-parameter validation tool with 100% schema coverage, an output schema, and read-only/idempotent annotations, the description provides everything needed to invoke it correctly. The 'not existence' clarification removes the most likely ambiguity.

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

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

Schema description coverage is 100% and the parameter description already specifies '8 digits, or 2 letters + 6 digits.' The tool description adds no new parameter-level meaning, 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 uses a specific verb ('Validate') and a specific resource ('UK Companies House number format'), and explicitly clarifies it does not check existence. This clearly distinguishes it from existence-checking tools among the many sibling validation tools.

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

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

The exclusion '(not existence)' tells the agent that this tool is only for format validation, not registration status. However, it does not explicitly name alternative tools for existence checks, so it stops short of full when-to-use versus alternative guidance.

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

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

Beyond the annotations (readOnly, idempotent), the description adds substantial behavioral detail: determinism, exact output components, stop-word exclusion, and the specific hash algorithm keccak-256. It also explicitly rules out external calls and ML, giving the agent a precise model of the tool's behavior.

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

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

Two tightly packed sentences, no filler or redundancy. The most important information (outputs and determinism) is front-loaded, and the functional nature of the tool is stated immediately.

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 fully covers the tool's behavior for a single-parameter pure function with an output schema present. It tells the agent what results to expect, the deterministic nature, the absence of side effects, and the hashing algorithm, leaving no meaningful 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 100%, including the note about arbitrary length and hashing over the exact input, so the tool description does not need to add parameter-level detail. The description contributes no additional parameter semantics but also does not need to, given the schema already fully documents the single 'text' parameter.

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

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

The description states a specific action and resource: 'Deterministic text digest' followed by exactly what it produces — word count, top-5 frequent words, first sentence, and keccak-256 hash. This clearly differentiates it from the sibling validation/check tools by emphasizing pure local computation rather than external lookups.

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

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

The description gives a clear context for when to use the tool: any time a deterministic local text summary is needed. It does not explicitly name alternatives, but the explicit statement 'Pure function — no external calls, no ML' establishes that this is the appropriate choice for offline text analysis, and no sibling tool competes for that role.

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 idempotentHint annotations, the description discloses the public API source, automatic ticker-to-id mapping, 60-second server-side caching, and preflight protection against paying during an API outage. This adds meaningful operational context without contradicting 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 tight sentences convey the core behavior, scope, and key operational details with no redundancy. The most important information—what the tool returns—is front-loaded.

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

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

For a single-parameter read-only tool with an output schema, the description covers the essential context: what is returned, for which inputs, from which source, with caching and outage protection. Nothing critical 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%, so the schema already documents the 'symbol' parameter. The description adds value by explaining that common tickers are automatically mapped to CoinGecko ids, reducing the user's burden to know CoinGecko-specific asset identifiers.

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

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

The description clearly states a specific verb ('Current spot price') and resource (a symbol via the public CoinGecko API), with the currency explicitly USD. This also distinguishes it from the sibling validation and balance tools, which serve entirely different purposes.

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

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

The description gives clear context for when to use the tool: to fetch the current spot price in USD for a supported crypto symbol. It does not explicitly name alternatives or exclusions, but no sibling tool appears to offer similar price functionality.

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 mark the operation read-only and idempotent. The description adds the behavioral validation rules (country code, total digit count, no leading zero), which an agent needs to understand what this check actually tests.

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?

One tightly scoped sentence that front-loads the main action and packs the essential validation criteria. No filler or redundant restating of the tool name.

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

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

For a single-parameter validation tool with an output schema and safety annotations, the description covers what the tool does, what it checks, and its exact format requirements. Nothing needed for correct invocation 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% (the phone parameter is described with an example), but the description goes beyond the schema by defining the exact E.164 constraints: +CC, 8-15 digits, no leading zero. This adds semantic meaning not present in the schema's bare 'International phone number' phrasing.

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 ('Validate') and a precise resource ('a phone number's E.164 structure'), and spells out the format rules (+CC, 8-15 digits, no leading zero). This makes it easy to distinguish from sibling validators like iban_check or isbn_check.

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

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

The description gives clear context: use this tool when you need to validate an international phone number against E.164 formatting. It doesn't explicitly name exclusions or alternative tools, but the format-specific scope is unambiguous among the sibling validators.

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 idempotentHint, so the safety profile is covered. The description usefully adds that this is only a checksum-level validation with specific weighting, not a full GS1 semantic or registry 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?

A single sentence conveys the action, target, and algorithm with no filler. The key information is front-loaded and every word earns its place.

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

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

For a single-parameter, read-only, idempotent validator with an output schema, the description plus schema fully cover what an agent needs: input format, validation method, and safety profile. Nothing important 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?

The input schema already fully documents the one parameter (13-digit EAN-13 barcode; spaces/dashes allowed), and schema coverage is 100%. The description adds no additional parameter behavior beyond the checksum algorithm, 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?

The description states a specific action ('Validate'), a specific resource ('EAN-13 barcode'), and the exact checksum method (mod-10 with odd positions x1, even positions x3). This distinguishes it from generic checksum validators like luhn_check and other identifier checks.

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

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

The description clearly implies the intended use case: validating EAN-13 barcodes by checksum. It does not explicitly name alternatives or exclusions, but the barcode-specific wording is unambiguous enough for an agent to select it correctly.

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

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

Annotations already provide readOnlyHint and idempotentHint, so safety and repeatability are covered. The description adds meaningful domain context: EIN has no public checksum, so the tool can only validate format, not authenticity or correctness beyond structure. This is useful behavioral disclosure beyond the annotations.

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

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

Two short sentences, with the core purpose and format front-loaded and the critical limitation stated in the second sentence. There is no redundant or filler content; every word earns its place.

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

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

For a single-parameter, read-only, idempotent format validator with a provided output schema and full schema coverage, the description is fully adequate. It states what is validated, the expected format, and the key limitation, leaving no significant 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 coverage is 100%, so the description is not required to compensate for undocumented parameters. The description's 'NN-NNNNNNN' pattern adds a concrete format illustration, but the schema already states '9 digits; dashes/spaces allowed.' Thus the description adds minimal additional semantic value 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 states a specific verb-resource pair: 'Validate US Employer Identification Number FORMAT', with the expected pattern 'NN-NNNNNNN' explicitly given. It also distinguishes itself from checksum-style validation by noting that no public EIN checksum exists, which differentiates it from sibling checksum tools.

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

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

The description clearly scopes the tool to US EIN format checking and explicitly warns that no checksum validation is possible, effectively telling the agent what this tool cannot do. It does not explicitly name sibling alternatives, but the context and the no-checksum caveat give clear usage direction.

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

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

Annotations already declare readOnlyHint and idempotentHint, and the description adds valuable behavioral context beyond them: it returns both raw and formatted values, resolves decimals on-chain with labeled fallbacks, and preflights so the caller never pays during an RPC outage. This meaningfully helps an agent predict behavior.

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

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

Two dense sentences carry all key information: scope, return nature, decimals handling, and the preflight guarantee. Information is front-loaded and no words are 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 read-only, idempotent tool with a full input schema and an output schema present, the description covers the essential behavioral details: raw/formatted output, decimal resolution fallback, and preflight safety. Nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters including the decimals override behavior. The description's mention of on-chain decimals and fallbacks mostly restates the schema, adding little new parameter-level meaning.

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

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

The description unambiguously identifies an ERC-20 balanceOf read for an address at a token contract, and the ERC-20 scope clearly distinguishes it from sibling balance_check. However, it lacks an explicit imperative verb such as 'Retrieves' or 'Returns', so it just misses the top rating.

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

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

The description gives clear context: use this for raw and formatted ERC-20 balances at arbitrary token contracts, with a practical preflight guarantee. It does not explicitly state when NOT to use it or name alternatives like balance_check, so it stops short of a full 5.

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

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

With annotations already declaring readOnlyHint, idempotentHint, and openWorldHint=false, the description adds specific behavioral context by explaining the exact validation algorithm (structural pattern and mod-36 cross-sum checksum). It does not contradict annotations and provides the key behavioral detail that this is a rule-based syntax 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?

The description is a single, well-structured sentence that leads with the action and resource, then packs the validation criteria into a compact parenthetical. No unnecessary words.

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

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

The tool is simple, with one well-documented parameter, a complete schema description, and an output schema present. The description provides the validation logic, and annotations cover safety and idempotency, so everything an agent needs to invoke and interpret the tool correctly is present.

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?

Although the schema already describes the gstin parameter as a 15-character Indian GSTIN, the description goes beyond by breaking down the internal format and mentioning the checksum. This helps the agent construct or understand valid input values, adding real semantic value.

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

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

The description uses the specific verb 'Validate' and identifies the resource as 'Indian GSTIN', then distinguishes it from sibling validation tools by detailing the exact structure (2-digit state code + PAN + entity code + 'Z') and mod-36 checksum. This makes the tool's purpose unambiguous and clearly differentiates it from other checks in the sibling list.

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

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

The description clearly implies the tool is for validating Indian GSTINs, so an agent knows when to use it. However, it does not explicitly state when not to use it or mention alternatives such as vat_mod97_check or luhn_check, 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 communicate read-only and idempotent behavior, so the description's job is lighter. It adds valuable behavioral context by disclosing that validation is offline, does not perform bank lookup, and is limited to format and checksum rules—important because agents might otherwise expect registry or bank verification.

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

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

The description is a single, front-loaded sentence with no filler. Every element—the validation standard, checksum algorithm, and offline/no-lookup caveat—adds 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?

For a single-parameter validator with an output schema and rich annotations, the description covers all essential behavioral aspects: what it validates, how it validates, and what it does not do (bank lookup). The output schema handles return-value details, so nothing needed for correct invocation 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?

The input schema fully documents the only parameter, 'iban', including that spaces are allowed. The description goes beyond the schema by explaining the exact validation standard (ISO 13616 and MOD-97-10), which helps the agent understand how the input will be interpreted and validated.

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 'Validate' and the resource 'IBAN', and precisely specifies the validation method: 'ISO 13616 structure and MOD-97-10 checksum'. It also distinguishes itself from bank lookup tools by adding 'offline, no bank lookup', making its scope immediately clear among siblings like luhn_check and vat_mod97_check.

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

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

The phrase 'offline, no bank lookup' clearly signals when this tool is appropriate: for structural and checksum validation only, not for bank account verification or lookups. It does not explicitly name alternative tools, but the context is clear enough for an agent to choose it correctly.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds genuinely useful behavioral context beyond annotations: the exact structural rule applied (11 characters, 5th character forced to 0, BBBB0NNNNNN pattern), which tells the agent precisely what criterion 'validates' means here. 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?

A single sentence with zero filler: verb first, resource second, the decisive format rule third. Every element earns its place and the most decision-relevant detail (the 0 requirement) is included without bloating the 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?

For a single-required-parameter validator with an output schema and safety annotations, the description is complete. The agent has everything needed to invoke it correctly: one fully documented parameter, the validation rule, and read-only/idempotent behavior from annotations. Return-value details are the output schema's job, and nothing relevant 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%, giving a baseline of 3. The description adds meaning beyond the schema's '11-character Indian Financial System Code' by specifying the positional structure (BBBB0NNNNNN and the 5th-character-is-0 rule), which is material validation knowledge an agent would not infer from the schema alone.

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

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

The description uses a specific verb ('Validate') plus a clearly bounded resource ('Indian IFSC') and the governing standard ('RBI structure'). The format hint (BBBB0NNNNNN; 5th character always 0) removes any ambiguity. It differentiates cleanly from sibling format validators like iban_check, swift_bic_check, and aba_routing_check, since it is explicitly scoped to India's IFSC.

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 'Indian IFSC' qualifier gives clear selection context: this is the tool for Indian IFSC validation, distinct from the sibling checks for other instruments and jurisdictions. It does not explicitly name alternatives or state when-not-to-use (e.g., 'for SWIFT/BIC use swift_bic_check'), 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 and idempotentHint, covering safety and repeatability. The description adds the behavioral specifics of supporting both ISBN-10 and ISBN-13 checksums and names the exact validation method, going beyond the structured fields. No annotation contradiction exists.

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

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

A single sentence with zero filler; the subject, resource, and algorithmic detail are front-loaded. It earns its place and leaves no redundant words.

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

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

For a simple single-parameter validation tool with an output schema and read-only/idempotent annotations, the description covers the essential behavior. It is slightly short of a 5 only because it does not address the adjacent EAN/Luhn tools or potential overlap between ISBN-13 and EAN-13.

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 isbn parameter has a complete schema description ('ISBN-10 or ISBN-13; dashes/spaces allowed'), so schema coverage is 100%. The tool description does not add new parameter-level detail beyond restating ISBN-10/13; 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?

Description states a concrete verb (Validate), a specific resource (ISBN-10/ISBN-13), and the exact checksum algorithm for each. This distinguishes it from sibling checksum tools like luhn_check, ean13_check, and sedol_check without needing to inspect 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 clear ISBN framing implies when it should be used, and the enumerated mod-11 vs 1,3-weight mod-10 algorithms implicitly signal it is not a generic checksum validator. However, it never explicitly states when to choose this over ean13_check or luhn_check, nor gives exclusions or alternatives.

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

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

Annotations already declare readOnlyHint and idempotentHint, and the description adds meaningful behavioral context by specifying the exact validation logic: structure plus Luhn mod-10 on the A=10...Z=35 converted string. This tells an agent what 'valid' means beyond the annotations.

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

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

The description is one tight sentence that front-loads the action and resource, then packs the necessary algorithmic detail without filler or redundancy. Every phrase earns its place.

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

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

With only one fully documented parameter, an existing output schema, and annotations covering read-only/idempotent behavior, the description is complete enough for an agent to invoke the tool correctly. The algorithm detail closes the main behavioral 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?

The input schema provides complete documentation for the single `isin` parameter, including length, format, and that spaces are allowed. The tool description adds no extra parameter-level meaning, so the baseline score of 3 applies given the 100% schema coverage.

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

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

The description names the exact resource (ISIN) and standard (ISO 6166), states the action ('Validate'), and specifies the validation algorithm. This makes the tool clearly distinct from sibling checks such as luhn_check or generic format validators.

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

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

The description implies when to use the tool: whenever an ISIN needs validation. However, it does not explicitly state when to prefer an alternative or call it out versus siblings, so the usage guidance is adequate but 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?

Annotations already convey readOnly and idempotent behavior. The description adds meaningful algorithmic context by naming ISO 17442 and ISO 7064 MOD-97-10 check digits, which clarifies the nature of the validation beyond just '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?

The description is a single sentence with no filler. The core purpose is front-loaded and the standard references add useful precision without bloat.

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 validation tool with readOnly/idempotent annotations and an output schema, the description is largely complete. A minor omission is whether 'validate' means only local format/check-digit checking or also GLEIF registration status, but this is not critical 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?

The schema already covers the single parameter fully, describing 'lei' as a 20-character Legal Entity Identifier and providing an example. The description adds standard-level context but no new syntactic parameter semantics, 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 clearly states the verb 'Validate' and resource 'Legal Entity Identifier', and further specifies the applicable standards (ISO 17442 + ISO 7064 MOD-97-10). This makes it distinguishable from the many sibling identifier checkers without needing to inspect 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?

Use is implied: call this tool when a Legal Entity Identifier must be validated. However, there is no explicit 'use when' or 'use instead' guidance relative to sibling tools, so the agent must infer routing from the resource name.

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 idempotentHint, so the safety profile is covered. The description adds value by warning against submitting real card numbers and clarifying that the check is algorithmic and covers card-style checksums, giving agents useful behavioral context beyond the structured 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 two sentences with no filler. The primary purpose and algorithm are front-loaded, followed by a concise, important safety caution. Every sentence earns its place.

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

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

For a simple single-parameter validation tool with a full input schema, an output schema, and safety annotations, the description is complete. It covers purpose, input scope, algorithm, and a key policy constraint, leaving no material gap for an agent to call 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?

Input schema coverage is 100%, so the schema already documents the 'number' parameter including format and allowed spaces/dashes. The description repeats '12-19 digit' and adds the algorithm context, but does not provide additional parameter-level detail 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 states a specific verb ('Validate'), a specific resource ('any 12-19 digit number'), and the exact algorithm ('Luhn mod-10'), which makes the tool's purpose immediately clear. It also adds 'card-style checksums' to distinguish this from sibling validation tools that use different standards.

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 usage through 'Luhn mod-10 algorithm (card-style checksums)' and explicitly warns 'Never submit real card numbers,' which is a safety exclusion. However, it does not name any sibling tool or explicitly state when to choose this over alternatives like ean13_check or iban_check.

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 idempotentHint=true, so the safety profile is covered. The description adds useful behavioral context by noting the engine is deterministic and explainable, but it does not describe output details or edge-case behavior. No contradiction with annotations exists.

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

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

The description is a single, economical sentence with no filler. It front-loads the key concepts—explainable output, rental fraud, and deterministic rule engine—and earns every word.

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

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

With an output schema present and all 8 parameters fully described in the input schema, the description does not need to explain return shape or parameter semantics. It sufficiently conveys tool purpose and core behavioral traits, though it could add a sentence on when this risk score is preferable to related rental tools.

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 parameters are already fully documented. The description adds the collective framing of these inputs as red-flag signals, which gives semantic context, but it does not explain individual parameters beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool produces an explainable rental-fraud risk score over listing red-flag signals, which identifies the domain, resource, and output. It is specific enough to distinguish itself from generic validation tools, though it does not explicitly contrast itself with the related rental_verdict sibling.

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

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

The description gives no explicit guidance about when to use this tool versus alternatives such as rental_verdict or rent_deposit_guard. It does not state exclusion criteria, prerequisites, or recommended use cases, leaving the agent to infer applicability.

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 read-only, idempotent, and closed-world behavior, so the description does not need to restate those. It does add the useful behavioral detail that the verdict is 'signed' and combines multiple checks, but it does not explain what signing means, what data sources are used, or failure behavior. This is moderate added context beyond 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 a single compact sentence with no filler. It front-loads the core value proposition ('One combined, signed rental due-diligence verdict') and then concisely enumerates the covered risk areas. Every word earns its place.

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

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

The output schema exists, annotations cover safety, and parameter descriptions are complete, so much of the call contract is already supplied. However, the description does not explain how this tool relates to closely related siblings such as rental_listing_risk and rent_deposit_guard, nor does it clarify when the combined verdict is preferable. It is adequate but leaves the orchestration decision to the agent.

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

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

Schema description coverage is 100%, with all 10 parameters individually documented. The description does not add parameter-level semantics beyond the high-level mapping to deposit, landlord entity, and listing risk, which is acceptable given the schema already carries the full burden. 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 clearly states the tool produces a single combined rental due-diligence verdict covering deposit, landlord entity, and listing risk. This specific composition distinguishes it from sibling tools like iban_check, lei_check, rental_listing_risk, and rent_deposit_guard without needing to open their schemas.

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

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

The phrase 'One combined, signed rental due-diligence verdict' implies the tool should be used when a synthesized verdict across all three risk areas is desired, but it does not explicitly say when to choose this over separate sibling checks or mention alternatives by name. Usage guidance is present only by implication.

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 idempotentHint, covering the safety profile. The description adds the specific checks performed, which is useful beyond annotations, but it does not disclose limitations such as not verifying account existence or the exact semantics of the country-alignment logic.

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

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

A single, front-loaded sentence that concisely enumerates the tool's scope without any fluff. Every word contributes to understanding what the tool does.

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 low complexity (3 parameters, 1 required, output schema present, read-only/idempotent annotations), the description sufficiently covers the tool's scope. It lacks explicit guidance on alternatives, but that is already accounted for in usage_guidelines, and the remaining context is adequate for 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%, so all parameters are already documented. The description's mention of IBAN checksum, country alignment, and pre-viewing flag maps to the parameters but adds no extra format, constraints, or relationships 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 specifies a concrete domain (rental deposits) and enumerates three distinct checks: IBAN checksum, property/deposit country alignment, and pre-viewing flag. This distinguishes it from generic iban_check and other siblings, though it lacks an explicit verb such as 'validates' or 'assesses'.

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 title and description imply use in rental deposit scenarios, providing enough context to infer when to call this tool. However, there is no explicit guidance on when to prefer it over iban_check or rental_verdict, and no exclusions or alternatives are mentioned.

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

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

Annotations already establish that this is read-only and idempotent, and the description adds the deterministic checksum algorithm, reinforcing the openWorldHint=false annotation. It clearly frames this as checksum-only validation without claiming registry or broader security-identifier verification.

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

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

The description is a single compact sentence that front-loads the resource and validation method without filler. Every phrase contributes directly to understanding the tool's purpose.

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

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

For a one-parameter, read-only, idempotent checksum validator with an output schema present, the description plus annotations are sufficient for an agent to select and invoke it correctly. Return behavior is covered by the output schema, and the algorithm description fills the behavioral 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?

The input schema fully describes the single parameter as a "7-character SEDOL code," so the description does not need to add parameter-level semantics. The description's geographic and algorithmic context is useful but does not change how the sedol parameter should be supplied or interpreted.

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 ("Validate"), a specific resource ("UK/Ireland security identifier"), and the exact method ("(1,3,1,7,3,9)-weight mod-10 checksum"). This distinguishes it from sibling tools like luhn_check and isin_check because it targets SEDOL specifically with a unique weighting scheme.

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

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

The description implies the tool is for SEDOL inputs by naming the identifier type and checksum, but it does not explicitly say when to prefer it over alternatives such as isin_check or luhn_check. No when-to-use or when-not-to-use guidance or alternative routing is provided.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds useful behavioral context: the time window is only the last ~48h, the result includes aggregate counts/volumes and sample hashes, and the tool is preflighted so the caller won't be charged during an RPC outage. There is 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?

The description is compact and front-loaded: it opens with the core counterparty-check purpose and follows with scope, output summary, and a cost-safety note. Every sentence earns its place and there is no padding or redundancy.

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

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

With only one parameter, a full output schema, and annotations covering read-only/idempotent behavior, the description covers the network, asset, time window, transfer directions, and output contents. The preflighted payment-safety note is a meaningful addition, and nothing needed to actually invoke this tool correctly is missing.

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

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

The input schema fully documents the single address parameter with 100% coverage, so the baseline applies. The description adds context by clarifying that the address is the participant in sent/received USDC transfers on Base, but it does not add format or constraint details 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 names a specific function: an on-chain counterparty check of USDC transfers SENT and RECEIVED by an address over the last ~48h of Base blocks. It also specifies the output contents (counts, volumes, sample tx hashes), which clearly distinguishes it from siblings like balance_check and tx_activity.

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 intended use is reasonably clear from the 'counterparty proof' title and the transfer-direction framing, but there is no explicit statement about when to choose this tool over alternatives such as tx_activity or balance_check. No when-not-to-use conditions or exclusion criteria are provided, so usage guidance is implied rather than explicit.

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

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

Annotations already cover read-only and idempotent behavior. The description adds useful behavioral context by specifying that validation is structural (bank code, ISO country, location, optional branch), which signals a format check rather than a registry lookup.

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?

One tightly written sentence that front-loads the tool's purpose and includes the essential structural detail. No filler or repetition of schema 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?

The tool is a single-parameter validator with 100% schema coverage, an output schema, and readOnly/idempotent annotations. The description's statement of what is validated is enough to call the tool correctly without further context.

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

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

Input schema already documents length and permitted spaces/dashes, so baseline is 3. The description adds meaning beyond the schema by explaining the structural components of the BIC (bank, country, location, optional branch), which helps an agent formulate valid input.

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

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

States a specific action (validate), a specific resource (SWIFT/BIC code), and a precise method (ISO 9362 structure). The component breakdown distinguishes it from sibling code-format tools like iban_check or aba_routing_check.

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

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

The description clearly signals when to use the tool: whenever a SWIFT/BIC code must be validated against ISO 9362. It does not explicitly name alternatives or exclusions, but the purpose is unambiguous given the sibling list.

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 read-only and idempotent behavior. The description adds valuable context by explaining the exact data sources (nonce, eth_getCode) and the preflight guarantee that prevents paying during RPC outages. 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?

The description is two dense, front-loaded sentences: the first summarizes the result set, the second adds an important operational guarantee. There is no filler or redundant repetition of schema details.

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

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

With one required parameter, full schema coverage, and an output schema available, the description sufficiently explains what the tool does and how it behaves. Nothing essential to selecting or invoking the tool 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%, with the single address parameter already documented as a 0x-prefixed EVM address. The tool description names the address as the subject but adds no extra format or usage semantics beyond what the schema provides.

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

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

The description identifies a specific resource (an EVM address) and exactly what the tool reports: total outbound transaction count, contract status via eth_getCode, and a nonce-based first-funded heuristic. It is clearly distinguishable from sibling balance/validation tools.

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

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

The intended use is implied by the on-chain activity framing and the note about preflighting during RPC outages. However, there is no explicit statement about when to choose this tool over siblings like balance_check, erc20_balance, or block_info.

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

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

Annotations already indicate read-only/idempotent behavior; the description adds the key behavioral trait that this is a structural (algorithm-based) check, not a registry query. It does not discuss output behavior or edge cases, but output schema exists and safety annotations cover side effects.

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

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

Single sentence with precise scoping: 'Structural VAT check (BE mod-97 family)' is front-loaded and contains no filler. Adequately sized for the tool's minimal surface.

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

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

For a one-parameter, read-only validation tool with an output schema and rich annotations, the description covers the essential nature of the check. It could strengthen completeness by explicitly noting that the tool only validates structure/checksum and does not check VAT registration status, but that is largely implied by 'structural.'

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

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

Schema coverage is 100%, and the schema already documents that vat_number is an EU VAT ID with BE mod-97 checksum and optional BE prefix. The description adds no additional parameter semantics beyond restating the structural nature.

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

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

The description identifies a specific resource (VAT) and scope (BE mod-97 family), which distinguishes it from sibling checkers like iban_check or luhn_check. However, 'structural check' is slightly vague and could be interpreted as any VAT validation without explicitly saying it validates Belgian VAT numbers.

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

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

No statement about when to use this tool versus alternatives, and no mention that this is only a format/checksum check rather than a registration/status check. Usage must be inferred from the tool name and title.

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

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

The description adds materially beyond the annotations: it discloses that the call is 'signed', that each identifier is 'checksummed', and that the result is 'one verdict, one receipt'. Even with readOnlyHint and idempotentHint present, this provides useful behavioral context about validation and output without contradicting the annotations.

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

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

The description is a single dense sentence that front-loads the core purpose, enumerates the covered identifiers, summarizes the output, and gives a pricing rationale. Every clause earns its place, and the copy is appropriately concise for an agent-oriented definition.

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

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

With a complete 4-parameter schema, an output schema, and annotations covering idempotency and read-only behavior, the description provides sufficient context for an agent to invoke the tool correctly. It communicates the bundled validation scope, the single-verdict outcome, and the commercial reason to prefer it over individual checks.

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 parameter semantics baseline is already met by the input schema. The description restates the identifier types but adds only marginal validation detail ('each checksummed') and does not explain individual formats or optionality beyond what the schema already documents.

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 ('Screen') and a clear resource ('a vendor's identifiers') and enumerates the four covered identifiers: IBAN, LEI, VAT, and UK company number. It also highlights the bundled nature and the 'verdict'/'receipt' outcome, which distinguishes it from the single-check sibling tools without needing to open their schemas.

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

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

'Screen a vendor's identifiers in ONE signed call' and 'Half the price of four single checks' clearly signal when the pack is appropriate: when the agent needs multiple vendor checks together. It does not explicitly state when to prefer an individual sibling check, so it stops just short of a fully explicit when/alternative guide.

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