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

With only readOnlyHint/openWorldHint provided, the description carries real behavioral weight: it explains the no-API-key fallback (ECB first, else the issuing central bank), that this is surfaced in a `note` field, that `rate_date` should be relayed, that some pairs or inverted pairs require a key, and that the returned rate is a mid-market rate. That is well beyond what the annotations convey.

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

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

Front-loaded with the when-to-use triggers, then return shape, then fallback behavior, then exclusions and alternatives. Every sentence carries distinct information; nothing is padding.

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 invocation conditions, output shape, degraded-mode behavior, limitations, and sibling routing. With an output schema present it need not explain return values, yet the extra detail it does give (note, rate_date) is directly actionable.

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

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

Schema description coverage is 100% and both parameters already document the ISO 4217 format, case-insensitivity, fiat-only restriction, pair direction, and the list_currencies fallback. The description restates the same direction semantics ('1 source = 0.9234 target') rather than adding new parameter-level detail, so the baseline 3 for schema-driven params is correct.

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

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

States a specific verb+resource ('live exchange rate') and explicitly scopes it to single fiat-to-fiat pair conversion. It distinguishes itself from siblings in the same breath ('For multiple targets in one call use get_rates_authenticated; for a past date ... use get_historical_rates'), so an agent can route without opening any schema.

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

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

Gives concrete trigger phrases ('what is X in Y?', 'convert X to Y', 'current rate of EUR/USD'), states the exclusions (no crypto, no commodities, no arithmetic on amounts), and names both the multi-target alternative and the historical alternative with the condition that selects each.

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?

Goes well beyond readOnlyHint/openWorldHint by disclosing the paid-plan API key requirement and the 403 failure mode for free/trial keys, the fixed sampling cadence per period, and the fact the window always ends NOW. These are non-obvious operational constraints an agent cannot derive from annotations or schema.

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

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

Front-loaded with example phrasings that map directly to user utterances, then return shape, then sampling, then auth, then alternatives. Every sentence carries a distinct piece of information with no padding.

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

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

With an output schema present, the description need not restate the return structure in depth, yet it does summarize it and still covers sampling resolution, window semantics, and auth gating. Nothing needed for a correct call is missing.

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

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

Schema description coverage is 100%, so the period enum, its point counts and the ISO 4217 pattern are already documented. The description mostly restates the sampling mapping and the source/target direction semantics already present in the schema, adding little beyond the baseline.

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

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

The description states a specific verb+resource (fetch a fixed-window historical rate time-series) and anchors it with concrete example queries. It distinguishes itself from siblings by explicitly naming get_rates_authenticated for past datetimes and get_exchange_rate for a single live rate.

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

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

Explicit when-to-use ('fixed-window time-series questions') plus two named alternatives with the exact condition that selects each (a specific past datetime, a single live rate). The agent never has to infer 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?

Annotations only cover readOnlyHint and openWorldHint, so the description usefully adds the parts they cannot: the API-key/paid-plan requirement for `date`, weekend/holiday rollback to the last published date, the `derived` flag for cross-computed pairs, and the instruction to cite `rate_date`. It stops short of discussing rate limits, caching, or table size limits, so it is strong but not exhaustive.

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

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

Front-loads the definition and the get_exchange_rate distinction, then handles each parameter mode in order. It is dense — semicolons carry several distinct constraints per sentence — but nearly every clause carries a decision-relevant fact rather than 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?

For a four-parameter read tool with an output schema present, the description covers everything an agent needs to choose the right call: source-tool dependency (list_central_banks for bank codes), auth implications, date fallback behavior, and pair narrowing. Return-value details are appropriately deferred to the output schema.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds genuine semantics the schema lacks: `date` shifts to the last published table on weekends/holidays, omitting `date` yields the newest table without a key, and omitting both source and target returns the full table with cross-computed pairs flagged `derived`.

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 the resource precisely ('OFFICIAL rates a named institution published') with three real user-phrasing examples, and explicitly names the sibling it is not (get_exchange_rate). An agent can distinguish it from get_exchange_rate and get_historical_rates without opening a schema.

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

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

Gives explicit when-to-use routing ('NOT live market rates — use get_exchange_rate for those'), plus conditions for each invocation mode: omit `date` for the newest table (no API key), supply `date` for the table in force that day (API key, paid plan), omit source/target for the full table vs both for one pair.

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

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

Annotations only declare readOnlyHint and openWorldHint; the description adds a real access constraint ('a past datetime needs a paid plan') that annotations cannot express, plus the row-per-target x bucket response semantics. It stops short of discussing rate limits, pagination, or the cost/behavior of large multi-target requests, so it is strong but not exhaustive.

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

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

Front-loaded with the two primary use cases, the return shape, then the caveat and alternatives - a sensible ordering. It is dense and some inline examples duplicate what the schema already shows, which keeps it just under fully economical.

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

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

With an output schema present, the description need not restate the response shape but does briefly clarify the row semantics anyway, and it covers auth/plan gating, all four parameters' intent, and sibling routing. Nothing required to call it correctly is missing.

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

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

Schema coverage is already 100%, so the baseline is 3; the description still adds meaning by spelling out the return direction ('1 unit of source is worth in target'), the no-spaces comma-separated target syntax, and the interaction between omitting `time` and using `group` for rolling averages.

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

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

States a specific verb+resource and enumerates the two exact modes it serves: multi-target latest rates in one call, and point-in-time rate at a past datetime. It also names the sibling tools it is NOT (get_exchange_rate, get_historical_rates), so an agent can disambiguate 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?

Explicit when-to-use for both modes ('a' multi-target, 'b' past datetime with optional bucketing) plus exclusions routed to alternatives: single live pair -> get_exchange_rate, fixed lookback windows -> get_historical_rates. It even flags the plan constraint that gates the `time` path.

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

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

Annotations only declare readOnlyHint and openWorldHint, and the description adds substantial context beyond them: the rate is never revised, the cross is computed via USD and flagged `derived`, the latest table needs no key while a past date requires an API key on a paid plan, and it warns this is not the WM/Refinitiv fix nor a registered benchmark with a disclaimer to relay. This is exactly the auth/caveat/derivation detail the annotations do not carry.

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

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

Front-loaded with the core definition, then usage, then parameter behavior, then caveats – a logical progression. It is dense with parentheticals and slightly long, but nearly every clause carries non-redundant information; little is pure padding.

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

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

With an output schema present, return values need not be explained, and the description still covers usage, sibling routing, parameter interaction, auth/plan requirements, and benchmark caveats. Nothing an agent needs to call this correctly is missing.

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

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

Schema coverage is 100% (baseline 3), but the description adds genuine semantics beyond the schema: omit source/target for the whole table vs. supply both for one pair crossed via USD and flagged `derived`, and omit date for the latest (no key) vs. supply it for a past day (API key, paid plan). This clarifies interaction and side effects the parameter docs alone do not convey.

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

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

The description states a specific verb and resource ('once-a-day, never-revised mid-market rate') and defines the exact methodology (per-currency median of samples in a five-minute window at 16:00 London). It actively distinguishes this from the live-quote sibling (get_exchange_rate) and the official-rate sibling (get_official_rates), so an agent can route correctly without opening any schema.

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

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

Explicit when-to-use is given with concrete scenarios ('index levels, return series, research datasets, month-end reports') plus explicit when-not-to-use via named alternatives ('rather than a live quote (get_exchange_rate) or an institution's official rate (get_official_rates)'). Nothing is left 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?

Annotations cover the read-only and open-world hints, and the description goes beyond them with auth context ('No API key needed') — a real distinction from the sibling get_rates_authenticated — plus freshness/health metadata ('whether it is behind schedule'). That is exactly the kind of operational context annotations cannot express.

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 call-first instruction is front-loaded, and every subsequent clause carries distinct payload: use cases, inventory size, return fields, and auth requirement. No filler or restatement of the name.

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

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

For a zero-parameter list tool with an output schema and read-only annotations, this description covers trigger conditions, inventory scope, field contents, cross-tool linkage, and auth needs. Nothing an agent needs to select or invoke it correctly is missing.

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

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

The tool takes zero parameters, so the baseline is 4 and there is no parameter semantics to clarify. The description's field-level explanation (code, name, publication date, schedule status) is informative but describes the response rather than inputs.

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 gives a precise verb+resource ('Returns every covered source — 121 central banks plus 3 tax authorities') and enumerates the exact returned fields (code, name, latest publication date, schedule status). It distinguishes itself from siblings by explicitly linking its `code` output to `get_official_rates`'s `bank` input.

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 opens with an explicit trigger ('Call this FIRST when you need a bank code') and supplies sample user questions ('which central banks do you cover?' / 'do you have rates from X?'), which map intent to this tool. It also names the downstream tool that consumes the result, so the when-to-use path is unambiguous.

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

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

Annotations already declare readOnlyHint and openWorldHint, and the description adds real context beyond them: upstream caching for 24h, low call cost, the validation-purpose rationale, and the crypto exclusion. These are operational traits an agent needs for budgeting calls and setting expectations that annotations cannot express.

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 directive that matters most — call this before other tools — is front-loaded, followed by concrete trigger phrases, then the return shape, scope limits, and cost. Every sentence carries a distinct piece of information with no 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?

With an output schema present, the description need not detail return values, yet it still sketches the shape ({currencies: [{code,name,symbol}], count}). Given the zero-parameter simplicity and existing annotations, nothing an agent needs to call this correctly is missing.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. There is no parameter semantics to add, and the description correctly says nothing about inputs.

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

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

States a specific verb and resource ('List supported currencies') and pins down scope precisely: 160+ ISO 4217 fiat currencies, explicitly excluding cryptocurrencies. An agent can distinguish this reference/enumeration tool from the rate-fetching siblings (get_exchange_rate, get_historical_rates) without opening any schema.

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

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

Gives an explicit temporal instruction ('Call this BEFORE other tools'), enumerates the exact user phrasings that should trigger it, and names the downstream tools it protects (get_exchange_rate / get_rates_authenticated / get_historical_rates). The when-not case (cryptocurrencies) is also stated.

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

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

Annotations only say it is a non-read-only, open-world, non-idempotent call; the description goes well beyond that by disclosing the 3-keys-per-IP-per-day rate cap, that the key is adopted by the server for the rest of the session, and that it is returned exactly once and must be persisted by the user in MCP config. That is exactly the operational context an agent cannot infer from structured fields.

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

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

Front-loaded with the core action and limits, then the trigger condition, then the session/return behavior, then the durable alternative. Every sentence carries distinct information with no restatement of the title.

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

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

An output schema exists so return values need not be explained, and the description still covers limits, session adoption, persistence instructions, and escalation paths. Nothing an agent needs to call this correctly or explain the result to a user is missing.

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

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

Schema coverage is 100% for both optional parameters (agent, purpose), so the schema already carries their meaning. The description adds no extra syntax, format, or example guidance for either field, so the baseline 3 applies.

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

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

States a specific verb+resource (self-issue an AllRatesToday API key) plus the exact scope: 100 lifetime calls, 7-day validity, no account or email. This is unmistakably distinct from the read-only rate siblings, which none of them create credentials.

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?

Gives an explicit trigger ('when another tool answered "needs an API key" and the user wants real-time rates or history right now') and names the alternative for the opposite case ('For a lasting key, register at ... or see pricing'). Both the when and the when-not are covered.

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