banking-intelligence

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

Even without annotations, the description fully discloses the output structure, logic for holiday counting, and authoritative nature of elapsed_business_days_by_send_date, leaving no behavioral ambiguity.

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?

Well-structured with clear sections and front-loaded purpose, but somewhat verbose; could be slightly more concise.

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

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

Given the tool's complexity and presence of an output schema, the description thoroughly covers all needed context for effective use and interpretation.

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?

Compensates for 0% schema coverage by detailing country_code format and year range, with examples that clarify usage.

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

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

Clearly states it fetches bank/public holidays with payment impact analysis, distinguishing from simpler siblings like is_business_day_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?

Provides explicit usage context for diagnosing payment delays, including what not to do (e.g., don't invent recent holidays). Lacks explicit comparison to sibling tools but still offers clear 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?

Since no annotations are provided, the description carries full responsibility. It discloses critical behavioral traits: the tool returns only swift and name per bank (not account numbers), country and currency are required and bound the result set, API key requirements, subscription tiers, strict daily caps (5/day PRO, 10/day VIP/FI/trial), and pagination limits (page 1–4). This level of detail ensures the agent understands constraints and 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?

The description is well-structured: a clear one-sentence summary, followed by a detailed explanation of behavior and constraints, then a bullet-like list of parameters with types and defaults, and finally concrete examples. Every sentence adds value; there is no redundancy or fluff. The front-loading of the core purpose and inverse relationship is 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?

Given the tool's complexity (6 parameters, cross-domain functionality) and the presence of an output schema, the description is complete. It explains the return format (swift and name only), required parameters, optional parameters, usage caveats (no account numbers), authentication requirements, rate limits, and examples. No significant gaps remain for an agent to invoke the tool correctly.

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

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

With 0% schema description coverage, the description compensates fully. It explains each parameter: correspondent_swift with example 'IRVTUS3N', currency as ISO 4217, country as ISO 3166-1 alpha-2, name_prefix as optional prefix, page range 1–4, and api_key with alternative header options. It also emphasizes that country and currency are mandatory and bound the result set. Examples show parameter combinations, adding meaning beyond the raw 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 explicitly states 'Reverse SSI lookup — find banks that use a given correspondent for a currency.' It clearly identifies the verb 'find', resource 'banks', and context 'using a correspondent'. It also distinguishes itself from the sibling 'ssi_lookup' by calling it the inverse, providing clear purpose differentiation.

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

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

The description provides explicit guidance on when to use this tool (reverse SSI lookup) and when not (for retrieving account numbers, it directs users to 'ssi_lookup'). It also details requirements: country and currency are required, an API key with specific subscriptions (PRO, VIP, FI) is needed, and daily caps are mentioned. Examples illustrate correct usage, making it highly instructive.

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

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

With no annotations provided, the description carries full behavioral disclosure. It labels the tool as 'EXPERIMENTAL,' notes 'No API key required,' and explains the behavior of searches with unregistered jurisdictions (empty 'completed' results) and the `XX` (GLEIF LEI) global fallback. This is thorough and goes beyond the typical surface-level 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 front-loaded with a one-line purpose and 'EXPERIMENTAL' warning, then provides necessary context about jurisdiction codes and fallback behavior, ending with an example. Every sentence serves a distinct purpose, and the structure is clean and easy to scan.

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 has zero parameters and an output schema exists, the description doesn't need to detail return fields. It covers purpose, usage context, behavioral caveats, and authentication requirements, making it complete for an agent to understand when and how to use the tool.

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

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

The tool takes zero parameters, and the input schema is empty. The example `company_registries()` makes the lack of arguments unambiguous, and the description's mention that it lists registries with no input requirements adds crystal-clear semantics.

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

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

The description clearly states 'List available company registries and supported jurisdictions' with a specific verb and resource. It further distinguishes itself from sibling tools by explaining that it provides the authoritative list of jurisdiction codes for company_search_person and company_search_company, and that it outranks those tools' descriptions.

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

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

The description explicitly tells when to use this tool: to obtain the LIVE list of registry codes before using company search tools. It also explains that the returned codes take precedence over those in sibling tool descriptions and warns that unsupported country codes will return empty 'completed' results, preventing misinterpretation.

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 thoroughly discloses behavior: it is marked EXPERIMENTAL, auto-screens against sanctions, and explains the silent-drop behavior with total_results 0 and status 'completed' when a jurisdiction is not on the list. It also clarifies the meaning of an empty result and tells the user to check `jurisdictions_not_searched` and `coverage_warning`, adding significant behavioral insight.

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 long but well-structured with clear sections (overview, jurisdiction constraints, warning, args, examples). The opening sentence and the following sentence are somewhat repetitive ('Search company registries' vs 'Find company registrations'), but the extra detail about beneficial owners and sanctions screening justifies the length. It is mostly front-loaded and each paragraph serves a distinct 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 complex 7-parameter tool without annotations, the description covers: jurisdiction list and limitations, exception for XX (GLEIF LEI), silent failure semantics, sanctions screening, all parameter semantics, API key alternatives, and examples. Return values are covered by the output schema, so the description is complete for selection and invocation.

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

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

The schema provides zero descriptions for all 7 parameters, but the description's Args section explains every parameter, including types, defaults, and constraints. For example, it clarifies that jurisdictions must be specified individually, "ALL" is not supported, and provides meaning for include_officers, include_shareholders, etc., fully compensating for the schema's lack of detail.

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

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

The description opens with 'Search company registries for a company with its officers and shareholders' — a specific verb plus clear resource. It further clarifies 'Find company registrations across worldwide registries, including directors, officers, and beneficial owners (PSC/shareholders)', which clearly distinguishes it from siblings like company_search_person and company_registries.

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

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

Provides explicit usage conditions: 'You MUST specify at least one jurisdiction. "ALL" is not supported', directs to 'Call company_registries() for the live list — this one can go stale', and offers specific guidance for the XX registry ('Reach for it whenever the company sits outside the national registries above'). It also warns about silent jurisdiction drops, which is critical usage 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?

With no annotations provided, the description carries the full burden and excels. It reveals that unsupported jurisdictions are silently dropped, resulting in a false-empty result with status 'completed' and no error. It also warns about the stale jurisdiction list and directs users to check `jurisdictions_not_searched` and `coverage_warning` in the response—critical behavioral insights beyond what any schema would encode.

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

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

The description is well-structured and front-loaded: a one-line purpose, followed by necessary usage caveats, then Arg descriptions and examples. Every sentence serves a purpose—no fluff. The length is justified by the five parameters and the critical silent-drop behavior.

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

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

The description is remarkably complete for a tool with no annotations. It covers purpose, parameter semantics, edge cases (silent drops, stale jurisdiction list), response fields to verify (`jurisdictions_not_searched`, `coverage_warning`), and includes two examples. The existing output schema complements this well, so the description doesn't need to re-explain return values.

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 has zero descriptions for parameters, so the description's Args section fully compensates. It explains each parameter: name, jurisdictions (required, with example format), include_sanctions_check (default true), include_inactive_roles (default true), and api_key (alternatives via headers). Concrete examples further clarify usage.

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 clear, specific verb-resource statement: 'Search company registries for a person's directorships, officer roles, and shareholdings.' This distinguishes it from its sibling company_search_company, which presumably searches for companies. It also mentions automatic sanctions screening, further refining the tool's purpose.

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

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

The description provides strong usage guidance: jurisdictions are mandatory, 'ALL' is not supported, the list can go stale (call company_registries() for the live list), and XX is a global registry. It gives explicit prerequisites and pitfalls, but it does not explicitly contrast this tool with alternatives like company_search_company. The when-to-use is implied by the person focus.

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 provided, so description carries full burden. It discloses experimental status, that results are cached, and authentication methods, but lacks details on error handling or rate limits.

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?

Concise and well-structured with purpose, usage, args, and example. 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?

Covers tool's purpose, parameters, authentication, and relation to siblings. With an output schema present, return values need not be explained. Lacks mention of potential errors.

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?

Despite 0% schema coverage, the description explains search_id as from a previous response and api_key with format hints, adding meaning 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 states the tool retrieves cached company search results by search ID, differentiating it from sibling search tools like company_search_person and company_search_company that produce the search_id.

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

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

It explains to use this tool when you have a search_id from a previous search, and implicitly not to use it without one, mentioning the sibling tools that generate search_ids.

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 full burden and does an excellent job. It explains that 'not_listed' is a positive FATF determination, that the coarse 'fatf' field is a weaker signal, and that 'currency' is national currency – not to be paired with payment currency. These are meaningful nuances that prevent misuse.

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 long but every section earns its place: purpose, return details, critical caveats, usage guidance, args, examples. The structure is logical and front-loaded with the core purpose. No redundant or promotional 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?

Given the complexity (multiple data blocks, FATF nuance, currency caveat) and the presence of an output schema, the description covers all necessary context. It points to sibling tools for code lookup, addresses common misconceptions, and supplies examples for different countries. Nothing essential is missing.

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

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

Schema description coverage is 0%, so the description must compensate. It does: 'country_code: ISO 3166-1 alpha-2 code (e.g., "DE", "US", "KZ")' plus three concrete examples. This fully defines the parameter beyond the bare schema.

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

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

The description opens with 'Get banking rules and requirements for a country' – a specific verb+resource+scope. It enumerates the exact data returned (IBAN, SEPA, FATF, currency, account formats, payment requirements), and differentiates from sibling country_payment_codes by directing users there for specific code values.

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

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

Explicitly states when to use: 'Use this to check country-specific STP rules that could cause payment delays, repairs, or rejections.' It names an alternative tool for payment codes and gives a strong directive to prefer this over training data for FATF questions. Multiple clear usage contexts are 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?

With no annotations, the description fully discloses behavioral traits: returns restriction details across jurisdictions, highlights the jurisdiction nexus nuance and payment_jurisdiction_note. No contradictions.

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?

Well-structured with purpose, important note, Args, Examples, Use case. Every sentence adds value. No 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 the complexity of export controls and presence of output schema, the description covers all aspects: parameters, usage caveats, examples, and context. No gaps.

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

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

Schema description coverage is 0%, but description compensates by explaining country_code as ISO 3166-1 alpha-2 and jurisdiction as optional filter with default behavior. Examples clarify usage. Could mention jurisdiction allowed values explicitly.

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

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

Description clearly states it looks up export control restrictions for a specific country, listing specific outputs (embargo status, sanctioned programs, etc.). Distinguished from sibling tools like sanctions_screen or export_controls_screen by focusing on country-level controls.

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

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

Provides explicit guidance on when to use the jurisdiction filter and a critical note about binding jurisdiction. Includes examples and a use case. Could explicitly mention alternative tools for individual/entity screening but overall clear.

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 provided, but description adds context about potential large response when no search filter, and explains the relationship with country_banking_rules. Could be improved by mentioning data freshness or rate limits.

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?

Concise and well-structured with an overview, Args section, and examples. No superfluous 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?

Given no annotations and presence of output schema, the description covers purpose, usage, parameters, and a caveat. It references a relevant sibling tool (country_banking_rules). Minor missing aspects like error handling or exhaustive list of code types.

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

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

With 0% schema description coverage, the description fully compensates by explaining each parameter: ISO alpha-2 format, code_type from payment_requirements, optional search filter. Examples illustrate usage.

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 'look up' and resource 'country-specific payment codes (KNP, purpose codes, etc.)'. It distinguishes from siblings by referencing country_banking_rules as a prerequisite.

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

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

Explicitly instructs to 'Use country_banking_rules first to see which code types a country requires... then use this tool'. Provides clear examples and explains optional search parameter.

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?

Discloses that it returns classification details, controlled jurisdictions, and license requirements, and that it is a reference tool (no side effects). However, with no annotations, it lacks information on error behavior, rate limits, or authentication needs. The description is adequate but not thorough.

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?

Concise and well-structured: first line states purpose, second clarifies nature, then context, Args, and Examples. Every sentence is informative with no fluff. Length is appropriate for the simplicity of the tool.

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

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

Covers purpose, usage context (export control regimes), parameter examples, and return content. Lacks error handling details, but the presence of an output schema mitigates this. Overall sufficiently complete for a simple lookup tool.

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

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

The input schema has 0% description coverage, but the description provides examples and explains the parameter meaning ('The ECCN to look up'). This adds significant value beyond the schema, compensating for the lack of schema descriptions.

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

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

States clearly that the tool looks up an ECCN and returns classification details, jurisdictions, and license requirements. Distinguishes itself from siblings like 'export_controls_screen' by focusing on a specific code.

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?

Labels itself as a 'pure reference tool' implying read-only usage, but does not explicitly compare to alternatives (e.g., when to use eccn_lookup vs export_controls_screen). Examples subtly guide usage but lack explicit when-not-to-use guidance.

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

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

With no annotations, the description fully carries the behavioral disclosure burden and does so richly. It explains the lexical classifier fallback, warns that vague descriptions return a likely-wrong HS code, instructs agents to never quote inferred codes as user-provided, and clarifies that destination findings are unaffected by classification doubt. These are meaningful behavioral traits beyond what any schema or annotation would show.

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 long but well-structured with clear paragraphs, IMPORTANT callouts, an Args section, and examples. It front-loads the core purpose before adding caveats. Some redundancy exists (e.g., the final use case restates the opening purpose), but the length is justified by the high-stakes, complex domain and the need to warn about classifier pitfalls.

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, the description covers all essential aspects: input requirements, jurisdiction logic, classification uncertainty, return values (license, risk, policies, reasons, flags), and usage examples. An output schema is present, so the description does not need to enumerate every return field; it provides enough context for an agent to invoke the tool correctly and interpret results correctly.

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

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

Schema description coverage is 0%, so the description must compensate, and it does. It explicitly lists each parameter, gives formats (ISO 3166-1 alpha-2, ECCN example, HS code digit range), acceptable jurisdiction values, and the 'at least one of' constraint. It also includes multiple usage examples that map parameters to real inputs, making parameter semantics far clearer than the raw schema.

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

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

The description opens with a specific verb+resource combination: 'Screen goods for export-control restrictions to a destination country.' It clearly explains the tool's combined function (goods classification + destination restriction status) and differentiates it from siblings by mentioning the multi-jurisdiction and license-determination aspects, which are not covered by other tools like goods_classify alone.

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 concrete use case ('Can we ship integrated circuits to Russia?') and provides guidance on when to use jurisdiction='ALL' versus a specific jurisdiction. It also warns against using goods_description when ECCN/HS code is available. However, it does not explicitly name alternative sibling tools or say 'use X instead when...', so it stops short of full when-not/alternatives guidance.

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

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

With no annotations provided, the description carries the full burden. It clearly indicates the tool is read-only ('Returns Federal Register publications'), and describes the scope (date range, filters). It could explicitly state it does not modify data, but the context is sufficient.

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

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

The description is well-structured: a concise one-line purpose, a brief summary of return contents, then a clear 'Args' list. While the Args section is detailed, it is necessary given the parameter count. The examples and use case add value without redundancy.

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

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

Given the tool has an output schema (so return format is covered elsewhere), the description covers all input parameters with examples and a use case. It provides sufficient context for an agent to select this tool over siblings and invoke 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?

Despite 0% schema description coverage, the description thoroughly explains all five parameters—their purpose, accepted values (e.g., 'BIS', 'OFAC', 'entity_list'), defaults, and constraints (days 1–365). This fully compensates for the missing schema descriptions.

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

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

The description clearly states the tool retrieves 'recent US regulatory changes from BIS and OFAC' and lists specific categories like entity list updates, rule changes, etc. This specific verb+resource combination distinguishes it from sibling tools like 'country_export_controls' and 'sanctions_screen'.

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 multiple examples and a concrete use case ('Any new entity list additions affecting China?'), explicitly showing when and how to use the tool. The parameter descriptions and default values further guide appropriate usage.

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

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

With no annotations provided, the description carries the full burden and succeeds: it reveals dual data sources (ECB and market), the meaning of the 'source' and 'source_note' fields, cross-rate computation via EUR, possible missing currencies, and exact error behavior. This goes well beyond basic 'get rate' and covers important caveats the agent must know.

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?

Although long, the description is tightly structured with clear paragraphs: first the rate definition and source caveats, then cross-rate explanation, then requirements, then arguments and examples. Each sentence adds non-redundant information; the length is justified by the tool's behavioral nuances. Front-loaded with the main verb phrase.

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

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

The description is complete for a 2-parameter tool with an output schema. It covers provenance, edge cases (missing currencies), calculation methodology, error semantics, and argument requirements. Given the output schema exists, the description need not list return fields, but it already explains the key 'source' and 'source_note' fields. No significant gaps remain.

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 only defines 'base' and 'target' as strings with no enum or description. The description compensates fully: explains they are ISO 4217 currencies, both are always required, gives multiple usage examples, and clarifies that omitting or mis-naming a currency returns an error. It also resolves ambiguity around ordering (e.g., USD/VND vs EUR/USD).

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

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

The description opens with a specific verb+resource: 'Get the latest available reference (mid-market) exchange rate for a pair.' It distinguishes from siblings like fx_rate_history (history vs current), and adds useful qualifiers (reference, mid-market, latest). The examples make clear the tool returns a single rate for an exact pair.

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 extensive when-to-use details: check the 'source' field, never call market rates 'ECB rate', both currencies are required, no implicit default pair, and what to do when a currency is missing. However, it does not explicitly reference alternative sibling tools (e.g., fx_rate_history, fx_timing_advisor) or state when NOT to use this tool in favor of another, so it misses the 'alternatives' criterion for 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 full burden. It discloses that ECB publishes rates on weekdays only and that errors occur for incorrect currency names. It does not contradict any annotations (none provided). However, it lacks details on rate limits or exact response format, which is partially covered by the output 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 and well-structured: a brief introduction, key caveats, parameter list, and examples. Every sentence adds value without redundancy. Front-loaded with the main 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?

An output schema exists, so return values are not needed. The description covers the tool's purpose, usage constraints, parameter details, and error behavior. Given the complexity, it is fully complete.

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

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

Schema coverage is 0%, so the description must fully define parameters. It lists base, target, and days, including types, ISO 4217 examples, default value, and range (1-365). Examples further clarify usage. This adds significant meaning beyond the bare schema.

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

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

The description clearly states 'Get historical ECB exchange rates for a currency pair,' using a specific verb and resource. It distinguishes from siblings like 'fx_rate' by specifying 'historical' and emphasizes that both currencies are required with no implicit defaults, which differentiates it from other FX 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 explicitly says both currencies are required, warns against implicit defaults, and notes that omitted or mis-named currencies result in errors. This provides clear context for when to use, though it does not explicitly name alternative tools like fx_rate for current rates.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It transparently explains that the FX market session is a trading window, not a guaranteed processing schedule, and warns against common misinterpretations. It also notes that restricted currencies carry an inbound_processing_note.

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

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

The description is well-structured with markdown headers and examples, and each sentence adds value. However, it is somewhat verbose (multiple paragraphs). For the tool's complexity, the length is justified, but it could be slightly more concise.

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

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

Given the presence of an output schema (context signals indicate 'Has output schema: true'), the description covers the tool's purpose, usage, parameters, examples, and nuanced interpretation. It addresses common pitfalls and provides references to other tools, making it complete for an AI 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?

Although schema description coverage is 0%, the description compensates by explaining the 'currency' parameter: pass a currency code for a specific window, or omit for all sessions and overlaps. Examples are provided, adding significant meaning beyond the schema's type definition.

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

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

The description clearly states the tool's purpose: 'Get FX trading windows for FX execution timing and spread / rate optimization.' It specifies the resource (FX trading windows) and the action (Get), and distinguishes it from sibling tools like fx_rate and fx_rate_history by focusing on timing and liquidity windows.

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 detailed usage guidance, including when to use the tool for rate optimization and when to use with care for delay diagnosis. It explicitly states what NOT to do ('do NOT tell the user a payment is held until the next session') and directs users to the country_banking_rules tool for delivery-side cutoffs, offering clear 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?

With no annotations, the description carries the full disclosure burden and does so thoroughly: it specifies the methodology (30/90-day annualized, standard deviation of log returns, sqrt(252)), explains qualitative buckets, and discloses critical caveats such as realized vs implied volatility, sample depth limitations, and the meaning of the future-spot band. It also explicitly warns that the band is not a transactable rate and not a hedge cost.

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 long but appropriately so for a complex tool; it is front-loaded with the core purpose, followed by structured guidance and a clear Args section. Each sentence adds actionable value, and the examples make scanning easy without redundancy.

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

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

Given the sparse schema but complex behavior, the description fully covers the tool's inputs, outputs, assumptions, limitations, and typical use cases. It references output fields like sample_depth and horizon.hedge_cost_note, which is sufficient even though an output schema exists.

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

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

Schema description coverage is 0%, so the description must fully compensate for the parameters. It defines base and target as ISO 4217 currency codes and explains horizon_days in detail: optional, calendar days, range 1-1825, omit for spot-only, and practical examples that show usage patterns.

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

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

The description opens with a specific verb and resource: 'Get realized FX volatility for a currency pair, and size the FX risk on an exposure held to a future date.' It clearly distinguishes itself from sibling tools like fx_rate and fx_rate_history by emphasizing realized volatility, risk sizing, and horizon scaling.

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

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

It gives explicit when-to-use guidance: pass horizon_days whenever exposure runs past settlement, omit for spot/settlement risk only, and provides concrete question examples. It also explains what not to do — never state a forward rate or invent hedging costs — which clearly separates it from 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?

With no annotations provided, the description carries the full burden and does so excellently. It discloses the lexical matcher's behavior, explains that confidence reflects string match strength rather than classification correctness, and warns users to read classification_basis and classification_confidence_note when no HS code is supplied.

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 thorough yet well-structured. It front-loads the core purpose, then covers key behavior, parameters, and examples. Every sentence adds critical value, including the practical warning about lexical matching and the concrete use case at the end.

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

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

The description is complete for a tool of this complexity. It covers purpose, usage, limitations, parameters, examples, and expected return elements (HS code, ECCNs, control reasons, confidence, alternatives). Since an output schema exists, the description appropriately focuses on behavior and context rather than exhaustively listing return fields.

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

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

The schema provides no parameter descriptions (0% coverage), but the description fully compensates: it explains description is required with min length, hs_code is optional for direct lookup, and language is an auto-detected hint. Examples also demonstrate parameter combinations, including empty description with hs_code.

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

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

The description opens with a specific verb and resource: 'Classify goods for export control from a description (or HS code).' It clearly differentiates from sibling tools by stating it is destination-agnostic and directs users to export_controls_screen for destination-specific decisions.

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

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

Explicitly states when to use the tool (to identify what goods are and whether controlled in principle) and provides an alternative: 'To get the license decision FOR A SPECIFIC destination, pass the result into export_controls_screen.' It also clarifies the tool's limitations with the lexical matching caveat.

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

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

No annotations exist, so the description carries full burden. It details what the tool returns (investigation playbooks, reason codes, etc.) and explains behavior for both called-with-code and called-without-code. It is thorough but could mention any external dependencies or rate limits.

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

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

The description is well-organized with a summary, bold usage note, bullet points, and examples. While slightly lengthy, every sentence adds value. It could be trimmed slightly, but overall structure is excellent.

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 presence of an output schema (not shown) and the detailed explanation of return content, the description covers all necessary information for correct tool invocation. No apparent 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 coverage is 0%, but the description adds rich meaning: it explains the 'code' parameter is a GPI status code, provides recommended values for common scenarios, and clarifies behavior when absent. This fully compensates for the lack of schema descriptions.

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

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

The description clearly states the tool's purpose: 'Explain SWIFT GPI tracking status codes and provide stuck-payment investigation guidance.' It uses a specific verb-resource pair and distinguishes itself from sibling tools by positioning it as the primary diagnostic entrypoint for payment issues.

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

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

Explicit instructions are provided: 'USE THIS TOOL FIRST whenever the user reports a payment that is stuck...' It also gives scenario-based recommendations with specific code calls, making it clear when and how to use the 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?

No annotations are provided, so the description carries full burden. It clearly indicates the tool is a read-only lookup with no side effects, describes accepted input formats (dots/spaces allowed), and discloses that empty results lack certainty, directing users to formal classification.

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

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

The description is well-structured with clear sections (overview, details, Args, Examples, Use case) and front-loads the key purpose. It is slightly longer than necessary, but every sentence adds value. Minor redundancy could be trimmed (e.g., Example repetition).

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 (export control mapping with caveats), the description covers input requirements, output content (ECCNs, confidence, regime), limitations, and alternative tools. It even references output schema fields implicitly. No gaps remain for the agent to interpret.

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 0% description coverage (no parameter descriptions in schema), but the description includes an 'Args:' section that explains both parameters: hs_code (4-6 digits, dots/spaces ok) and jurisdiction (optional filter with examples). This fully compensates for the missing schema descriptions.

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

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

The description clearly states the tool performs a reverse-lookup from HS codes to export-control classifications (ECCNs). It uses specific verbs ('reverse-lookup'), specifies the resource (HS code to ECCNs), and distinguishes itself from sibling tools like goods_classify and eccn_lookup by focusing on the mapping direction and use case.

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

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

The description explicitly targets customs brokers and shippers, advises on optimal input (6-digit vs 4-digit), and cautions that an empty mapping does not guarantee uncontrolled goods, recommending goods_classify for confirmation. However, it does not explicitly name all alternative tools or describe when not 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?

With no annotations, the description carries full burden and does so thoroughly. It details what `valid: true` means (not that account exists or belongs to named beneficiary), warns about currency being country-level, and explains the bank cross-check resolution. It even references response fields like `verification_note` and `currency_note`, providing complete behavioral context.

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

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

The description is front-loaded with the primary purpose, then uses structured paragraphs (validation steps, cross-check, caveats, examples). It is lengthy but every section adds critical information. A slight deduction for verbosity, though the organization and clear headers (CROSS-CHECKS, valid: true, currency) aid readability.

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 an output schema, the description goes beyond it to explain response semantics (valid meaning, bank_identifier.resolved_institution, country_currency), potential use cases, and common pitfalls. The provided examples and warnings make the tool self-contained for an agent to use correctly in payment diagnostics.

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 a single `iban` string with 0% coverage, so the description must compensate. It provides two clear examples of valid inputs (compact and space-separated) and explains that the IBAN encodes country+bank+account. It doesn't explicitly say 'the iban parameter is the IBAN string', but the examples and context make this unambiguous, adding meaningful semantics beyond the raw schema.

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

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

The description opens with a specific verb+resource: 'Validate an IBAN and identify the institution that holds the account.' It clearly distinguishes this tool from siblings by focusing on IBAN validation and bank resolution, and it explains the cross-check feature that is unique to this tool.

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

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

The description explicitly states when to use the tool: 'Call this whenever the user supplies an IBAN AND names a beneficiary bank or BIC.' It also provides exclusion guidance, e.g., 'Never rule out the account details on the strength of it when diagnosing a failed payment.' This gives clear context and limits, outperforming typical tool descriptions.

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

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

With no annotations provided, the description carries the full burden. It honestly discloses the 'today' block, the date_anchor_warning for past dates, and concrete examples of year-mis-resolution flipping the answer (2025-07-20 vs 2026-08-20). This is far beyond a minimal 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?

Though a bit long, every sentence adds value: purpose, behavior, warnings, args, examples. It is well-structured, front-loaded with the core function, and the examples are representative. No fluff or redundant phrasing.

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

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

Given the tool's complexity (relative dates, holiday logic, warnings), the description covers all critical aspects: return content (business day, reason, next business day), the 'today' block, and the date_anchor_warning. An output schema exists, so detailed return field documentation is unnecessary here.

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

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

Schema description coverage is 0%, so the description must compensate. It does so by defining both parameters: country_code as ISO 3166-1 alpha-2 with examples ('US', 'DE') and check_date as ISO format (YYYY-MM-DD), plus three concrete usage examples that map parameters to real calls.

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

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

The description opens with a specific verb and resource: 'Check if a specific date is a business day in a country.' This clearly distinguishes it from siblings like bank_holidays (which likely lists holidays) and value_date (a settlement concept).

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

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

It provides clear context for when to use the tool (any business-day question) and gives important guidance on resolving relative dates against the server's today block. However, it does not explicitly contrast itself with alternative tools, such as saying 'use instead of bank_holidays when you need a yes/no business-day answer.'

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?

Describes key behaviors: sends verification code, requires accept_terms confirmation, and outlines legal implications by referencing specific terms sections. No annotations provided, so description carries the burden and does it well, though lacks mentions of rate limits or error handling.

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?

Description is well-structured with a clear purpose, parameter explanations, and an example. No unnecessary sentences every part adds value.

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?

Covers tool purpose, parameters, and next steps. Given that an output schema exists, it's not required to explain return values. Lacks information on error cases or prerequisites, but sufficient for a registration tool.

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

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

Even though schema description coverage is 0%, the description explains each parameter in detail: email, organization_name, and accept_terms with the requirement to be true and its legal significance. Includes a usage example demonstrating parameter usage.

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

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

Clearly states the tool registers for an Ohmyfin API key to use paid tools, describes the flow (creates account sends verification code), and distinguishes from sibling mcp_verify by indicating the next step.

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

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

Provides clear context for when to use (registration step for API key) and what to do next (call mcp_verify). Doesn't explicitly state when not to use, but implicitly suggests it's for new users only.

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

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

With no annotations, the description carries the full burden. It discloses success behavior (returns API keys) and mentions subscription activation for paid tools, but does not describe error cases (e.g., invalid code, expired code) or state changes, 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 concise with 4 sentences plus Args and Examples. It front-loads the core purpose. The subscription mention is slightly tangential but not overly verbose. Overall efficient and well-structured.

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

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

Given the presence of an output schema, the description needn't detail return structure. It covers the workflow clearly: after registration, verify with code to get API keys. It lacks error handling details but is sufficient for a straightforward verification tool.

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

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

Schema description coverage is 0%, but the description explicitly defines both parameters: 'email: The email you registered with' and 'code: The 6-digit verification code from your email.' This adds essential meaning beyond the bare schema.

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

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

The description clearly states the tool verifies email and returns API keys. It distinguishes itself from the sibling tool mcp_register by explicitly mentioning 'after calling mcp_register', making the purpose and context unambiguous.

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

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

The description provides clear context on when to use (after mcp_register, check email for code) and includes an example. However, it does not explicitly mention when not to use or alternatives, missing some usage boundaries.

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, but description details DST-observing system behaviors, field names (season_now, operative_cutoff_today), and value interpretation. Lacks idempotency/rate limit info but output schema covers return.

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?

Well-organized with sections and examples, but lengthy due to system list. Could be trimmed slightly without losing clarity.

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

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

Covers input usage, DST edge case, and parameter details thoroughly. Output schema presumably handles return format. Minor omission: no mention of error handling for invalid inputs.

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?

Despite 0% schema description coverage, the description fully explains both parameters with valid values, aliases, and usage patterns (e.g., 'TARGET2' and 'T2' resolve same). Examples illustrate usage.

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 starts with 'Get payment system cutoff times for major clearing systems' and lists specific systems, clearly distinguishing it from siblings like bank_holidays or fx_rate.

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

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

Provides explicit usage guidance for EUR filtering and DST handling, and explains parameter behavior (omitting for all, case-insensitivity). Does not contrast with alternatives but context is clear.

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

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

Without annotations, the description carries full burden for behavioral transparency. It explains that the tool evaluates methods, explains charge options (OUR/SHA/BEN), and returns cost, speed, requirements, and step-by-step fee investigation guidance. It does not mention side effects, but as a comparison/investigation tool, this is acceptable. It could disclose if it modifies data or has external calls, but given the nature, it's reasonably transparent.

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

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

The description is well-structured and front-loaded with the main purpose, followed by details and examples. Every sentence adds value—no filler. It is concise yet comprehensive, using bullet points and examples effectively without being verbose.

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 (multiple payment methods, fee investigation), the description is complete. It covers inputs, behavior, and examples. Since an output schema exists (as indicated by context signals), the description does not need to enumerate return fields. The examples cover the main use cases, making the tool easy to 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 documentation coverage is 0% (no descriptions in schema properties), so the description must fully explain parameters. It does so clearly: both parameters (source_country, dest_country) are described as ISO 3166-1 alpha-2 codes, and examples are provided for each use case. This fully compensates for the missing schema descriptions.

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

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

The description clearly states the tool's purpose: compare payment methods and investigate fee deductions for a country pair. It lists specific methods (SEPA, SWIFT, domestic) and explicitly mentions fee investigation, distinguishing it from sibling tools that might focus on single-country or general banking data.

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, including when to use the tool for fee investigation ('when the beneficiary received less than expected'). It includes multiple examples showing different scenarios (SEPA, non-SEPA, domestic). However, it does not explicitly state when not to use this tool or mention alternatives among siblings, though the examples imply some differentiation.

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

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

With no annotations, the description carries the full burden and succeeds. It discloses the free/paid tiers, behavior differences for subject types (bank vs party), the fact that warning-list entries for banks are clone-firm alerts, and that results include matching entities with similarity scores. This goes beyond a simple 'screens names' statement and gives meaningful behavioral context.

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

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

The description is well-structured: a one-line summary, then free-tier/paid info, then list coverage, then bank/party behavior, then parameter explanations, then examples. Every sentence adds value; the length is appropriate for the tool's complexity. No filler 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 the moderate complexity (different subject types, free tier, API key options, threshold) and the presence of an output schema, the description is complete. It covers all parameters, usage constraints, and special cases, leaving no critical gap for an agent to select and invoke the tool correctly.

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

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

The schema has no descriptions (0% coverage), but the description's Args section fully compensates. It explains the meaning of 'name' (person or entity), 'api_key' (optional, header alternative), 'threshold' (range, default 85, minimum score), and 'subject_type' (bank/party/auto with the special resolver behavior). This provides far more semantic richness than the raw schema.

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

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

The description clearly states the tool screens a name against global sanctions and watchlists, naming the specific lists (US SDN, EU, UK, Canada, Switzerland, Australia, New Zealand). The verb 'screen' and resource 'sanctions and watchlists' are specific, and the tool is distinct from the listed siblings such as export_controls_screen.

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

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

The description provides explicit usage context: free tier limits (3/day without API key), paid tier with API key, and how the API key can be passed. It also differentiates behavior for banks vs companies/individuals, giving clear guidance on when the tool returns designations only. Examples illustrate typical invocation patterns.

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 fully carries behavioral disclosure: beta status and beta=true payload, credit costs, inferred vs confirmed routes, route_adjusted semantics, sample-size confidence, outlier mode, non_arrival.p_reject, and the ACCC 'delivered' nuance. It even instructs the agent to prevent users from making irreversible decisions without caveats—far beyond typical 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?

Although long, the description is well-structured into clear sections (modes, input discipline, reading answers, args) and every paragraph provides operational or safety-critical information. The emphasis on BETA and caveats is justified for a high-stakes financial estimator, not clutter.

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

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

The description is self-contained: it explains when to use each mode, how to interpret output fields like basis.n, route.confirmed, route_adjusted, mode, and non_arrival.p_reject, and how to relay results honestly. Since an output schema exists, return values need not be fully enumerated, but the description still covers the key fields and edge cases.

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 has 0% description coverage, but the Args block gives meaning to every one of the 12 parameters: path-specific roles, BIC length/format, date format and switching to reverse mode, ignored params when uetr resolves, and optional enhancement fields like amount and countries. This fully compensates for the bare JSON schema.

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

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

The description opens with a specific verb and resource: 'Estimate when a SWIFT payment will arrive' and immediately distinguishes the two modes (forward and reverse). This clearly separates it from siblings like track_payment, which tracks status, and value_date, which computes banking days.

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

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

It explicitly provides when-to-use guidance: mid-flight uses only uetr, pre-trade uses currency + BICs, and reverse mode uses arrive_by_date. It also says when NOT to do things (never compute elapsed_business_days yourself), names alternatives for resolving dates (bank_holidays / value_date / is_business_day_check), and routes outlier mode to the stuck-payment diagnostic flow.

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

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

With no annotations, the description fully discloses behavioral traits: data gaps (account numbers empty, is_preferred rarely populated, intermediaries empty), interpretation of fields like asset_categories, and error scenarios (empty correspondents). It also warns against inventing data and clarifies subscription requirements.

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 lengthy but well-structured with sections (purpose, data gaps, usage notes, examples). It is front-loaded with the main goal and progressively detailed. Some repetition could be trimmed, but the complexity justifies the 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?

Given the tool's complexity and the presence of an output schema, the description covers all necessary aspects: response field meanings, error handling, data limitations, and integration with other tools via next_steps. It leaves no significant 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 coverage is 0%, so the description compensates fully. It explains 'swift' as a SWIFT/BIC code with format (8 or 11 chars), 'currency' as ISO 4217, and 'api_key' as optional with alternative passing methods. Examples illustrate usage.

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

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

The description clearly states the tool's purpose: 'Look up correspondent banking / settlement instructions (SSI) for a bank.' It specifies the resource (SSI for a bank) and differentiates from siblings like swift_lookup by focusing on settlement instructions.

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 when to use the tool ('Essential for payment routing and pre-validation') and provides guidance on next steps, such as calling ssi_lookup on correspondent SWIFT codes and inspecting the next_steps array. It also mentions using swift_lookup for missing account numbers, but lacks explicit 'when not to use' criteria.

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 the coarse nature of the sanctions flag, the automatic resolution of country names, and the coverage of non-SWIFT institutions. It also explains the return fields and provides examples.

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

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

The description is well-structured with clear paragraphs covering purpose, coverage, returns, and examples. Every sentence adds value, and it is front-loaded with the main purpose. It is appropriately sized for the complexity.

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 has an output schema (not shown) and the description lists the return fields, it is complete. It covers edge cases like non-SWIFT institutions and country name resolution. The description fully equips an agent to use the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the query parameter (search by name/BIC) and the country parameter (ISO codes or full names, automatic resolution). However, the limit parameter is not mentioned, leaving a gap.

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

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

The description clearly states that the tool searches banks and financial institutions by name, SWIFT/BIC code, or country. It explicitly mentions coverage of both SWIFT-connected and non-SWIFT institutions, and differentiates from sibling tools like ssi_lookup and sanctions_screen.

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

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

The description provides explicit when-to-use scenarios (search by name, BIC, country) and when-not-to-use (for correspondent banking or compliance verdicts, use dedicated tools). It also gives examples covering various use cases.

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 fully carries behavioral transparency. It explains that specific types (e.g., MT103) include a 'tracing_note' and that the tool can answer field-location questions. This adds meaningful 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 well-structured: clear purpose statement, coverage list, usage details, args, and examples. Every sentence is informative with no fluff. Front-loaded with the essential 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?

Given the tool's simplicity (one optional parameter) and the presence of an output schema, the description is comprehensive. It covers all use cases, includes special behavior (tracing_note), and provides examples. No gaps are apparent.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the parameter's purpose, format, case-insensitivity, examples (MT103, pacs.008), and behavior when omitted. Adds significant value over the bare 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 starts with a specific verb 'Look up' and resource 'SWIFT message types', clearly defining the tool's purpose. It distinguishes itself from siblings like 'swift_lookup' by focusing on message type details and field locations.

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

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

Provides clear instructions: pass a specific type for full details or omit to list all. Includes examples and describes when to use for field location questions. Lacks explicit when-not-to-use or direct comparison with 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?

Despite no annotations, the description fully discloses behavioral traits: deduplication of identical tracks, only results for current user + system tracks, requirement of an API key with active FI subscription. It explains limitations like not showing other users' data and that entries include what was entered vs. bank confirmations.

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

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

The description is well-structured with clear sections: a summary paragraph, a bullet-style usage guide, visibility note, API requirement, and Args list. Every sentence adds value without redundancy, and the format enhances readability for an AI agent.

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 and that it has an output schema, the description covers all necessary aspects: what the tool returns (distinct entries with entered data and bank details), deduplication logic, user scope, and prerequisites. It prepares the agent for interpreting results (e.g., amount discrepancies) and explains constraints thoroughly.

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 provides detailed semantics for 'uetr' (strongly preferred) and 'reference' (used when no UETR) in an 'Args' section. However, the 'api_key' parameter is only mentioned in the body text without explanation of its purpose or behavior in the args section, leaving a small gap.

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

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

The description clearly states the tool shows how tracking results changed over time, distinct from sibling tools like track_payment that show current status. It provides a specific verb ('Show') and resource ('tracking history') with clear deduplication behavior.

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?

Includes a dedicated 'WHEN TO USE THIS' section with three explicit scenarios (page discrepancy, amount reconciliation, before concluding consolidation). It also explains when not to use it and what alternatives to consider, e.g., 'check the history' before assuming data loss.

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

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

With no annotations, the description carries the full burden and delivers richly: it discloses success rates (~80% UETR, <1% reference-only), the need for exact amount/currency/date, the interpretation caveat that 'details' banks may be sender/beneficiary/intermediary and role is only known via self-report, and the behavior of not_found_guidance. This goes far beyond a basic safety profile and fully informs the agent of behavioral nuances.

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 long, but well-structured with clear sections (IMPORTANT, Args, Returns, Examples) that make it navigable. It earns most of its length due to the tool's complexity. However, there is some repetition — e.g., the required-ness of amount/currency/date appears both in the 'every trace needs four things' warning and in the Args section, and the UETR concept is explained multiple times. A moderately tighter version would earn a 5.

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 (6 parameters, multiple status outcomes, bank-detail interpretation, auth requirements, and recovery paths), the description is remarkably complete. It covers required parameters, exceptions, return value semantics, failure handling (not_found_guidance), and concrete examples. The presence of an output schema is a plus, but the description still goes beyond it by explaining status meanings and per-bank role interpretation, leaving no major gap for 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 0%, so the description must compensate — and it does. Every parameter receives detailed semantics: UETR format and UUID v4 example, reference as MT103 Field 20 / pacs.008 InstrId, amount exactness and warning against rounding, currency ISO 4217 and 'as sent' requirement, date formats and 90-day window, and api_key alternatives (KEY header or Authorization). Examples further illustrate correct usage. This is exemplary parameter documentation.

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

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

The description opens with 'Track a SWIFT payment by UETR or reference number', a specific verb+resource statement that clearly distinguishes this from sibling tools like swift_lookup or tracking_history. It further clarifies the scope ('enriched by data from certain banks in the correspondent chain') and the primary identifier (UETR), making the tool's function unmistakable.

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

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

The description provides explicit when-to-use guidance, including a dedicated 'WHEN THE USER HAS ONLY A REFERENCE AND NO UETR' section that tells the agent exactly what to collect and how to set expectations. It also names alternatives (recover UETR via MT103, use swift_message_reference for details) and gives onboarding steps (mcp_register → mcp_verify → subscribe), making usage context exceptionally clear.

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 of behavioral disclosure. It explains the calculation factors, the settlement_type values and their implications, and even provides instruction on handling relative dates via the `today` block from other tools, which helps agents use it correctly.

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 long but well-structured, with a lead sentence, a bulleted list of behavioral factors, an Args list, and examples. Every sentence adds value, and the format makes it easy to scan.

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 tool has six parameters with conditional requirements, and the description covers all of them, provides example calls, and addresses the nuance of the default from_date. The output schema exists, so not describing return values is acceptable. The description is complete for agent 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 description coverage is 0%, so the description's detailed Args section is essential. It provides country/currency formats, default values, conditional requirements (e.g., FX currencies required for fx_spot), and settlement_type semantics, fully compensating for the sparse schema.

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

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

The description opens with a specific verb ('Calculate') and resource ('value/settlement date for a payment'), and elaborates on the inputs that affect the result. This clearly differentiates it from sibling tools like settlement_eta or fx_timing_advisor, which target different aspects of payment timing.

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 strong sense of when to use the tool—for determining settlement dates with holiday/weekend/convention logic—and includes worked examples for common scenarios. However, it does not explicitly name alternative tools or list exclusions (e.g., 'use settlement_eta for expected arrival times'), so it earns a 4 rather than a 5.

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