sanctions-screening

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

No annotations are provided, so the description carries the full transparency burden. It discloses important behavioral traits: the data is dated 2026-02-13 and each call costs $0.005, which directly affects agent decisions. It does not describe the response shape or error cases, but for a non-mutating lookup this is above-average disclosure.

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

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

The description is four short sentences with no filler. It front-loads the primary action and resource, then adds input format, data date, and cost—each 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 two-parameter lookup tool with no output schema and no annotations, the description covers purpose, input format, data vintage, and pricing. It could be more complete by describing the exact return values, but the core selection and invocation needs are met well.

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

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

The schema only describes api_key in detail, leaving country minimally specified. The tool description compensates by stating that 'country' accepts an ISO 3166-1 alpha-2 code or a country name, adding meaning beyond the raw schema. The api_key requirement and funding path are already thoroughly documented in the schema's parameter description.

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

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

The description uses a specific verb ('Classify') with a clear resource ('a country's AML risk') and explicitly names the reference lists (FATF black/grey and EU high-risk-third-countries). This fully distinguishes it from the sibling screening tools and leaves no ambiguity about what the tool does.

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

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

The description provides clear context for when to use the tool: any need to classify a country's AML risk against specific regulatory lists. It does not explicitly name alternatives or when-not conditions, but none of the sibling tools appear to overlap directly, so a no-exclusions clear-context score is appropriate.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the key starts with a $0 balance, requires funding before use, and that paid tools require a funded key. This is useful behavioral context beyond the schema.

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, with three sentences that are front-loaded with the primary purpose and followed by essential usage details. No wasted words.

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

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

Given the tool's simplicity (one optional parameter, no output schema), the description covers the key aspects: creation, funding, and usage. It could mention what the response contains (e.g., the key value), but the lack of output schema and simple nature make this adequate.

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

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

The schema has one optional parameter 'note' with 0% description coverage. The description does not explain the 'note' parameter, but since it's optional and likely a label, the schema's maxLength provides some guidance. The description adds no extra meaning, 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?

The description clearly states the tool creates a Watchtower API key, which is a specific verb+resource combination. It distinguishes from siblings by focusing on API key creation, though it doesn't explicitly contrast with other tools.

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

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

The description provides clear context on when to use the tool: to create an API key for Watchtower. It also explains the funding requirement and mentions alternatives like paying per call via x402, which helps the agent decide when to use this tool.

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

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

The description discloses key behavioral aspects: it POSTs events to a webhook, charges $0.01/day prepaid from API credit, and has a 90-day maximum. It does not mention failure modes or error handling, but the core side effects are clearly stated, which is good given the absence of 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 well-structured, condensing the core function, event mechanism, pricing, and duration into a few clear sentences with no redundant information.

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

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

Given the schema constraints (e.g., days between 1 and 90, threshold between 0.5 and 1) and the description covering the main operational details, the tool is adequately described for an agent to use it correctly. Some aspects like error handling are omitted, but they are not critical for basic 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 covers 5 parameters but only provides a description for api_key. The tool description adds meaning for name (the monitored entity), webhook_url (receives events), days (duration capped at 90), and api_key (payment method), but threshold is not explained. This partial coverage earns a mid-range score.

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 primary function: 'Monitor a name against all sanctions + US export-control lists.' It distinguishes this from one-time screening tools by emphasizing ongoing monitoring with daily refreshes, making it evident this is for long-term watch activities.

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

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

The description implies when to use this tool (for ongoing monitoring rather than immediate screening) through phrases like 'daily list refresh' and 'watch_changed' events. It also mentions cost and duration limits, but does not explicitly name alternative tools or contrast with one-time screening services, so it falls slightly short of the highest standard.

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

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

The description discloses that the tool is 'Free:' (no cost), and the listed outputs (versions, hashes, etc.) indicate a read-only, non-destructive behavior. With no annotations provided, the description adequately conveys the tool's behavioral profile.

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

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

The description is a single sentence that efficiently covers all key aspects of the tool's functionality without any redundant information.

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

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

Given zero parameters and no output schema, the description fully characterizes what the tool does and returns, leaving no ambiguity about its purpose or output.

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?

There are zero parameters, and the description adds meaning by specifying exactly what the tool returns (versions, hashes, freshness, counts, prices), which goes beyond the empty schema to inform the user of the expected output.

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

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

The description explicitly states the tool provides 'sanctions list versions, source hashes, freshness, entry counts, and the full per-tool price menu,' which is a specific verb+resource combination that clearly distinguishes it from sibling tools like screen_name or kyb_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?

No explicit guidance on when to use or not use this tool is provided. However, its purpose as a free information retrieval tool is implied by the prefix 'Free:' and the listing of data it returns.

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 transparency burden. It discloses the cost ($0.02 per call) and the dual nature of the operation, which is useful behavioral context. However, it does not mention authentication beyond what the schema says, side effects, rate limits, or what happens when both or neither name/LEI are provided.

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

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

Two sentences, front-loaded with purpose and followed by cost. Every word earns its place; no filler or repetition of schema content beyond what adds meaning.

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 and no annotations exist, so the description must carry more weight. It names the two result dimensions (GLEIF identity and sanctions/exclusion screening) but omits output structure, error behavior, and parameter-requirement edge cases. It is adequate for selection but not fully complete for reliable invocation.

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

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

Schema coverage is only 33%, so the description must compensate. It clarifies that a company can be resolved 'by name or LEI', mapping directly to the name and lei parameters. Yet it does not specify whether at least one is required, whether both can be supplied, or any precedence or matching behavior.

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 ('resolve') and identifies the resource/outcome: a company to its GLEIF legal identity plus sanctions and exclusion screening. It clearly distinguishes from sibling tools by combining both capabilities in one call, making 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 'in one call' gives clear context that this tool is meant for consolidated KYB resolution and screening, implying it replaces separate calls to resolve_lei and screen_name. It does not explicitly name alternatives or state when not to use it, but the usage 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?

With no annotations, the description carries the full burden. It only mentions 'free' but lacks details on authorization (api_key is required but not described), rate limits, or behavior when no watches exist.

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?

Extremely short, but at the expense of useful information. The single sentence is too sparse to be effective.

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

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

The tool is simple (one param, no output schema), but the description omits any mention of output format, pagination, or limits. It feels incomplete for practical 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?

Schema coverage is 0%, so the description must compensate. It fails to describe the only parameter 'api_key' – no hint on what it is or how to obtain it.

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

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

The description clearly states the action ('list') and resource ('active watches'), and the 'free' qualifier adds a small distinction. However, it doesn't explain what a 'watch' is beyond the tool name.

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

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

No guidance on when to use this tool versus siblings like 'create_watch' or 'screen_name'. No indications of prerequisites or context.

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

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

No annotations are provided, so the description carries full burden. It discloses that the LEI is checksum-validated first, that the tool costs money, and that an API key with a funded balance is required. This is good disclosure of the financial and validation behavior, though it does not specify what happens if validation fails or in what format the record is returned.

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 that front-load the main purpose and then add critical constraints (cost, authentication). Every word earns its place; no fluff 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?

Given there is no output schema, the description lists the expected output fields which helps agents know what to expect. The tool has a side effect (cost) and authentication requirements, which are explicitly covered. The absence of error handling or failure behavior details is a minor gap, but for a lookup tool with clear inputs and outputs, the description is adequately 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 coverage is 50%, meaning the API key parameter is not described in the schema properties but is documented in the description. The description explains the LEI role, adds checksum validation, and details the api_key requirement including how to fund it and alternatives via x402. This goes beyond what the schema provides for the api_key, though it leaves the LEI parameter without format details beyond the schema (maxLength/minLength).

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 resolves an LEI to its official GLEIF record with specific fields (legal name, status, jurisdiction, country, registration status). This distinguishes it from siblings like search_lei_by_name (which likely searches by name) and validate_identifier (which likely only validates format), while the note on checksum validation adds specificity.

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 use when you have an LEI and need its official record, but it does not explicitly state when to prefer this over validate_identifier or search_lei_by_name. It mentions the cost and authentication prerequisites, which are important context but not alternative tool guidance. The paid nature suggests a cost-benefit consideration that is not fully 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 provided (neither readOnlyHint nor destructiveHint), the description carries the full burden of behavioral disclosure — and it delivers well. It reveals determinism ('Deterministic'), return structure ('returns findings (masked), counts, and a redacted copy'), and critical cost implications ('Costs $0.005 per call'). This is strong disclosure for a state-free analysis tool, though it leaves some behaviors (latency, error handling on failed payment) undisclosed, preventing 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 tightly-packed sentences deliver maximum value. The first verb-to-the-point sentence states the purpose and exhaustive detector list; the second covers behavior, returns, and cost. The lengthy parenthetical list of secret types earns its place — it's the primary value proposition allowing the agent to verify coverage for its specific secret type. The 'Use before...' and cost details are efficiently integrated without fluff.

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

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

Despite having no output schema and no annotations to rely on, the description covers the essential dimensions: what it detects, how it behaves, what it returns, when to use it, and what it costs. The schema's api_key parameter description nicely complements by covering authentication and funding flows. Minor gaps remain (error handling, rate limits, idempotency semantics), but for a text-scanning tool this is well-covered. The priced nature of the tool is appropriately surfaced since it's the highest-stakes contextual fact.

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

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

With schema description coverage at 50% (api_key is documented, text is not), the parameter burden is partially on the description. The description implicitly defines the text parameter by explaining what gets detected/redacted and the output shape, but never explicitly documents the 'text' parameter's constraints (though maxLength 100000 is in the schema). The api_key parameter itself is well-documented in the schema with funding details. The description adds moderate value by connecting tool behavior to parameter purpose, but doesn't fully compensate for the undocumented text parameter — a solid 3 meeting baseline expectations.

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+resource+scope: 'Detect & redact PII and secrets in text' followed by a comprehensive, concrete enumeration of detector types (private_key, jwt, aws_access_key, email, ssn, iban, etc.). This scope is clearly distinct from sibling tools that handle names (screen_name), crypto addresses (screen_crypto_address), and entity resolution (resolve_lei), making differentiation immediate.

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 contextual usage guidance: 'Use before logging/forwarding untrusted or agent-generated text.' This tells the agent when the tool is appropriate. However, it stops short of explicitly naming alternatives or providing when-not-to-use exclusions — it doesn't compare against siblings or describe conditions under which this tool would be the wrong choice, which is why it doesn't reach a 5.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does mention the $0.01 per-call cost and exact-match semantics, which are useful. However, it omits authentication requirements, return format, and failure/error behavior; the api_key requirement is only present in the parameter description.

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 only two sentences. The main action is front-loaded, and the additional details (exact match, cost) are presented without any redundant language.

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

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

This is a simple check tool, but without an output schema or annotations, the description should clarify the result format and any required auth. The description covers the core screening action and cost, but relies on the parameter schema for the API key requirement and says nothing about the response.

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 address parameter has no schema description, and the tool description compensates by indicating it accepts BTC/ETH/others and uses exact matching. The api_key parameter is already well-documented in the schema, so the description adds little there. Overall partial compensation for the 50% schema description 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 uses a specific verb ('Check'), names the resource ('crypto address'), and explicitly ties it to the OFAC sanctioned digital-currency address list. It also adds 'Exact match' to indicate matching semantics, differentiating it from sibling screening tools like screen_name or check_jurisdiction.

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 statement about when to use this tool versus alternatives like screen_name or check_jurisdiction. The intended use case is implied by the description and tool name, but 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?

The description discloses key behavioral aspects: deterministic matching, typo tolerance, fuzzy matching logic, and the specific sanction lists involved. It also transparently states the per-call cost, which is a behavioral factor. It does not mention edge cases (e.g., no match, multiple matches) or error handling, but the provided details are substantial.

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 efficiently structured: it opens with the primary action, then enumerates the target lists, followed by the matching behavior and cost. It fits in two sentences with no redundancy or unnecessary detail, making it easy to parse quickly.

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 gives the core purpose and behavioral traits, but it omits practical details such as how to handle results (no output schema), potential limitations (e.g., regex vs. fuzzy matching nuances), or interaction with other parameters like threshold. It also fails to mention whether the tool supports batch processing or if there are rate limits. Some context is present, but gaps remain for a fully self-sufficient description.

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

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

The description provides no explanation of any parameter (e.g., name, dob, threshold, types). While the input schema includes descriptions for four of six parameters, the description itself adds zero value to parameter understanding. The threshold parameter, in particular, is left unexplained, and the description does not clarify how parameters interact (e.g., dob affecting matching). Coverage is below 80%, so no 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 tool's function: screening names against a comprehensive list of sanctions and exclusion lists (OFAC, UN, UK, etc.). It also specifies the matching approach (deterministic, typo-tolerant fuzzy) and the cost, leaving no ambiguity about what the tool does.

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 lacks guidance on when to use this tool versus alternatives (e.g., screen_names_batch, scan_text). It does not mention prerequisites like having an API key, nor does it clarify typical use cases beyond the basic screening action. The cost note implies an API key but doesn't explicitly state requirements or recommended usage scenarios.

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 bears the full burden. It adds useful behavioral context: cost per name, billing from API key credit, and the exact sanction lists checked. However, it does not disclose potential behaviors like response format, error cases (e.g., invalid names, unfunded account), or whether the operation is read-only, which limits transparency.

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

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

The description is two sentences, front-loaded with the primary purpose and capacity ('Screen up to 500 names'), then adds pricing and billing details. Every clause contributes value with no redundancy or excessive length.

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

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

The description covers the core scope (lists, batch size, cost) but lacks critical context for a paid API tool with no output schema: it does not hint at the response structure, match details, or error handling. It also omits threshold semantics. For a batch screening tool, these are notable gaps.

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

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

Schema description coverage is low (33%, only api_key described). The description adds meaning for the names parameter by stating the 500-name limit and per-name pricing, and the api_key parameter is described in the schema. However, the threshold parameter (range 0.5-1) is not explained at all, leaving a gap that the description does not compensate for.

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 'Screen' with a clear resource ('up to 500 names') and explicitly lists the sanction lists (OFAC SDN, OFAC Consolidated, UN, EU, UK OFSI). This clearly distinguishes it from sibling tools like screen_name (single name) and screen_crypto_address (crypto addresses).

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 batch use for multiple names and highlights a cost advantage over single-call pricing ('25% below single-call price'), indicating when to prefer this tool. However, it does not explicitly name alternatives or state when not to use it (e.g., for a single name, use screen_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?

The description discloses the cost ($0.01 per call) and indicates that the tool returns candidate records, implying a list. However, it does not mention authentication requirements (e.g., api_key) or any potential side effects, which are covered only in the schema.

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 conveys all key information without redundancy. It directly states the purpose, the return fields, and the cost.

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

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

Given that no annotations are provided, the description carries the burden of context. It mentions cost and output fields, but omits authentication details and error behavior. The schema covers some of these, but the description alone is not fully self-sufficient.

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

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

The description adds minimal value beyond the schema: it clarifies that 'name' refers to the company legal name, but it does not explain 'limit' or 'api_key'. The schema already provides constraints for name and limit, but the api_key’s description is not echoed here.

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: finding Legal Entity Identifiers by company legal name via GLEIF. It also specifies the output as candidate records, making the purpose unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives like resolve_lei or check_jurisdiction. The mention of 'via GLEIF' gives some context but does not differentiate it from sibling 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?

No annotations are provided, so the description carries the full burden. It discloses determinism, checksum/format validation, normalization, auto-detection, cost per call, and paid nature via api_key. It does not describe failure behavior or output format, but covers key operational aspects beyond the schema.

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, information-dense sentence that covers purpose, supported types, auto-detection, and cost. It is concise and front-loaded, but the list of types could be seen as verbose; however, it serves a functional purpose. No wasted words.

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

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

Given the tool's complexity (15 identifier types, auto-detection, paid API), the description covers key points but lacks details on normalization output format, error handling, and prerequisites beyond api_key. The output schema is absent, so the lack of return structure explanation is a gap for full completeness.

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

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

Schema description coverage is low (33%: only api_key has a description; type has enum but no description, value lacks description). The tool's description explains auto-detection for type adds value, but it doesn't explain the expected format of 'value' beyond maxLength, nor the meaning of 'normalize'. It falls short on compensating for the low coverage.

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

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

The description clearly states the tool validates and normalizes identifiers by checksum/format, listing supported types. It distinguishes from siblings like resolve_lei and screen_crypto_address, which focus on specific types; however, it doesn't explicitly contrast with them or mention normalization 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?

The description explains auto-detection when type is omitted and mentions cost per call, which implies use for validation tasks. It doesn't explicitly state when to use this tool versus alternatives like resolve_lei for LEI-specific needs, but the list of types and auto-detection provide reasonable context.

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