FXMacroData

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

The description adds meaningful behavioral context beyond the annotations: it reveals the resumable-cursor polling pattern, the bounded nature relative to streaming, and the exact authentication failure behavior (subscription_required with a subscribe link). There is no contradiction with the annotations, which already indicate a read-only, open-world, non-destructive operation.

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 three tight sentences with no filler. The core action is front-loaded, followed by the critical polling pattern, and then the access requirement. Every sentence contributes essential information.

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

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

Given that there is a rich output schema and 100% parameter schema coverage, the description covers the remaining needed context: the tool's purpose, the cursor-based continuation pattern, its bounded behavior versus streaming, and the auth/subscription outcome. Nothing essential is missing for an agent to 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?

Schema coverage for parameters is 100%, so the baseline is 3. The description adds value beyond the schema by explaining the intended cursor workflow: 'use the returned next_cursor as since on a later call.' This gives practical meaning to the since parameter, though the other parameters are not discussed in the description.

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

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

The description opens with a specific verb and resource: 'Poll recently ingested macro announcement changes with a resumable cursor.' It clearly identifies what the tool does and explicitly distinguishes it from an unbounded streaming alternative by calling it the 'bounded MCP-safe companion to the release-event stream.' This is more than enough to differentiate it from sibling tools like latest_announcements or release_calendar.

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 explicit usage guidance: use the returned next_cursor as the since parameter on a later call rather than holding an unbounded streaming invocation open. It also provides access guidance by stating that an FXMacroData API key is required and that anonymous calls return subscription_required with a subscribe link. This clearly tells the agent when and how to use the tool.

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

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

The description adds behavioral context beyond the annotations: it notes the need for an API key and the behavior on anonymous calls (subscription_required with subscribe link). This is useful but does not cover rate limits or other potential behaviors.

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

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

The description is concise and front-loaded with the main action. It lists supported indicators and access requirements, but this overlaps with schema details. Every sentence is purposeful, though not perfectly minimal.

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 (4 parameters, output schema exists), the description sufficiently conveys the tool's function, supported indicators, and access constraints. It does not explain output format, but that is covered by the output schema, so 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 schema already provides descriptions for all parameters (100% coverage). The tool description repeats the list of supported indicators but does not add new parameter semantics beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Get historical price series for supported commodity indicators using the exact slugs advertised by this schema.' This is a specific verb and resource, and it distinguishes from siblings by focusing on commodity indicators with historical price series.

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 access requirements (API key needed, anonymous call returns subscription_required) but does not explicitly mention when to use this tool versus alternatives like latest_commodities or forex. The guidance is implicit based on the tool's name and purpose, but not explicit.

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

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

Discloses access requirements: requires an FXMacroData API key, and anonymous calls return subscription_required with a subscribe link. This is specific and consistent with the readOnlyHint annotation, adding valuable behavioral detail not present in the annotations.

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

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

Two sentences, no redundancy, front-loads the key differentiator (chart metadata) and includes the access caveat. Every sentence adds value without unnecessary detail.

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

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

For a simple tool with no output schema and three well-documented parameters, the description sufficiently explains the purpose, relationship to the sibling tool, and access constraints. 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 already documents all three parameters with descriptions and examples, covering 100% of parameters. The description adds no additional parameter semantics beyond referencing the same payload as commodities, so baseline score of 3 is appropriate.

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

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

Clearly states it returns the same payload as commodities but adds chart metadata for interactive rendering, differentiating from the commodities sibling tool. The verb 'packaged' implies retrieval and presentation, making the purpose unambiguous.

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

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

Explicitly references the commodities sibling and notes the packaging difference, implying use when an interactive chart is desired instead of raw data. It also mentions access requirements, but does not explicitly name alternative tools like latest_commodities or provide a direct 'use when' construction.

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

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

Beyond annotations (readOnlyHint=true, destructiveHint=false), the description adds update frequency (Friday 15:30 ET, Tuesday cutoff), weekly snapshot format, and API key requirement. It also discloses that anonymous calls return subscription_required, providing valuable behavioral context for the agent.

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 moderately long but well-organized: core function first, then usage scenarios, then update/API details, then supported currencies, then access note. Each sentence adds value, though the supported currency list could be seen as redundant with the schema. Overall front-loaded and efficient.

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

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

With an output schema present and 3 simple parameters (1 required), the description covers the return format (weekly snapshots with long/short open interest), update schedule, API key requirement, and supported currencies. It provides everything an agent needs to decide and call correctly, including failure mode (subscription_required).

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

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

Schema description coverage is 100%, so all parameters (currency, start_date, end_date) are already documented in the schema. The description adds supported currency list and case-insensitivity, but these are also in the schema, so it does not add meaningful new 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 fetches weekly CFTC COT positioning data for FX futures on CME, specifying the resource and action. It distinguishes itself from siblings like cot_visual_artifact (visual) and forex (broader data) by focusing on positioning metrics and trader categories.

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 lists use cases: speculator positioning, non-commercial longs vs shorts, hedge-fund positioning, sentiment extremes. It also notes API key requirement and that anonymous calls return subscription_required, but does not explicitly name alternative tools for other data types, so it's clear on when to use but 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?

Annotations already mark this as read-only and non-destructive; the description adds important access behavior: it requires an FXMacroData API key and returns subscription_required with a subscribe link for anonymous calls. It also clarifies default charting behavior and how to change it. No contradiction with annotations.

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

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

Three clauses in two sentences, all dense with information: payload relationship, default field, override mechanism, and access gate. No filler or redundancy.

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

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

For a chart-metadata tool with rich annotations and full schema coverage, the description supplies the essential behavioral context: access requirements and subscription fallback, plus the default and override field. It relies on `cot_data` for payload detail, which is acceptable given the sibling, but a standalone note on the response shape would be more complete given there is no 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?

The input schema already documents all four parameters at 100% coverage with descriptions, examples, and defaults, so the baseline is 3. The description's only added parameter insight is that `metric` changes the charted COT field, which is a minor reinforcement of the schema's 'Field to plot from each COT row'. No significant additional meaning is introduced.

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 that the tool produces MCP Apps chart metadata for COT data, with a specific default of charting noncommercial net positioning and support for other COT fields via `metric`. It explicitly distinguishes itself from the sibling `cot_data` ('Same payload as cot_data, but with...'), so an agent can tell this is the chart-variant 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?

It frames usage relative to `cot_data`: same payload, but adds chart metadata, which tells an agent to pick this tool when an MCP Apps chart is needed. It also documents the default metric and how to override it, giving a clear usage context. It doesn't spell out exclusions such as 'use cot_data for raw data', but the pairing makes the intent 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?

Beyond annotations, the description discloses that the tool returns exact indicator slug strings reusable by other tools, warns that stale/partial/unavailable rows are not suitable for real-time carry or inflation analysis, and exposes the access model: USD is keyless while other currencies return subscription_required with a subscribe link. No contradiction with annotations.

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

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

The core purpose is front-loaded, followed by usage guidance, a staleness caveat, and access information — each sentence earns its place. The supported-currency list is somewhat redundant with the schema, and the text is dense, but it remains well-structured and free of 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?

Given a complete input schema and an output schema, the description covers what the tool returns, what to do with the output, when the output should not be trusted, and the access constraints. The subscription guidance and sibling routing make it fully usable without external context.

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

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

Schema description coverage is 100%, and each parameter already has type, default, examples, and a detailed description. The prose adds marginal value by tying include_coverage to the downstream coverage check, but the supported-currency list duplicates the schema, so the description does not carry the parameter-semantics burden.

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: 'List every macroeconomic indicator FXMacroData publishes for a currency' with explicit metadata coverage (units, frequency, coverage/freshness). It distinguishes itself from siblings by naming indicator_query, release_calendar, and indicator_visual_artifact as downstream consumers of the returned slugs.

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 an explicit trigger condition — 'ALWAYS call this first when the user asks about a country's macro data' — and requires checking coverage before calling indicator_query. It also names the exact downstream tools, effectively routing the agent away from alternatives that expect pre-selected indicator slugs.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral details beyond annotations: daily windows exclude the publication-day fixing, changes from previous actuals are not consensus surprises, and non-USD currencies return subscription_required with a subscribe link. This gives the agent important operational expectations without contradicting the annotations.

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

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

The description is four sentences and each earns its place: the core purpose, a key calculation caveat, async support, and access restrictions. It is front-loaded with the purpose and avoids fluff. It is slightly denser than strictly necessary but remains efficient.

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 7-parameter tool with no output schema, the description covers the essential operational facts: purpose, calculation nuance, async behavior, and access constraints. It falls short of full completeness by not distinguishing itself from closely related sibling task tools and not hinting at the return format, but the schema and annotations carry substantial load.

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

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

Schema description coverage is 100%, with each parameter already having descriptive text, examples, and supported values (e.g., currency/indicator lists, date formats, lookback_events default). Per the rubric, the baseline is 3. The description itself does not add parameter-specific semantics beyond the schema; it only provides general context around the replay window.

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: 'Replay verified publication events against measured 1, 5 and 20-observation FX reference returns.' This is precise and clearly separates it from generic FX price or data-listing tools. However, it does not explicitly contrast itself with closely related sibling tools like fx_backtest_task or known_at_time_task, so it misses the full sibling-differentiation standard for a 5.

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

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

The description implies usage from its purpose but gives no explicit 'use when...' or 'instead of X use Y' guidance. It adds two useful invocation conditions: MCP Tasks support for async execution and the USD-vs-other-currency access restriction. These are contextual, but not a clear routing map among the many sibling task tools.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, and the description adds materially: it discloses the auth requirement ('requires an FXMacroData API key'), the anonymous-call failure mode (subscription_required with subscribe link), and the row keying ('announcement_id/date/indicator'). No contradiction with annotations.

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

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

The description is longer than average but every sentence earns its place: purpose, usage trigger, row keying, supported currency list, slug pointer, and auth note. It's front-loaded with the purpose and usage. Minor redundancy: the currency list is repeated in the schema, but it's still useful as an at-a-glance reference.

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 20-parameter tool with an output schema, the description covers the key operational facts: what data it returns, when to use it, how to resolve indicator slugs, and what happens without an API key. The output schema handles return values, so 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 100%, so the schema fully documents all 20 parameters. The description adds little beyond pointing to data_catalogue for exact indicator slugs and noting the indicator parameter lists them – helpful but not necessary. Baseline 3 is appropriate.

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

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

States a specific verb ('Return') and a specific resource ('stored forecasts... for macro announcements'), then enumerates the exact data types (consensus-style, central-bank projections, survey forecasts, IMF forecasts, nowcasts, FXMacroData). It also positions itself relative to siblings ('Use this with release_calendar and indicator_query'), so an agent can tell it apart from actual-data 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?

Explicitly states when to use: 'when a report needs actual-vs-consensus, prior-vs-forecast, or event-surprise context.' It also provides a prerequisite instruction to call data_catalogue(currency) for indicator slugs. This is clear context with a named complementary 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?

Annotations already declare readOnlyHint/openWorldHint/destructiveHint, and the description adds meaningful behavior beyond them: the API-key requirement, currency-dependent subscription errors, and the empty-result meaning. There is no contradiction with the annotations.

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

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

The description is three tight sentences: purpose first, then authentication/empty-result behavior, then the currency access rule. Every sentence adds distinct information and there is 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?

The description covers purpose, authentication, error behavior, and empty-result semantics, and the output schema covers return values. However, for a tool with nine parameters and zero schema description coverage, the optional filter semantics (dates, measure, source, issuer, offset/limit) remain unexplained, leaving real gaps for correct invocation.

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

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

Schema description coverage is 0% for 9 parameters, and the description does not compensate. It never explains limit, offset, issuer, source, measure, start_date, end_date, or instrument_id. Mentions of issuer, instrument, maturity, curve type, and source precision are framed as output preservation, not input parameter semantics, and currency is only discussed in access rules.

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: 'Read persisted official financial price observations,' then enumerates the covered instrument categories (government yield curves, individual securities, overnight benchmarks, reference prices). This clearly identifies what the tool does and sets it apart from general price/rate tools by emphasizing official, persisted observations.

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 operational context: an API key is required, USD works without a key, other currencies return subscription_required with a subscribe link, and empty results mean no stored observations exist. However, it does not explicitly say when to use this tool versus sibling alternatives such as rate_curve or fx_intraday_reference_rates.

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

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

Annotations already cover read-only and non-destructive nature. The description adds valuable behavioral context: daily granularity from central-bank reference rates, full multi-year history, and the authentication requirement (API key; anonymous returns subscription_required). It also hints at the output style (raw rows, plain-text table). This goes beyond annotations without contradicting them.

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 information-dense. It front-loads the core purpose and usage guidance, then covers data source, supported values, and access requirements in a logical order. Every sentence adds value; there is no fluff. While longer than the ideal two-sentence example, the complexity of the tool 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 (5 parameters, indicator list, currency list, authentication), the description is comprehensive. It covers purpose, usage, data source, authentication, and supported options. Since an output schema exists, return-value details are not needed. No critical information is missing 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?

Schema description coverage is 100%, so the baseline is 3. The description restates the supported currencies and indicator slugs, which are already in the schema. It adds minor nuance like 'use lowercase 3-letter codes' and 'comma-separated list', but these are largely redundant. The description does not significantly enrich parameter understanding 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's purpose: 'Get raw historical FX spot-rate rows for a currency pair'. It also explicitly differentiates from the sibling forex_visual_artifact by specifying when to prefer each. The verb, resource, and scope are 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?

It provides explicit guidance: 'Prefer this tool when the user explicitly wants a plain-text table, raw rows, exact values...' and 'If the user asks more generally... prefer forex_visual_artifact instead.' This names the alternative and the exact conditions, leaving no ambiguity.

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 the tool is read-only and non-destructive. The description adds meaningful behavioral context beyond those annotations by disclosing that an API key is required and that anonymous calls return subscription_required with a subscribe link, which is valuable operational knowledge.

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 tool's relationship to 'forex' and its core output, then follows with precise usage examples and access requirements. Every sentence earns its place; there is no filler or redundant repetition of schema content.

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

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

For a 5-parameter read-only tool with no output schema, the description covers the essential operational context: what it returns, when to choose it over the sibling tool, explicit example prompts, and the authentication failure behavior. Nothing an agent needs to decide whether and how to invoke it is missing.

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

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

The input schema has 100% coverage, so the schema already documents all five parameters with supported values, formats, and defaults. The description adds no additional parameter-level detail, but it also does not need to; the baseline of 3 is appropriate.

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

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

The description clearly states this tool returns the same FX payload as 'forex' but wrapped in MCP Apps chart metadata for an inline interactive spot-rate chart. It names the resource (FX pair time-series) and differentiates itself from its sibling 'forex' without requiring schema inspection.

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: prefer this by default for FX pair time-series and trend-view requests, with concrete prompt examples. It also states when NOT to use it — when the user wants a table, raw values, JSON, CSV-style output, or exact row-by-row data — directing to plain 'forex'.

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 (readOnlyHint=true, destructiveHint=false) already establish safety, and the description adds significant behavioral context: it downloads complete histories, verifies vintages and price coverage, charges various costs, and explicitly notes that the carry signal excludes funding income or broker rollover. It also explains the async execution support. This exceeds the baseline set by annotations.

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

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

The description is two sentences, front-loaded with the core purpose and key behaviors, then adds the critical caveat about carry signal costs and async support. Every sentence earns its place, though the caveat could be considered slightly dense for 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?

Given 10 parameters with 100% schema coverage and no output schema, the description appropriately focuses on behavior and constraints not in the schema. It covers data downloading, verification, cost charging, carry signal limitations, and async execution. The annotations convey safety, so nothing essential for correct invocation is missing.

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

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

Schema coverage is 100%, so the schema documents all 10 parameters with descriptions and examples. The description adds context for a few parameters (e.g., carry signal semantics, event gating details), but does not systematically expand parameter meaning beyond what schema already provides. Baseline of 3 is appropriate given high schema coverage.

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

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

The description clearly states a specific verb ('Run') and resource ('spot-only FX backtest'), and distinguishes it from related tools like 'fx_trade_setup_task' by emphasizing the backtest focus on historical signals and costs. However, it doesn't explicitly name sibling tools for comparison, leaving some differentiation to inference.

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 specifies when to use the tool (when running a backtest on policy-rate differentials or momentum) and how to customize it via strategy and event gating, but doesn't explicitly state when to use alternatives like 'fx_trade_setup_task'. It also mentions support for MCP Tasks, which is an alternative invocation 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?

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds valuable behavioral context: it is subscriber-only, requires an FXMacroData API key, and anonymous calls return subscription_required with a subscribe link. This goes beyond the annotations without contradicting them.

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?

Three sentences with no filler: purpose, prerequisite, and access requirement. The most important scoping information is front-loaded, and every sentence earns its place.

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

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

For a read-only tool with a rich output schema and full parameter documentation, the description covers the essential operational context: what it returns, the prerequisite universe call, and authentication behavior. Minor gaps like pagination or empty-result behavior are not critical given the output schema and annotations.

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

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

Schema description coverage is 100%, so the schema already fully documents base, quote, start_time, and end_time. The description only reinforces the 'one pair' scope and does not add parameter-level detail beyond the schema.

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

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

The description opens with a specific verb and resource: 'Return subscriber intraday official FX reference-rate observations for one pair.' This clearly distinguishes the tool from siblings like fx_reference_universe and fx_reference_sources by emphasizing 'intraday' and 'one 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?

It gives explicit guidance to call fx_reference_universe first to verify pair and source availability, and it states the API key requirement. It does not explicitly name alternatives or when-not-to-use conditions, but the context is clear.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds useful behavioral detail about authentication requirements, including that anonymous calls return subscription_required with a subscribe link, which is not inferable from the 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?

Two concise sentences, with the primary action front-loaded and the access caveat placed second. Every sentence earns its place without redundancy or extraneous detail.

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

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

Given zero parameters, an output schema, and annotations covering read-only behavior, the description is complete: it states the resource, the workflow position, and the authentication consequence. Nothing material is missing for an agent to 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?

The input schema has zero parameters with 100% schema description coverage, so there are no parameter semantics to clarify. Per the baseline rule for zero-parameter tools, this is appropriately scored at 4.

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 ('List'), a concrete resource ('public official FX reference-rate sources and their source policy'), and links to the workflow ('before requesting a pair-specific intraday reference-rate series'). This clearly distinguishes it from rate-returning siblings like fx_intraday_reference_rates.

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 frames when to use the tool: before requesting a pair-specific intraday reference-rate series. It does not name alternatives or give explicit when-not-to-use guidance, but the contextual instruction is clear enough for an agent to place it correctly in the workflow.

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, openWorldHint, and destructiveHint, so the safety profile is covered. The description adds valuable behavioral context beyond annotations by detailing the authentication requirement and the anonymous-call response ('subscription_required with a subscribe link'). This is the kind of operational detail 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 two sentences with no redundant content. The purpose is front-loaded, the usage context follows, and the access note is placed at the end. Every sentence earns its place.

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

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

For a simple list tool with two optional parameters, the description covers purpose, filters, sequencing, and authentication behavior. An output schema exists so return values need no explanation. Nothing critical is missing for an agent to decide to call and successfully invoke 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?

Schema description coverage is 100%, with both 'source' and 'currency' already described and exemplified. The description's phrase 'optionally filtered by currency or source id' only paraphrases the schema without adding new semantic meaning. Thus a baseline of 3 is appropriate.

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

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

The description clearly states a specific verb ('List') and resource ('public FX reference-rate pair universe'), with optional filters. It distinguishes itself from siblings by naming the resource type and explicitly positioning it as a prerequisite to intraday reference-rate series, avoiding confusion with fx_reference_sources or fx_intraday_reference_rates.

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 explicit sequencing guidance: 'Call this before requesting an intraday reference-rate series.' It also states the access requirement and the failure mode for anonymous calls, which informs the agent when the tool is appropriate and what to expect without an API key.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the behavioral note about supporting MCP Tasks for async execution, which is useful context. It does not contradict annotations, and the bar for additional behavioral disclosure is lower given the annotations. Still, it doesn't elaborate on response behavior 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?

The description is two sentences, with the primary purpose front-loaded and the MCP Tasks note appended. It is efficient with no redundancy, earning a high conciseness score. It could be slightly more structured but remains appropriately sized.

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 has no output schema, so the description must explain what the tool returns. It only says 'Build a trader-oriented FX pair setup' without describing the output format, structure, or how to interpret results. For a task-oriented tool with 4 parameters and no output schema, this is a significant gap. The description should clarify what a 'setup' entails and what the response looks like.

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

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

Schema description coverage is 100%, so all parameters are documented in the schema. The description's mention of 'spot context, macro differentials, upcoming catalyst risk, and optional COT positioning' aligns with parameters but does not add syntax or format details beyond what the schema provides. Per calibration, a baseline of 3 is appropriate when schema fully covers parameters.

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: building a trader-oriented FX pair setup using specified inputs. It distinguishes itself from siblings like fx_backtest_task by focusing on setup rather than backtesting, though it does not explicitly name alternatives. The mention of MCP Tasks adds context but doesn't detract from clarity.

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 a usage hint about MCP Tasks for async execution, which is a specific context. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. The guidance is implied but not fully explicit.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false. The description adds valuable context: the subscription requirement for non-USD currencies (and a subscribe link) and MCP Tasks support for async execution. This goes beyond the annotations and helps the agent anticipate access failures and execution modes.

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 – two sentences plus an access note. It front-loads the primary purpose in the first sentence, then covers async support and access. There is no fluff, and the structure is logical. Slight deduction because the access note could be seen as secondary but is still relevant.

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

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

Given there is no output schema, the description gives a fair sense of what is returned ('chart-ready series data, derived analytics, and nearest release timing context'). It also covers access constraints and async behavior. However, it stops short of specifying the exact structure or fields of the pack, and start_date/end_date semantics are left to the schema. Still, it is reasonably complete for an agent to understand what it will receive.

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% – every parameter (currency, indicator, start_date, end_date) has a description. The description does not add meaningful parameter-level detail beyond what the schema already states; it only notes that the tool targets 'one indicator' and mentions release timing, which is not directly tied to a specific parameter. Baseline of 3 applies.

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

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

The description states a specific verb ('Build an intelligence pack') and resource ('one indicator') and explains the combination of chart-ready series data, derived analytics, and release timing context. It is distinct from siblings like indicator_query (which likely queries raw data) and macro_briefing_task (which covers multiple indicators), though it does not name them explicitly.

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 condition for async execution ('when clients send task-augmented requests') and access notes (USD free vs subscription required), but it does not state when to prefer this tool over other indicator-related siblings like indicator_query or macro_briefing_task. No alternatives or exclusions are mentioned, leaving the agent 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?

Beyond the readOnlyHint/openWorldHint annotations, the description reveals important behaviors: official-source rows only, prohibited private aggregator rows always removed, as_of controls historically eligible values, and current values may include later revisions. It also discloses pagination metadata such as pagination.next_offset and page_includes_latest_available.

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 core purpose and strong usage guidance, but it is overly long and repetitive: the supported currency list appears twice and the instruction to call data_catalogue(currency) appears twice. Several sentences could be merged or removed without losing information.

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

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

For a complex 15-parameter tool, the description covers the critical workflow: preliminary data_catalogue call, auth requirements, pagination, official-only behavior, revisions, and as_of semantics. It does not fully explain every replay-related parameter like availability or value_mode, and the output schema already covers return values, so this is a strong but not perfect contextual package.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real value beyond the schema: slug overrides currency/indicator, as_of enables vintage-eligible values, official_only removes fallback observations, and dataset_version should be reused on subsequent pages. This materially helps the agent invoke the parameters correctly.

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 a paginated historical time series of a single macroeconomic indicator for a currency." It enumerates concrete use cases and explicitly distinguishes itself from indicator_visual_artifact and known_at_time_task. An agent can immediately tell what this tool is and is not.

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 explicit routing guidance: use known_at_time_task for verified historical slices, use indicator_visual_artifact for chart rendering, and call data_catalogue(currency) first for the exact slug. It also covers pagination strategy, access differences for USD vs non-USD, and subscription requirements.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the description does not need to restate safety. It adds meaningful behavioral context beyond annotations: it describes the visual rendering behavior, explicitly defers to indicator_query for raw output, and discloses the access asymmetry (USD works without an API key, other currencies return subscription_required with a subscribe link). No contradiction with annotations.

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

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

The description is long but every component earns its place: purpose and differentiation come first, followed by when-to-use, fallback conditions, pagination guidance, supported currencies, and access caveats. The only minor redundancy is repeating the full currency list that also appears in the schema, which prevents 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?

The description is robust despite having no output schema: it explains what the visual artifact returns, how to paginate, how to find valid indicator slugs, and what access errors to expect. It does not detail the exact shape of the MCP Apps metadata, but for tool selection and invocation the rendering behavior and fallback rule are sufficient.

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

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

Schema description coverage is 100%, so the schema already documents all 7 parameters, including defaults, ranges, formats, and supported values. The description adds helpful but non-essential parameter-related guidance: supported currencies are repeated, and it directs callers to data_catalogue(currency) for exact indicator slugs. It does not materially deepen per-parameter semantics beyond the schema, so baseline 3 is appropriate.

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

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

The description opens with a specific, differentiating statement: same payload as indicator_query but with MCP Apps metadata for interactive line-chart rendering in compatible clients. It clearly names the sibling tool it parallels and distinguishes its output form, so an agent can tell it apart from indicator_query without inspecting 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?

Usage guidance is explicit and decision-oriented: prefer this tool by default for time-series requests involving show, explain, compare, or trend review, and fall back to indicator_query only for raw tables, JSON, or plain structured output. It also explains how to handle broad histories with limit/offset/page and pagination.next_offset rather than arbitrary retries.

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

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

Annotations already mark it read-only and non-destructive, and the description adds meaningful behavioral context: verified vintages are selected before pagination, non-USD currencies return subscription_required with a subscribe link, and MCP task-augmented requests are supported. This goes beyond annotations without contradicting them.

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 three sentences with no filler: purpose, async behavior, and access constraints each earn their place, and the core function is front-loaded.

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

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

With annotations covering safety and schema covering parameters, the description adds useful access and execution context. It does not describe the return format or pagination mechanics, but for a read-only historical lookup with a rich schema, this is a minor gap.

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

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

Schema coverage is 100%, so the input schema fully documents all 7 parameters. The description adds little per-parameter meaning beyond the vintage and pagination context, so the baseline score of 3 is appropriate because the schema carries most of the semantic load.

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

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

The description names a specific verb and resource: returning the macro-series slice as of a timestamp and selecting verified vintages before pagination. It is clear and informative, but it does not explicitly differentiate this tool from sibling query tools like indicator_query or event_impact_replay_task.

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 useful context: async execution is available for task-augmented requests, and USD access works without a key while other currencies require a subscription. However, it does not state when this tool should be preferred over sibling tools or when it should not be used.

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

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

The annotations already mark it as read-only and non-destructive, and the description adds important behavioral detail: USD works without an API key while other currencies return subscription_required with a subscribe link. This helps the agent anticipate authorization outcomes.

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

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

The description is compact and informational, with no redundant phrasing. Each sentence adds distinct value: what it returns, when to use it, and access 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?

Given the simple one-parameter interface and the presence of an output schema, the description provides all necessary context: purpose, usage prerequisite, access caveats, and result scope. No important operational detail 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 single parameter 'currency' is fully described in the schema with a clear ISO code format, case-insensitivity note, and examples. The description also connects it to the access behavior, making its role unambiguous.

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 clear verb ('Return'), a specific resource ('latest stored macroeconomic value'), and a precise scope ('for every available indicator in one currency'). The purpose is immediately understandable and distinct from 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?

Explicitly tells when to use this tool ('for a compact current macro snapshot') and gives a prerequisite ('after data_catalogue has confirmed the currency coverage'). Also clarifies access conditions for USD versus other currencies.

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

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

Annotations already convey read-only and non-destructive behavior, and the description adds valuable context beyond them: it requires an FXMacroData API key and anonymous calls return subscription_required with a subscribe link. This meaningfully informs the agent about authentication-dependent 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?

Three short sentences, each adding distinct value: what the tool returns, how it relates to commodities, and access requirements. The main behavior is front-loaded 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?

For a zero-parameter read-only batch tool with an output schema, this description covers the necessary ground: result scope, sibling relationship, and authentication behavior. There are no missing operational details an agent would need before calling it.

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

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

There are zero parameters, so the input schema is trivially complete and there is nothing for the description to clarify. The description's mention of returning all indicators in one response also implicitly explains why no parameters are needed.

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 ('Return'), a clear resource ('latest stored value for every available commodity indicator'), and one-response batch behavior. It also names 'commodities' as its single-tool counterpart, which distinguishes it from siblings.

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

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

The description clearly frames this as the batch counterpart to commodities and notes that it is a subscriber tool, implying when it should be used. It does not explicitly say 'use commodities for a single indicator,' but the batch-versus-single distinction provides solid routing guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context: it supports async MCP Tasks, requires an API key, and returns subscription_required with a subscribe link for anonymous calls. This goes beyond the annotations and helps the agent anticipate failure modes. It does not detail output format, but with no output schema and a briefing-builder tool, the description carries the burden reasonably well.

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

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

The description is compact and front-loaded with the core purpose, then adds async support and access requirements in two additional sentences. Every sentence earns its place, though the access sentence could arguably be moved to annotations or a separate auth field. Still, it is appropriately sized 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?

For a single-parameter briefing tool with read-only annotations, the description covers the purpose, data sources, async behavior, and auth failure mode. It does not describe the output structure or how the briefing is delivered (e.g., text vs artifact), but given the tool's complexity and the absence of an output schema, the description is reasonably complete. A 5 would require explicit output format or delivery details.

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

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

Schema description coverage is 100%, so the schema already documents the single 'currency' parameter with examples and a supported list. The description adds that the briefing is 'for a currency' but does not add syntax, formatting, or behavioral details beyond the schema. Baseline 3 is appropriate when the schema does the heavy lifting.

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 ('Build') and resource ('compact macro briefing for a currency'), and enumerates the exact data domains combined (catalogue, key macro series, release-calendar, prediction, news, risk-sentiment, COT, seasonality, FX technical). This clearly distinguishes it from sibling tools like macro_war_room_task or macro_research_pack_task, which likely produce different briefing scopes.

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 mentions MCP Tasks support for async execution when clients send a task-augmented request, which is a clear usage condition. It also states the access requirement (FXMacroData API key) and the anonymous-call fallback. However, it does not explicitly name sibling alternatives or state when NOT to use this tool versus other briefing tasks, so it falls just 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds genuinely non-obvious behavior beyond annotations: the access rule where USD works without an API key while all other currencies return subscription_required with a subscribe link. It also clarifies the value is precomputed/documented, setting expectations about freshness. No contradiction with annotations.

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

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

Three sentences, zero waste: the first states the core function, the second gives the usage caveat, the third gives the access constraint. The most important information is front-loaded, and no sentence is redundant with the schema or annotations.

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 an 8-parameter read-only query with a full output schema, openWorldHint, and complete param descriptions, the description covers the essential operational context: purpose, usage boundary, and access behavior. The only notable gap is that valid factor slugs are not discoverable (no enum exists), and the description doesn't hint at where to find them; the schema's example partially compensates.

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 of 3 applies. The description adds marginal value by mapping 'stored component scores' and 'source references' to include_components and include_sources, and 'one currency' to the singular-currency expectation. Overall it mostly echoes what the schema already documents rather than deepening param understanding.

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

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

The description uses a specific verb+resource: 'Return a precomputed macro factor for one currency.' It names the optional extras (component scores, source references) and differentiates itself from news/release-oriented siblings with 'not as a substitute for inspecting its underlying macro releases,' which distances it from macro_news, release_calendar, and announcement_changes.

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 an explicit when ('Use this for a documented factor value') and a clear when-not ('not as a substitute for inspecting its underlying macro releases'). It does not name the alternative sibling tool explicitly, so the routing requires a small inference, but the exclusion 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, openWorldHint, and destructiveHint, covering the safety profile. The description adds the async MCP Task support detail and the return structure, which is useful but not extensive. No contradictions with annotations.

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

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

The description is two sentences, with the primary purpose front-loaded and no filler. Every word contributes meaning, making it highly concise 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?

For a read-only tool with full schema coverage and safety annotations, the description provides a solid overview. It mentions the output matrix components and async support, but does not detail matrix formatting or pagination, which are minor gaps 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 100%, so all parameters are documented in the schema. The description does not add any parameter-specific meaning beyond the schema, which is acceptable given the high coverage.

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

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

The description states a specific verb ('Build'), resource ('cross-currency macro heatmap'), and output content ('matrix with latest values, recent changes, and z-scores'). It is distinct from sibling tools like macro_briefing_task or macro_war_room_task, though it doesn't explicitly differentiate them.

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 no guidance on when to use this tool versus alternatives. It does not mention conditions, prerequisites, or exclusions, leaving the agent to infer applicability from the name and purpose alone.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: it returns official-source headline rows, includes lightweight keyword-derived affected_indicators and sentiment fields when classifiable, and discloses that non-USD currencies return subscription_required with a subscribe link. This goes beyond the annotations without contradicting them.

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 core purpose, followed by use-case context, return-field details, supported currencies, and access notes. It is slightly long but every sentence carries useful information; the currency list and access note are necessary for correct invocation.

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 output schema exists and annotations cover safety, the description is nearly complete. It explains what the tool returns, when to use it, supported inputs, and access restrictions. The only minor gap is that it doesn't explicitly describe pagination behavior beyond the offset parameter, but the schema covers that.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds context about the return fields (affected_indicators, sentiment) and access behavior, but does not add new parameter-level meaning beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Return') and resource ('recent official central-bank news and press-release headlines for a currency'), and distinguishes it from siblings by emphasizing official-source headlines and currency scoping. It also lists supported currencies, making the tool's scope 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 explicitly says when to use the tool: 'when a report needs headline context for central-bank policy, inflation, employment, GDP, trade, fiscal, energy, or commodity narratives.' It also provides access guidance (USD free, others require subscription), which helps an agent decide whether to call it or route to subscription-related siblings.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the description adds value beyond that by disclosing access behavior (USD without key, others return subscription_required with a subscribe link) and the async execution mode (MCP Tasks with task-augmented requests). It also mentions the output includes assumptions and confidence notes, which is not covered by annotations. No contradiction exists.

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

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

The description is three concise sentences: purpose first, then async support and access. Every sentence contributes essential information without redundancy. The most critical operational constraint (access) is placed last but still within a compact structure. No fluff or tautology.

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

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

The tool is a task-based classifier with three parameters and read-only annotations. The description covers purpose, async behavior, and access, but it does not describe the return format (e.g., what does a classification result look like, whether it's a task ID or immediate result). Given no output schema, the agent lacks clarity on what to expect after invocation. This is an incomplete picture for a classification tool, so a 3 is warranted.

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 parameters currency, start_date, and end_date are already fully documented with examples and format details. The description does not add any parameter-specific meaning beyond what the schema provides; it only mentions the underlying data inputs (policy rate, inflation, GDP, unemployment) which are not directly the tool's parameters. Baseline of 3 is appropriate as the schema carries the burden.

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: 'Classify a currency's macro regime' using policy rate, inflation, GDP, and unemployment context. It clearly differentiates from sibling macro tasks like macro_heatmap_task or macro_briefing_task by focusing on regime classification for an individual currency. The inclusion of 'explicit assumptions and confidence notes' further specifies the tool's output characteristics.

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 no guidance on when to use this tool versus alternatives. It mentions async execution support and access restrictions (USD free vs subscription required) but does not state selection criteria relative to other macro tasks. No explicit 'use X instead' or 'when not to use' is given, leaving the agent to infer usage context from the tool name alone.

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

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

Annotations already cover readOnly, openWorld, and non-destructive hints, but the description adds genuine behavioral value: it discloses that async execution is supported via task-augmented requests, and it spells out access rules (USD free, others require subscription). These are beyond the annotations and help the agent set expectations.

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?

Three sentences, no fluff. The first sentence states the core purpose and contained data types; the second adds the async capability; the third covers access rules. Everything earns its place and is front-loaded with the most important information.

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

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

Given there is no output schema, the description explains what the payload contains (catalogue, indicator history, next release timing, FX context) and mentions 'persistent-host-friendly', which hints at the shape. It also covers async and access. However, it doesn't describe the exact structure of the response or how to handle the subscription_required case beyond the link, so it's not fully complete—but close.

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

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

Schema description coverage is 100%, so the schema already documents every parameter (currency, indicator, base, quote, start_date, end_date). The description does not add further meaning to any parameter; it only references 'currency' and 'indicator' implicitly through the bundle components. Baseline 3 is appropriate given the schema's completeness.

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 'bundle' and the resource 'research payload', enumerating exactly what is included: catalogue, indicator history, next release timing, and optional FX pair context. This distinguishes it from sibling tools like indicator_query (which likely returns only history) and macro_briefing_task (which may summarize).

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 mentions MCP Tasks for async execution and access conditions, but provides no explicit guidance on when to choose this tool over alternatives. It does not say 'use this when you need all these pieces together' or name any sibling to avoid. An agent would have to infer the bundled nature implies a one-stop shop, but no direct comparison is given.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds value beyond that: it discloses async execution support via MCP Tasks and, importantly, the access gating (USD free without API key; all other currencies return subscription_required with a subscribe link). This is genuinely useful auth/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?

Three sentences, each carrying weight: what it builds, the async execution mode, and the access requirement. The core purpose is front-loaded. The access note, though placed last, is consequential rather than filler. No wasted words.

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

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

For a 6-parameter, no-output-schema, no-nested-object tool, the description covers the essential calling context: purpose, async variant, and access constraints. The enumerated output components indirectly signal what gets returned. It could name the output structure explicitly, but nothing critical is missing for a first call.

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%, with all 6 parameters documented in the input schema itself, so the baseline is 3. The description mentions 'pair context' and 'release queue' which loosely map to base/quote/currency, but it adds no parameter details beyond what the schema already provides.

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

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

The description states a specific deliverable ('multi-panel macro market cockpit') with concrete components (FX sessions, release queue, pair context, risk alerts), which is clear and actionable. It differentiates by output type from siblings like macro_heatmap_task and macro_briefing_task, though it never names a sibling explicitly.

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 conveys an implied usage context (when a combined macro cockpit is wanted) and gives a real execution-mode note about MCP Tasks for task-augmented requests. However, it provides no explicit when-to-use vs alternatives, no exclusions, and no routing to a simpler sibling for lighter queries.

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

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

The description transparently notes that it accounts for weekends and major banking holidays, and the annotations (readOnlyHint, destructiveHint) already clarify it is read-only and non-destructive. No behavior is hidden or contradictory.

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 (three sentences) and front-loaded with the primary purpose. Every sentence adds value: purpose, usage examples, and parameter behavior. No redundant content.

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

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

The tool has a single optional parameter, and the output schema is provided. Together with the description, an agent knows exactly what the tool does, when to call it, and what it returns. No gaps exist for successful 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 only parameter 'at' is fully described in the schema and the description reinforces it as optional, defaulting to now, with an example format. 100% schema description coverage and no ambiguity.

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 ('Tell') and resource ('FX trading sessions'), clearly distinguishing the tool's purpose. It explicitly mentions the sessions (Sydney, Tokyo, London, New York) and the scope of the response (currently open, next opens/closes).

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 example prompts ('is the market open?', 'when does London open?', 'which sessions overlap right now?') and explains when to pass the optional 'at' parameter for a specific moment. This fully guides an agent on when to invoke the tool.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the agent knows this is a safe, open-ended read-only query. The description adds no extra behavioral context beyond scope (clients/platforms), which is adequate but not rich.

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

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

Two sentences: the first states purpose, the second gives usage triggers. No wasted words, front-loaded with the core action.

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, no-output-schema informational tool, the description fully covers what and when. The list of platforms is exhaustive for typical use cases, and no additional context is needed.

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?

No parameters exist in the schema, so the baseline is 4. The description adds value by listing the types of questions the tool handles (OAuth, API key, specific clients), effectively documenting what would otherwise be implicit.

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

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

The description states a specific action ('Explain which authentication mode to use') with a clear resource (FXMacroData MCP) and scope (across major clients and platforms). It distinguishes from sibling tools, which are mostly data-fetching tools, by focusing on auth guidance.

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 says 'Use this when the user asks whether to use OAuth, an API key...' and enumerates specific clients/platforms. However, it does not explicitly mention when not to use it or provide alternative tool names, though none are obvious.

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

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

Annotations already indicate readOnlyHint=true, destructiveHint=false. The description adds behavioral context beyond these flags by revealing the tool's meta-purpose: it explains server capabilities, tool rendering modes, and access tiers, which sets expectations for a textual, informative response.

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

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

The description is compact and front-loaded with the main purpose ('Explain what...') followed by specific sub-topics and usage triggers. Every clause adds value, with no redundant or filler 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?

As a capabilities/discovery tool with no parameters and no output schema, the description fully covers what the tool does and when to use it. It also complements sibling tools by clearly positioning itself as the gateway for overview questions, making the response complete for an 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?

The tool takes zero parameters, so the schema places no burden on the description. With no params to describe, the baseline of 4 applies as the description correctly explains what the tool does without needing parameter details.

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

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

The description uses a specific verb ('Explain') and a clear resource (FXMacroData MCP server capabilities) while enumerating concrete topics: which tools render MCP Apps, which return plain rows, public vs subscriber-only, and cross-client selection. This clearly distinguishes it from sibling tools like mcp_auth_guide or data_catalogue.

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: 'when a user asks what is available, why visuals are not showing, or how to get the same result in a different interface.' This provides actionable triggers and helps the agent route correctly versus 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?

The annotations already signal readOnly=true and destructive=false; the description adds a valuable runtime behavior: USD works without an API key, while other currencies return subscription_required with a subscribe link. This is meaningful disclosure beyond the annotations, though it does not detail response edge cases.

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

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

The description is compact and front-loaded: purpose first, then parameter usage, supported values, and the access caveat. Every sentence carries operational information, and the supported lists are presented efficiently.

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

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

With a rich schema, output schema, and annotations, the description adequately covers the main selection logic and access constraints. It could slightly improve by noting the conditional component requirement, but that is already fully documented in the schema, so no critical context is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds semantic value by explaining endpoint_type selects the taxonomy group, dataset selects the series family, and currency determines access/subscription behavior. Component is left to the schema, which already documents its bop-only requirement.

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 metadata-first official dataset payloads grouped by API endpoint type.' It further distinguishes the tool by enumerating exact endpoint_type and dataset values, which sets it apart from sibling tools like commodities or forex without needing to open the 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?

It explains how to choose parameters ('Use endpoint_type to pick the API taxonomy group and dataset to choose the specific series family') and gives an access rule for currency. It does not name alternatives or state when not to use this tool, 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?

Annotations already indicate read-only and non-destructive behavior, but the description adds that it supports MCP Tasks for async execution and that it requires an FXMacroData API key, with anonymous calls returning subscription_required and a subscribe link. These are valuable behavioral disclosures beyond the annotations.

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

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

Three concise sentences: the core purpose first, then async support, then access requirements. Efficient, front-loaded, and free of 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?

For a composite tool with no output schema, the description explains what it does and access requirements but does not detail what the intelligence pack contains or the output format. While parameters are fully covered by schema and safety is covered by annotations, the absence of output context leaves a gap for an agent anticipating the result.

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 100% coverage with clear descriptions for all four parameters, so the description does not need to add parameter meaning. It does not add any, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool builds an intelligence pack for an FX pair and specifies it combines three contexts: policy-rate spread, spot-rate, and release-timing metadata. This distinguishes it from simple data-fetching tools, though it does not explicitly name sibling alternatives.

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 what the tool does but provides no guidance on when to use it versus the many sibling tools (e.g., rate_differentials, release_calendar, forex). There is no mention of prerequisites, exclusions, or alternative 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 already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is known. The description adds useful behavioral context by specifying that the check covers both the API and MCP server reachability, and that it is for unexpected failures. It does not describe return format, but the output schema exists to cover that.

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 exceptionally concise: two short sentences with no wasted words. The key phrase 'Quick health check' is front-loaded, and the usage guidance is directly stated.

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

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

For a simple zero-parameter health check, the description fully covers what the tool does and when to use it. The output schema exists to document return values, and the annotations cover safety. No additional context is necessary.

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

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

There are zero parameters, so the baseline is 4. The description adds nothing about parameters, but none exist, so no further elaboration is needed.

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: 'Quick health check that confirms the FXMacroData API and MCP server are reachable.' The verb 'confirms' and the resource 'FXMacroData API and MCP server' are specific, and this distinguishes it from all sibling tools, none of which are health checks.

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

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

Explicit guidance is provided: 'Use this only if other tools fail unexpectedly — it is not needed before normal calls.' This clearly states when to use and when not to use, effectively differentiating it from normal data access tools.

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

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

Beyond the readOnlyHint/openWorldHint annotations, the description reveals important behavioral constraints: 'This tool never fetches arbitrary URLs or runs custom chart code; it only composes approved FXMacroData API surfaces.' It also discloses nuanced access requirements ('USD is available without an API key; every other currency returns subscription_required with a subscribe link'), which is exactly the kind of auth/availability context the annotations do not provide. No contradiction with the annotations.

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

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

The description is densely packed but every sentence earns its place: the primary purpose and scope, the when-to-use guidance, a concrete example, the behavioral limitation, and the access caveat. Information is front-loaded with the main verb and resource in the first sentence, and there is no redundant restating of schema content.

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

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

With 19 optional parameters and no output schema, the description does substantial work: it defines the scope, lists supported sources, gives a runnable example in natural language, clarifies behavioral boundaries, and flags subscription requirements. The parameter-specific details live in the (thorough) schema, so nothing critical is missing for an agent to select and invoke this 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 input schema already documents all 19 parameters at 100% coverage, so the baseline is 3. The description adds meaning beyond that by showing how to combine an announcements series with a predictions series using concrete parameter values (`usd/policy_rate_midpoint` plus `prediction_class=forecaster_survey`), and by explaining that the `series` array is the mechanism for multi-series plots. This example effectively maps parameter usage to a real scenario, lifting the value above schema-only.

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: 'Build a generic MCP Apps chart from one or more FXMacroData endpoint families.' It then enumerates the supported series sources and gives a concrete example, clearly distinguishing this generalist chart tool from the specialized sibling visual_artifact tools (forex, cot, commodities, etc.) by emphasizing 'arbitrary plot requests, multi-series charts, and actual-vs-consensus views.'

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 it: 'Use this for arbitrary plot requests, multi-series charts, and actual-vs-consensus views that need to combine announcements with event_predictions.' It also clarifies what it is not for ('never fetches arbitrary URLs or runs custom chart code'), but it never names the alternative specialized visual artifact tools or states the condition for choosing them instead, so it falls short of a full when-to-use/when-not-to-use routing guide.

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 declare readOnlyHint=true, openWorldHint=true, destructiveHint=false, and the description adds concrete behavioral details about authentication ('requires an FXMacroData API key') and error response ('anonymous call returns subscription_required with a subscribe link'). This goes beyond annotations, providing practical operational context, though it does not describe the output format.

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 exceptionally concise: two sentences, the first stating the core purpose and the second noting access requirements. Every sentence contributes value, and the information is front-loaded with the primary action.

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

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

Given the schema covers all parameters and the tool name indicates a visual artifact, the description is fairly complete. It specifies the chart type, the access requirement, and the error behavior. The main missing element is the exact return format (e.g., image URL), but this is a minor gap given the 'visual artifact' naming convention and typical usage patterns.

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%, with each parameter having a description in the schema. The tool description adds no additional parameter-specific information beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description states a specific action ('Build a two-series chart comparing base and quote policy-rate history') and the intended purpose ('visualize the rate differential setup for an FX pair'). This clearly differentiates it from other visual artifact tools by specifying policy-rate differential, making its function 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 clearly implies when to use this tool (when visualizing policy-rate differentials for an FX pair) but does not explicitly mention alternative tools or exclusions. It lacks explicit guidance such as 'use this instead of X' or 'do not use if you need a different chart type', leaving usage context somewhat implied.

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

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

Beyond the readOnlyHint and destructiveHint annotations, the description discloses important behavioral details: async support for task-augmented requests, an API-key access requirement, the anonymous subscription_required response, and the heuristic nature of the elasticity assumption. This materially helps an agent anticipate outcomes and errors.

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?

Three sentences, each earning its place: the first states the core function, the second explains async capability, and the third covers authentication and failure behavior. The most important information is front-loaded.

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

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

For an 8-parameter task tool with no output schema, the description covers the core behavior, auth requirement, anonymous failure mode, and async support. However, it does not describe the response/output format beyond 'estimate directional spot impact', which is a modest gap given there is no 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?

Since schema description coverage is 100%, the schema already documents all 8 parameters, including examples and defaults. The description adds thematic context ('policy-rate spread', 'elasticity') but no parameter-level meaning beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Run') with a precise resource ('policy-rate spread what-if scenario for an FX pair') and the distinctive outcome ('estimate directional spot impact using an explicit heuristic elasticity assumption'). This clearly differentiates the tool from sibling tasks like fx_backtest_task or rate_differentials, even without naming them.

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: it is for scenario modeling, supports async execution via MCP Tasks, and requires an FXMacroData API key, including the anonymous failure mode. However, it does not explicitly name alternatives or state when not to use this tool versus sibling task tools.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, covering the safety profile. The description adds the async MCP Tasks execution detail, but does not disclose return behavior, output format, or other operational characteristics. With annotations present, the bar is lower, but the description adds only modest 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 two sentences with no wasted words. The primary purpose is front-loaded, and the async execution note is relevant and 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?

The parameter schema is rich and annotations cover safety, but there is no output schema and the description does not characterize the return value or result shape. For an analysis tool, an agent might need more clarity on what the response contains, though the core invocation context is adequately established.

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

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

Schema description coverage is 100%, with each parameter documented including examples, defaults, and descriptions. The tool description itself adds no parameter-level meaning, so the baseline of 3 applies.

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

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

The description clearly states the tool analyzes a multi-position FX book for concentration, stress exposure, and event-driven catalyst risk. This is a specific verb and resource with enough detail to distinguish it from many siblings, though it does not explicitly name an alternative 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 mentions that the tool supports MCP Tasks for async execution when clients send task-augmented requests, which gives some usage context. However, it does not explain when to prefer this tool over sibling tools like fx_backtest_task, event_impact_replay_task, or fx_trade_setup_task, nor does it state any 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?

Even though annotations already mark this as read-only, the description adds substantial behavioral context: no API key is needed, it works for every served currency, it returns coverage metadata only, and it distinguishes 'no publisher produces this forecast' from 'data exists but is paywalled.' It also warns to never report listed pairs as unavailable, which is important agent-facing guidance.

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 and well organized, but it repeats itself: the no-API-key/free access point appears twice, and the returns-no-values/subscription point appears twice. The content is useful, but a few sentences could be tightened without losing information.

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

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

Given the tool's moderate complexity, a single optional parameter, an output schema, and clear annotations, the description covers all necessary context: when to call, what it returns, what it does not return, access requirements, and the paywall distinction. Nothing important is missing for correct 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 already covers the single optional currency parameter at 100%, including the omit-for-summary vs pass-for-detail behavior. The description echoes this and adds that it works for every served currency, but does not add meaningfully new parameter-level semantics beyond the schema.

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

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

The description names a specific verb ('List') and a precise resource: which publishers produce pre-release forecasts for a currency's indicators, including forecast class, consensus status, and archive depth. It also differentiates from event_predictions by stating it is a coverage catalogue, not a values endpoint.

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 invocation rules: call it whenever the user asks whether a consensus or forecast exists, call it BEFORE event_predictions, and call it when event_predictions returns nothing or subscription_required. It also clarifies that forecast values are not returned and require a subscription, effectively stating when not to rely on this tool.

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

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

The description discloses that no derived sentiment or indicator classifications are added, which is a useful behavioral detail beyond the annotations. It also clearly states the authentication/access behavior for USD versus other currencies, which is important for callers to 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?

The description is concise and well-structured, with no unnecessary words. It front-loads the core purpose, adds the sibling-tool distinction, and then states access requirements in a clear final sentence.

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 output schema exists and the parameters are straightforward, the description provides enough context about what is returned and under what conditions. The access caveat and the distinction from macro_news make the tool's role in the broader toolset clear.

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

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

The schema already fully describes all parameters, including currency case-insensitivity and limit/offset defaults and ranges. The description does not add extra parameter-level meaning, so a baseline score is appropriate.

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

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

The description clearly states the tool returns the public central-bank press-release archive for a currency, with a specific verb and resource. It also explicitly differentiates this tool from macro_news, making its purpose unambiguous.

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

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

It provides direct guidance on when to use this tool versus macro_news: use macro_news when a headline summary is useful, and this tool when original official release rows matter. It also explains access differences by currency, including the subscription_required outcome.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds behavioral traits like 'deterministic projection' and async support, but it does not disclose output structure, error conditions, or any other operational traits. The added value is moderate, so a 3 is appropriate.

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

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

Two sentences with no redundancy. The core purpose is front-loaded, and the second sentence directly adds the async invocation condition. Every word earns its place.

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

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

With 9 parameters and no output schema, the description gives a general sense of the outputs via 'deterministic projection, stress percentiles, and horizon assumptions' but never specifies the return format. The annotations and schema are rich, yet an agent still lacks a clear picture of what a successful response contains. Adequate but with clear 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 100% and each parameter already has detailed descriptions with defaults and examples. The tool description mentions 'FX pair' and 'horizon assumptions' but does not add any parameter-specific meaning beyond what the schema provides, matching the baseline for high schema coverage.

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

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

The description uses a specific verb ('Run') and resource ('quant-style policy scenario for an FX pair'), and lists distinctive features (deterministic projection, stress percentiles, horizon assumptions). It indicates 'expanded' scope but does not explicitly distinguish itself from sibling tools like policy_scenario_modeler_task, so it stops short of full 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 a clear context for async execution: 'Supports MCP Tasks for async execution when clients send task-augmented requests.' However, it gives no explicit guidance on when to prefer this over sibling scenario tools such as fx_backtest_task or policy_scenario_modeler_task, leaving alternatives 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?

The description aligns with the readOnly and non-destructive annotations and adds transparency about subscription-gated behavior and anonymous-call outcomes. It does not fully spell out that no data is modified, but the annotations already cover that and the description adds meaningful access-related 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?

The description is concise and information-dense, with no redundant phrases or filler. Three sentences cover purpose, access requirements, and failure mode without unnecessary elaboration.

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

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

Given that an output schema exists, the description does not need to detail return formats. It adequately covers the tool's data-access context, authentication requirement, and anonymous behavior, making it sufficiently complete for a subscriber-gated read-only data 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 schema descriptions already cover all six parameters with 100% coverage, so the baseline applies. The description adds some context around derived forward segments and official government-nominal curves, but it does not materially deepen parameter understanding beyond the existing 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's purpose: returning official government-nominal curve nodes, slopes, or derived forward segments for one currency. It identifies the specific resource, the action, and the scope in a way that is immediately understandable.

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 actionable access guidance: it is a subscriber data tool, requires an FXMacroData API key, and notes that anonymous calls return subscription_required with a subscribe link. It stops short of comparing this tool to sibling alternatives, but the access guidance is clear and useful.

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

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

Annotations already mark the tool as read-only and non-destructive, so the description adds value by stating that results may be stored or derived and that anonymous calls return subscription_required with a subscribe link. It also tells the agent to surface the returned measure, rate type, curve family, and tenor metadata when explaining results. No annotation contradiction is 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?

Two sentences with no filler: the first states the action, the second adds result-usage guidance and access behavior. It avoids repeating schema details and remains tightly scoped.

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 read-only annotations, an output schema, and a fully documented input schema, the description covers the important operational context: stored/derived behavior, API key requirement, anonymous error response, and how to present results. It could go slightly further by noting date-range or pagination behavior explicitly, but the schema already covers those.

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

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

Schema description coverage is 100%, so the schema already documents base, quote, measure, rate_type, date range, pagination, and forward tenor parameters. The description adds no new parameter-specific meaning; its metadata guidance is about how to use the output rather than how to set the 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 opens with a specific verb and object—'Return the stored or derived rate differential for one FX pair'—so an agent can tell this is a data-retrieval tool rather than a visual artifact tool. It does not explicitly differentiate from close siblings like rate_curve or policy_rate_differential_visual_artifact, but 'for one FX pair' narrows the scope.

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

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

The description implies use when an agent needs a stored or derived rate differential for a single FX pair, and the access note sets expectations for authentication. It does not state when to prefer this tool over siblings such as rate_curve or policy_rate_differential_visual_artifact, nor does it provide 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?

The description goes well beyond the annotations (readOnlyHint, openWorldHint, destructiveHint=false) by disclosing the exact return shape (ISO-8601 announcement_datetime in UTC, market-local timestamps, optional timezone-converted field), the future-only scope, and the access restrictions (USD no key, other currencies return subscription_required with a subscribe link). It also mentions the `announcement_datetime_requested_timezone` field and the `release`/`currency` fields in each row, giving the agent a clear model of what the tool will return and what to expect.

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 suitably structured with essential information front-loaded: the primary purpose and use-case examples in the first two sentences, followed by return format, parameter guidance, and access details. It is long, but most of the length is necessary coverage for such a complex tool with five parameters and a large indicator list. There is some redundancy: the full currencies list is repeated from the schema's property description, but since the agent sees the schema as well, this makes it slightly less concise than it could be.

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

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

No output schema is present, so the description carries the full burden of explaining the return format. It covers the key elements: ISO-8601 UTC timestamps, market‑local timestamps, optional timezone field, the `release` string and `currency` code per row, and the access behavior for different currencies. For a tool with no return schema and five parameters, the description is complete enough to know what the tool returns and what to expect.

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

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

The input schema already contains a description for all 5 parameters (100% coverage), which sets the baseline at 3. The description adds meaning by explaining when to actually pass parameters: start_date/end_date use when the user mentions a month, week, day, or explicit date range; `timezone` for an optional converted timestamp; `indicator` to narrow to a single series, and it directs the agent to the `data_catalogue(currency)` for the exact indicator slugs. This is pragmatic, actionable usage guidance that the schema's type-level descriptions do not provide.

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 upcoming scheduled macroeconomic release timestamps for a currency.' It clearly states the tool's purpose and includes explicit usage examples like 'when is the next CPI/GDP/payrolls/policy decision' and 'plan a trade around a known release', which distinguishes it from sibling tools such as latest_announcements and release_calendar_visual_artifact. This makes it easy for an agent to understand exactly what this tool does and how it differs from related capabilities.

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 when to use the tool ('Use this when the user asks...' and 'or to plan a trade around a known release') and provides an exclusion with 'Unbounded calls return future releases only; do not show stale past rows unless the user explicitly asks for historical/past calendar data.' It also gives guidance on what to do for presentation and data catalogue lookups, but does not explicitly route to sibling tools like latest_announcements for already-released data, so the alternative routing is left implicit.

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

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

Beyond the readOnly/openWorld/non-destructive annotations, the description discloses important behavioral context: it returns the same payload as release_calendar, triggers inline rendering in compatible clients, and includes access behavior stating USD requires no API key while other currencies return subscription_required with a subscribe link. This goes well beyond what annotations provide.

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 dense but well-structured: purpose and default-selection rule come first, alternate-tool guidance second, then parameter guidance, supported currencies, and access. Every sentence earns its place, and the lengthy indicator list is left to the schema rather than repeated in the description.

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

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

For a tool with no output schema, the description is complete enough: it explains what the tool renders, when to choose it over its sibling, how to filter parameters, which currencies are supported, and the auth/access behavior. No critical operational detail needed to invoke it correctly appears to be missing.

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

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

Schema coverage is 100%, so the schema already documents every parameter. The description adds value by mapping parameters to user intent, e.g., passing start_date/end_date/indicator when a specific series or range is named and timezone for local-time requests. This is meaningful usage-level semantics beyond the schema's type and default information.

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 this tool is a visual artifact wrapper around release_calendar, designed so MCP Apps clients render an interactive Release Calendar App inline. It explicitly differentiates from the plain release_calendar sibling by naming the rendering behavior and the user intent it serves, such as 'show me the AUD release calendar'.

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?

Usage guidance is explicit and actionable: prefer this tool by default for show/display/visualize/render requests, and prefer plain release_calendar only for raw tables, JSON, exact rows, or text-only output. It also says when to pass indicator, start_date, end_date, and timezone, leaving no ambiguity about tool selection.

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 carry readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context by naming the input signals ('release-calendar proximity and indicator-level heuristics') and noting async support. It does not disclose output details, but the annotation safety profile lowers the burden.

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

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

Two sentences, no filler, and the core action is front-loaded. The second sentence adds the async-task nuance that is otherwise absent from annotations. Every sentence earns its place.

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

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

The description explains what the tool does and when async execution applies, but there is no output schema and the description never clarifies what the output looks like, how the score is scaled, or how to interpret the result. For a scoring tool, return-value semantics are important contextual information.

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 base, quote, and horizon_events each have descriptions plus examples. The description adds no per-parameter detail beyond the schema; it only restates the general purpose. With full schema coverage, baseline 3 is appropriate.

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

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

The description states a clear verb and resource: 'Score upcoming releases for a currency pair using release-calendar proximity and indicator-level heuristics.' This is specific enough to convey what the tool computes. However, it does not explicitly distinguish this from sibling tools such as event_impact_replay_task or pair_intel_task, so it misses the full dimension of 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 gives one conditional usage cue: 'Supports MCP Tasks for async execution when clients send task-augmented requests.' This is useful context for when the async variant is relevant, but it does not say when to choose this tool over the many adjacent task tools, nor does it mention any exclusions or alternatives.

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

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

Beyond the readOnlyHint annotation, the description discloses important runtime behavior: it requires an FXMacroData API key and that anonymous calls return subscription_required with a subscribe link. It also reveals output components such as composite score, regime label, component contributions, pagination, and data_quality metadata.

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

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

The description is compact and front-loaded: it opens with the primary action and resource, then adds result composition, use case, and access requirements. Every sentence earns its place with 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?

For a read-only tool with two optional date parameters, an output schema, and annotations, the description covers the essential operational context: what the result contains, when to use it, and authentication behavior. Nothing critical is missing for an agent to decide whether and how to call it.

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 are already documented as optional date filters. The description adds no additional parameter-level meaning, so the baseline of 3 is appropriate.

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

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

The description clearly states a specific resource — the global risk-on/risk-off sentiment series — and its purpose for FX regime analysis. It is distinct enough from generic macro tools, though it does not explicitly name or differentiate against sibling tools like macro_regime_classifier_task.

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 explicit guidance on when to use it: 'before classifying high-beta, safe-haven, commodity, or USD-defensive FX conditions.' It lacks explicit exclusions or named alternatives, but the intended usage context is clear.

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

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

The annotations already declare readOnlyHint, openWorldHint, and destructiveHint, so no contradiction exists. The description adds that the tool returns computed monthly statistics 'from stored FX or gold series', which is useful but does not go beyond the annotation-covered safety profile with details about side effects, auth, or rate limits.

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

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

The description is compact and well-structured: one sentence states the core function and trigger cases, and a second sentence summarizes the returned metrics. Every clause adds useful information without repetition or 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?

Given the rich parameter schema and the presence of an output schema, the description is complete enough. It names the input domain, the query scenarios, and the key returned fields (average return, median, win rate, sample size, dispersion, per-year monthly returns), so an agent can select and invoke the tool confidently.

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

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

The schema already provides 100% coverage with descriptions for all four parameters: instrument, month, end_date, and lookback_years. The tool description does not add any extra parameter-level meaning, so it stays at the baseline for well-documented schemas.

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 ('Get'), a precise resource ('monthly return seasonality for an FX pair or XAU/USD'), and immediately gives concrete trigger phrases such as 'seasonal patterns', 'month-of-year tendency', and 'historical monthly win rate'. It clearly distinguishes this tool from the broad set of FX and commodity siblings by focusing on seasonality analysis.

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

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

The description explicitly says 'Use this when the user asks for seasonal patterns, month-of-year tendency, historical monthly win rate, or XAUUSD/gold seasonality', giving clear usage conditions. It does not name alternative tools or state when not to use it, but the provided trigger list is sufficiently specific for an agent to decide.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false. The description adds a behavioral detail by stating it 'Returns a direct checkout path,' clarifying the tool's output. It does not contradict annotations.

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

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

The description is a single sentence that front-loads the verb and resource, provides usage context, and states the return value. Every word earns its place with 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 tool has no parameters, no output schema, and simple behavior, the description fully covers what an agent needs: when to invoke it and what to expect (a checkout path). No additional context is necessary.

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 has zero parameters, so the schema is fully covered. The description adds context about what the tool accomplishes, but parameter semantics are inherently minimal. Baseline 4 for zero-param tools is appropriate.

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

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

The description clearly states 'Open subscription options' with a specific verb and resource, and explains the purpose: 'when a user needs to unlock MCP app visuals, charts, and advanced analytical tools.' This distinguishes it from sibling data/analysis tools.

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

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

The description provides clear context on when to use it: 'when a user needs to unlock MCP app visuals, charts, and advanced analytical tools.' It doesn't explicitly mention alternatives or exclusions, but the trigger condition is specific enough for an agent to decide.

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