banking-intelligence

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

With no annotations, the description carries full burden and excels. It reveals the internal logic of payment_impact analysis, the meaning of 'costs_a_business_day', the conditions for a holiday to count, and the authoritative nature of elapsed_business_days_by_send_date. It also warns against misinterpreting empty lists, providing transparent boundaries.

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 organized with sections and bullet points. Every paragraph adds value; however, the diagnostic bullet is dense and could be tightened. It is not as concise as a two-sentence description, but length is justified by 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?

The description covers purpose, parameters, return sections, edge cases, and examples. It anticipates the user's diagnostic needs and explains the semantics of the output. For a tool with two parameters and no annotations, it is exceptionally complete.

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

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

Schema description coverage is 0%, so the description fully compensates. It defines country_code as ISO 3166-1 alpha-2 with examples, and year as optional with default current year and a range 2020-2030. Both parameters are clearly explained and mapped to 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 specific verb+resource: 'Get bank/public holidays for a country with payment impact analysis.' It clearly distinguishes this tool from siblings like is_business_day_check and country_banking_rules by focusing on the payment impact analysis, not just listing holidays.

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

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

The description explicitly states when to use: 'for diagnosing a payment that is ALREADY stuck' and provides decision rules for interpreting recent holidays. It includes a caveat to not invent holidays from training data, and directs to use the authoritative business-day count 'verbatim instead of hand-counting.' This goes beyond vague context to actionable guidelines.

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 provided, the description carries the full burden of behavioral disclosure. It openly explains that `days` is a ceiling not a guarantee, that series start at different dates per currency, that `series_coverage` reports what is actually spanned, that market data is not ECB, that peg context includes third-currency pegs, and that errors name the missing leg. This is exceptionally transparent about edge cases and potential misinterpretations.

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 sentence serves a purpose. It uses paragraphs, bolded warnings, and a clear separation between the main description, args, and examples. The structure makes important caveats prominent without being verbose or repetitive.

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 (source distinctions, data gaps, peg context) and the absence of annotations, this description is remarkably complete. It covers return values, error handling, historical coverage semantics, and user precautions. The presence of an output schema reduces the need to explain return structure, but the description still covers all important behavioral aspects, making it fully adequate 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 provides no descriptions (0% coverage), so the description must compensate. It does so thoroughly in the Args section: base and target are defined as ISO 4217 codes, and days is explained as a lookback window with a default of 90 and a clear caveat that it is a ceiling, not a guarantee. The inclusion of examples further clarifies 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?

The description clearly states the tool's purpose: 'Get the historical reference exchange-rate series for a currency pair.' It uses a specific verb ('Get'), identifies the resource ('historical reference exchange-rate series'), and distinguishes itself from the sibling 'fx_rate' tool by emphasizing 'historical'. This makes it unambiguous and differentiates it from other rate-related tools.

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

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

The description provides explicit usage guidance, including that both currencies are required, there is no implicit EUR/USD default, and how to interpret `series_coverage` and `source` fields. It also gives strong when-not guidance (e.g., never describe a market series as ECB, never fill gaps from memory). However, it does not explicitly mention alternatives or when to use this tool versus sibling tools like `fx_rate` or `fx_volatility`, so it falls short of a 5.

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

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

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?

With no annotations provided, the description fully carries the transparency burden. It discloses exactly what each call returns: investigation playbooks, common causes, recommended actions, ISO 20022 reason codes, and child reason codes. It also explains the behavior of omitting the code, leaving no ambiguity about side effects or output.

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, usage-first directive, scenario table, return value breakdown, and examples. It uses bullets and bolded scenarios for scannability, and there is no redundant filler.

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

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

Despite having an output schema, the description goes beyond by explaining domain concepts (GPI reason codes, child codes), providing realistic examples, and covering edge cases like omitted arguments. It is complete enough for an agent to select and invoke the tool correctly in the majority of payment-investigation contexts.

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

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

The schema only documents a single nullable 'code' parameter with no description. The description compensates completely by explaining what values to pass, examples (ACSP, G001), and the meaning of omitting the code. It transforms the raw parameter into a fully understood API.

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

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

The description uses specific verbs ('Explain', 'provide') and clearly identifies the resource (SWIFT GPI tracking status codes). It distinguishes itself from sibling tools like track_payment and tracking_history by framing itself as the diagnostic entrypoint for stuck-payment investigation.

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 states 'USE THIS TOOL FIRST' for stuck payments and provides scenario-by-scenario recommended calls with concrete code arguments. It clearly signals when to call with a code versus without, and gives exclusions implicitly by listing specific scenarios.

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

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

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 exist, so the description carries full responsibility. It thoroughly discloses behavioral nuances: the distinction between standard and DST values, the existence of `season_now` and `operative_cutoff_today`, the warning to quote today's operative cutoff rather than defaulting to winter values, and the alias handling for T2/TARGET2. This goes far beyond a basic read-only query 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?

Despite being long, the description is well-structured with clear sections (coverage, guidance, DST warning, Args, examples). Every sentence carries meaningful information—there is no fluff. The prominent DST warning is placed close to the top, ensuring agents notice the critical pitfall.

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 (many systems, DST handling, multiple parameters) and the presence of an output schema, the description is remarkably complete. It covers system coverage, currency filtering logic, DST behavior, parameter semantics, and usage examples. The guidance about which cutoff to quote is especially valuable for correct real-world usage.

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

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

The input schema provides only types without descriptions, so the description compensates fully. It explains both parameters in an 'Args' section, giving concrete examples ('system="T2"', 'currency="EUR"'), notes case-insensitivity, and clarifies that 'TARGET2' and 'T2' resolve to the same entry. This adds substantial meaning beyond the schema structure.

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 payment system cutoff times for major clearing systems', a specific verb-resource pairing. It further details the exact systems covered (RTGS, net settlement, SEPA, FX, etc.) and distinguishes itself from sibling tools by focusing solely on cutoff times, not other payment-related queries.

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 usage guidance, e.g., 'For same-day EUR guidance: filter by currency="EUR" to retrieve all SEPA schemes plus T2 in one call' and explains how to interpret DST-sensitive values. While it does not explicitly mention when not to use or name alternatives (like settlement_eta or value_date), the instructions are concrete and contextual enough for an agent to apply correctly.

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

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

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 provided, the description shoulders the full behavioral disclosure burden. It exceeds it remarkably: it details cross-referencing, the verification block, adjudication semantics (corroborated vs not_corroborated), coverage_gate behavior, what is and isn't removed, and how to handle unverified responses. It even explains the underlying logic of false-positive floors and warns against misreporting. No contradiction with annotations exists since none are provided.

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

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

Though long, the description is densely informative and well-structured. It opens with a one-line purpose, then moves into tier/coverage details, bank-specific nuances, verification and adjudication logic, gates, and finally a clear Args section and examples. Every section earns its place; nothing is fluff. For a tool with this many behavioral subtleties, the length is justified and the structure helps an agent parse it.

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

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

The tool is complex—multiple gates, adjudication values, verification blocks, and subject-type variations. The description covers all of them in depth, explains the output semantics (what fields mean, how to interpret them), and gives edge-case handling (e.g., bank clone-firm alerts, non-Latin aliases). It also warns against common reporting pitfalls. For the complexity level, 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?

The schema has zero description coverage, so the description must compensate entirely. The 'Args' section gives each parameter (name, api_key, threshold, subject_type) a full explanation: types, defaults, allowed values, and behavioral implications (e.g., subject_type options and how bank resolution overrides the passed value). It also provides concrete examples for different parameter combinations, adding meaning far 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 precise declaration: 'Screen a name against global sanctions and watchlists.' It names the verb (screen), resource (name against sanctions/watchlists), and global scope, and it distinguishes itself from siblings like export_controls_screen (export controls) and swift_lookup (SWIFT lookups) by stating exactly what this tool does and what it doesn't. The purpose is unambiguous and unique among the sibling set.

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 use guidance: it explains the free/paid tier distinction, when to pass an API key, and how to choose subject_type ('bank' vs 'party' vs 'auto'). It also gives clear direction on when to prefer alternatives (e.g., for banks, screening by BIC or calling swift_lookup yields a verified answer). It even tells the agent how to interpret results and when to avoid certain reporting behaviors, leaving nothing to inference.

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

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

With no annotations provided, the description carries the full burden — and it overdelivers. It discloses the BETA status and instructs the agent to say so, defines response semantics (`route.confirmed=false` means inferred, not GPI-confirmed; `route_adjusted=true` means route-composed, not observed), flags the outlier mode behavior, and even addresses billing transparency ('never describe tracking as free'). This goes far beyond any annotation could have captured.

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?

Exceptionally well-structured with headers, bold labels, and code-format parameter names — easy to scan despite length. The 'Reading the answer honestly' section and forward/reverse mode setup earn their place. Docked one point because some agent-behavior instructions (e.g., 'relay these to the user') could arguably live in the system prompt rather than a tool description, and the description could be tightened by 15-20% without losing meaning.

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

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

For a 12-parameter, dual-mode tool in BETA with no annotations, this is as complete as it gets. It covers both invocation modes, edge cases (outlier mode, rejected past dates), interpretation guidance for every non-obvious return field (n, route_adjusted, p_reject), and even billing implications. The guidance to present windows as estimates rather than commitments is exactly the kind of nuance an agent needs for a financial tool of this complexity.

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 had to carry everything — and it documents all 12 parameters in a well-organized Args block. It adds meaningful context per param: `uetr` is 'preferred for mid-flight questions,' `current_status` and `elapsed_business_days` are 'pre-trade path only,' `arrive_by_date` switches to reverse mode and 'a date in the past is rejected,' and `amount` accepts both formats ('50000' and "50,000.00"). Also clarifies the deterministic resolution of parameters from the tracking record.

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 first sentence nails it: 'Estimate when a SWIFT payment will arrive: a corpus-grounded arrival window with an honest tail, computed from real completed payments...' — a specific verb (estimate), resource (SWIFT payments), and scope (arrival windows). It clearly differentiates from siblings like `track_payment` (tracking status) and `value_date` (business-day resolution) by framing itself as the arrival estimator with two explicit modes.

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?

Excellent input discipline section: distinguishes 'Mid-flight payment' (pass ONLY the uetr) from 'Pre-trade question' (currency + sender_bic/receiver_bic), and explains reverse mode with arrive_by_date. It even directs the agent to resolve date ambiguities 'against the `today` block returned by bank_holidays / value_date / is_business_day_check.' Slightly docked because it never explicitly names a sibling as a better alternative in plain terms — the guidance is thorough on how to use THIS tool but doesn't say 'for X, use sibling Y instead' as a direct comparison.

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?

With no annotations, the description carries the full behavioral burden and does so thoroughly: it discloses representative-office selection, office_note, the coarse sanctions FLAG limitation, country-name normalization, and the pricing implications of BIC choice. It is unusually transparent about the 'BIC identifies an office, not a brand' trap and provides worked examples. No contradiction with annotations because none are present.

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 block carries operational weight: coverage scope, sanctions caveat, BIC-office pricing rule, and usage examples. It is front-loaded with the search statement and uses capitalization sparingly for a genuinely critical warning. Still, the BIC-identification section could be tightened without losing 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?

For a tool with an output schema already explaining return shape, the description covers the remaining agent-critical context: entity classes searched, coarse vs full sanctions distinction, parameter formats, office-vs-brand behavior, and examples. The limit omission is minor because the schema provides a default and the output schema bounds what is returned.

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 only property names and defaults with 0% description coverage, so the description must compensate. It richly explains query (name, BIC, city, non-SWIFT entities) and country (ISO or full English name, auto-resolution), but says nothing about limit or its default meaning. This is a small but real gap, so 4 rather than 5.

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

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

The description opens with a specific verb-resource pair: 'Search banks and financial institutions by name, SWIFT/BIC code, or country.' It also differentiates itself from neighboring tools by explicitly pointing to SSI tools for settlement instructions and sanctions_screen for compliance verdicts, so an agent can select it correctly without opening schemas.

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

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

It provides concrete when-to-use guidance: use for bank/institution lookup across SWIFT and non-SWIFT entities; use dedicated SSI tools for correspondent/settlement; use sanctions_screen for a full compliance verdict. It also gives decision rules for city/BIC disambiguation, telling the agent to include a city when named and to ask which BIC otherwise. This is explicit and actionable routing.

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 fully carries the transparency burden. It discloses case-insensitivity, the effect of omitting the parameter, and that 'MT103 and pacs.008 responses include a tracing_note explaining UETR recovery,' which goes beyond the schema to reveal valuable output behavior.

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

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

Although longer than average, the description is well-structured with clear sections for overview, coverage, field questions, args, and examples. The first sentence front-loads the core purpose, and every section adds substantive 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 single optional parameter and the presence of an output schema, the description is comprehensive. It explains the tool's scope, usage, parameter behavior, and a special output detail, making it fully sufficient 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's message_type has zero description coverage, but the Args section fully compensates with examples, case-insensitivity note, and the omit-to-list behavior. This provides the agent with complete semantic understanding of the parameter.

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

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

The description opens with 'Look up SWIFT message types — MT (FIN) and MX (ISO 20022),' which clearly identifies the action and resource. It also distinguishes itself from siblings by explicitly covering message types and payment field locations, making the tool's unique purpose evident.

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

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

The description gives clear usage guidance: 'Pass a specific type to get full details, or omit to list all types' and 'Also use this tool to answer questions about where specific payment fields live.' However, it does not mention when-not-to-use or name alternative tools, so it lacks explicit exclusions.

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 provided, the description carries the full burden of behavioral disclosure, and it goes far beyond a simple summary. It explains refusal semantics, what happens when beneficiary_fee.known=false, the OUR-breach caveat, why correspondent fees are ranges, and that the estimator is BETA with beta=true in the payload. It even warns against common misuse patterns like adding missing fees as zero, which is exactly the kind of behavioral transparency an agent needs.

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-organized with headers and bullets, and most sentences carry real operational value. There is some redundancy (BETA is stated twice, and 'never a quote' is repeated in different forms) and the examples are detailed, but given the tool's complexity and the absence of annotations, the length is largely justified. It is structured well, with the core summary front-loaded and detailed behavioral notes following.

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 addresses nearly every situation an agent will encounter: refusals, missing tariffs, observed vs. tariff sources, charge type behavior, assumptions, segment fallbacks, OUR breach, and corridor-level basis. It also covers operational context like credit costs and the BETA flag. With an output schema present and no annotations, this description is unusually complete for a tool of this complexity.

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. The Args section explains all 10 parameters, including BIC formats, charge_type options, the meaning of beneficiary_segment, and the default behavior when it is omitted. It adds substantial meaning beyond the bare schema by explaining why each parameter matters and what the consequences of omitting it are.

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 what a cross-border payment will COST, split by WHO PAYS.' It names the three fee components and the recipient-receives figure, so an agent immediately knows what the tool does. This also distinguishes it from sibling tools like fx_rate or track_payment, which cover related but different concerns.

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 strong contextual guidance: pass beneficiary_bic when known, ask the user for charge_type, only use this for cross-border payment cost estimation, and never use it as a contractual quote. It does not explicitly name sibling tools as alternatives or state when NOT to use this tool instead of another, so it stops one short of a 5.

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

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

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.