Inferventis — Financial Data, News & Web MCP

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

With no annotations, the description carries the burden of behavioral disclosure. It explains what is returned (list of transactions), how account filtering works, and the credential prerequisite. It doesn't cover edge behaviors like error handling or rate limits, but covers the core behavior 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 well-structured and front-loaded with the primary purpose. It includes essential context about alternatives and requirements without fluff. Every sentence contributes to understanding when and how to use the tool.

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

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

Given the tool's simplicity (2 optional params, no output schema), the description is complete. It covers purpose, usage, alternatives, and prerequisites, making it sufficient for an agent to select and invoke 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 is 100% for both parameters, so baseline is 3. The description adds value by explaining that omitting account_id returns transactions across all linked accounts and that limit controls the maximum number of transactions, reinforcing and extending the schema descriptions.

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

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

The description clearly states it retrieves bank account details and transaction history, with a specific verb and resource. It also differentiates itself from siblings like open_banking_transactions and stripe_payments by specifying the connected bank API integration and 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 provides explicit usage guidance: 'Use bank_accounts when...' and 'Prefer open_banking_transactions when... / Prefer stripe_payments when...' It also notes the credential requirement, giving clear context for when to choose this tool over 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?

Discloses that it sources real-time rates from CoinAPI, requires a CoinAPI key, and consumes CoinAPI quota—a non-obvious operational cost. Even with no annotations, this adds meaningful behavioral context. It does not mention response format or error handling, but the quota warning and key prerequisite strengthen transparency beyond baseline.

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 lengthy but every sentence contributes: function, examples, usage guidance, alternatives, and prerequisite note. It is front-loaded with the core purpose and logically organized, though the multiple alternative references could be condensed 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 3-parameter tool with no output schema, the description covers purpose, use cases, alternatives, prerequisites, and quota implications. It lacks an explicit statement of return value (converted amount), but that is easily inferred. Overall it is complete enough for an agent to select and invoke 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 descriptions already fully document each parameter (amount, from, to) with valid formats and case-insensitivity. The description adds value by clarifying supported conversion pairs (crypto-to-fiat, fiat-to-crypto, cross-crypto) and that amount is denominated in the 'from' currency, but this does not significantly exceed the schema's 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 explicitly states the tool converts amounts between crypto and fiat or crypto-crypto pairs, with concrete examples (BTC/USD, BTC/ETH). It distinguishes itself from sibling tools by name (crypto_price, currency_convert), making its scope unmistakable.

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

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

Provides explicit when-to-use guidance: 'Use crypto_fx_rates when the conversion involves at least one cryptocurrency and a specific amount must be converted.' It also names alternatives (crypto_price, crypto_price_lite, currency_convert, currency_fx_lite) with clear conditions, covering both crypto-only and fiat-only scenarios.

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

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

No annotations are provided, so the description carries the full burden. It discloses that data is 'real-time', returns live spot prices only (not historical), and lists the exact fields (price, 24h change, market cap, volume). It does not mention rate limits or error behavior, but that is less critical for a read-only query tool.

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 purpose, then details, then usage alternatives and exclusions. Every sentence earns its place; no wasted words despite being relatively long.

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 exists, but the description explains the return values (price, change, market cap, volume). It also covers limitations (historical data, fiat-to-fiat) and clearly positions the tool relative to siblings, making it self-contained for agent decision-making.

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 baseline 3 applies. The description adds minor context (e.g., 'full market picture' and 'lighter response') but the schema already describes the include_market_data flag clearly. No extra syntax or format details beyond 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 states a specific verb ('Retrieves') and resource ('real-time price data for any cryptocurrency listed on CoinGecko'), clearly distinguishing from siblings like crypto_price_lite and crypto_fx_rates. It names the tool's scope and key outputs.

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 when-to-use guidance, naming alternatives (crypto_price_lite, crypto_fx_rates, currency_convert) and exclusions (no fiat-to-fiat, no historical data). This exceeds the calibration example.

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

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

With no annotations, the description carries the full burden and mostly succeeds. It discloses the public API source, omits extended market data, supports 10,000+ assets, accepts ticker or full names, and notes currency default. It lacks error/rate-limit details but is otherwise transparent.

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

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

The description is a bit verbose but every sentence adds value — purpose, variant comparison, usage alternatives, input formats, and defaults. It is well-organized and 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 there is no output schema, the description sufficiently explains the return values (price, percentage change, timestamp). It also covers core usage scenarios, parameter details, and scope, making it complete for a simple price lookup tool.

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

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

Schema coverage is 100% and includes descriptions for both parameters. The description adds value by clarifying case-insensitivity, default currency, and that full names like 'bitcoin' are accepted, going beyond schema basics.

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

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

The description clearly states the tool retrieves current spot price and 24-hour change for any cryptocurrency, naming the returned fields (price, percentage change, timestamp). It also distinguishes itself from sibling tools crypto_price and crypto_fx_rates, making the purpose unmistakable.

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

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

Explicit usage guidance is provided: use crypto_price_lite when only raw price and 24h direction are needed, prefer crypto_price for extended data, and use crypto_fx_rates for currency conversion. This gives clear decision rules for the agent.

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

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

With no annotations, the description carries the burden. It discloses the live data source, return values (converted amount, rate, timestamp), and supported currencies. It doesn't explicitly state there are no side effects or auth requirements, but as a conversion tool the read-only nature is implicitly clear. The API source and metadata details provide solid transparency.

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

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

The description is well-structured and every sentence contributes value: purpose, return info, currency list, usage guidance, alternatives, and exclusions. It is front-loaded with the core function and remains appropriately sized for the decision-making needs it addresses.

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

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

Despite no output schema, the description explains the return values and metadata. The tool is simple (3 params) and the description covers purpose, supported inputs, alternatives, and explicit exclusions. This is complete for an agent to select and invoke 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 is 100%, so the parameter descriptions already provide full semantics. The tool description adds minimal parameter-specific value beyond reiterating currency support and examples; it doesn't clarify parameters beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool's function: converting a monetary amount between currencies using live exchange rates. It identifies the specific resource (Frankfurter API/ECB data) and distinguishes from sibling tools by naming alternatives like currency_convert_lite, currency_fx_lite, and currency_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 provides when-to-use guidance for full metadata needs, and when to prefer lite versions for just amount/rate. Also directs users to currency_rates for historical rates and warns against crypto conversions, naming the appropriate tools. This is comprehensive alternative selection guidance.

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

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

With no annotations, the description carries the full burden. It discloses the live data source (Frankfurter/ECB), what is returned (amount and rate), that the response omits timestamp/source attribution, and that crypto is unsupported. It also mentions fallback behavior when Frankfurter is rate-limited. However, it does not discuss error handling, invalid code behavior, or any potential side effects, so a small transparency gap remains.

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 necessary but front-loaded: the first sentence states the core action, the second states the return value, and the rest is purposeful sibling differentiation. While the tool-selection guidance is verbose, it earns its place given the large sibling list. No filler words 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 has no output schema, so the description must explain return values, and it does: 'Returns the converted amount and the exchange rate applied.' It also covers data source, response scope (minimal), and exclusions. Given that this is a simple conversion tool with three fully documented parameters, the description is contextually complete.

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

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

The input schema already covers parameter meaning 100%, so the baseline is 3. The description adds value by specifying 'fiat currencies' only, listing example ISO codes, and explicitly stating crypto pairs are not supported. This extra context helps disambiguate parameter constraints beyond the schema's generic 'ISO 4217 code' definitions.

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 ('Converts') and clear resource ('monetary amount between any two fiat currencies'), immediately distinguishing it from sibling tools. It further clarifies that this is a 'lightweight variant of currency_convert' with a minimal response, so the tool's purpose is unambiguous.

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

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

The description provides explicit when-to-use guidance and names alternatives: use this when only converted value and rate are needed, prefer currency_convert when timestamp/richer output is needed, prefer currency_fx_lite when ECB source is not required, use currency_rates for historical, and currency_convert_open as a fallback. It also excludes crypto and directs to crypto_price/crypto_fx_rates, making selection among siblings very clear.

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

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

With no annotations provided, the description carries the full burden. It discloses that the source is an 'open public exchange rate feed suitable for informational use', indicating reliability limitations. It explicitly states the output (converted amount and rate applied) and excludes cryptocurrency pairs. While it doesn't discuss rate limits or error handling, it offers meaningful behavioral context beyond a mere conversion claim.

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 every sentence earns its place: purpose, output, fallback context, preference alternatives, and exclusions. It front-loads the main action and then systematically addresses sibling tools, making it well-structured for an agent navigating many related tools.

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 3-parameter tool with no output schema and no annotations, this description is highly complete. It covers what the tool does, what it returns, when to use it versus alternatives, its suitability for informational use, and a clear exclusion for crypto pairs. Given the sibling complexity, 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 description coverage is 100%, with each parameter (to, from, amount) already described with ISO 4217 and positivity constraints. The description adds that only fiat currencies are supported, which is a useful semantic clarification, but doesn't go beyond the schema's parameter-level documentation. Thus 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 verb and resource: 'Converts a monetary amount between two fiat currencies using live exchange rates'. It clearly distinguishes itself from siblings by naming alternative sources and specifying it does not support crypto pairs, directing users to crypto_fx_rates instead.

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 given: use this tool when currency_convert or currency_fx_lite are unavailable or rate-limited. It also states when to prefer alternatives: prefer currency_convert/currency_rates for ECB-auditable rates for accounting, currency_convert_lite for minimal output with ECB backing, and currency_fx_lite for lightweight mid-market conversions. It even excludes crypto conversions.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool returns the converted amount and rate, uses live mid-market rates, and does not support crypto pairs. However, it does not specify the exact rate provider (only mentions ECB/Frankfurter as not specifically needed) or any potential rate latency limits, leaving some ambiguity about the data source.

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 in the first sentence, followed by structured usage guidance and exclusions. Every sentence contributes value, making the length justified given the large sibling list. There is no redundancy 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?

The description covers the essential aspects: function, output fields, usage context, exclusions, and supported currency codes. It would be more complete if it mentioned the rate source explicitly or potential error conditions, but for a lite conversion tool with no output schema, it provides sufficient context for an agent to select and invoke it correctly.

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

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

Schema coverage is 100% with all three parameters (amount, from, to) having descriptions. The description adds minimal extra value beyond the schema, such as accepting 'all major ISO 4217 currency codes' and confirming amount must be positive. It does not provide syntax or formatting details beyond what the schema already includes.

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

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

The description clearly states the tool's function: 'Converts a foreign exchange (FX) amount between two fiat currencies using live mid-market rates. Returns the converted amount and the exchange rate applied.' It also explicitly distinguishes from sibling tools by naming them and their purposes, such as 'currency_convert' for richer metadata and 'currency_rates' for historical 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 provides explicit usage guidance: 'Use currency_fx_lite when only the numeric result is required and the ECB/Frankfurter data source is not specifically needed.' It also gives clear alternatives for other scenarios (prefer currency_convert, currency_convert_lite, currency_rates, currency_convert_open) and explicitly excludes crypto pairs, directing users to crypto_fx_rates or crypto_price_lite.

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

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

With no annotations, the description must carry the behavioral transparency burden. It discloses the ECB/Frankfurter source, supports historical dates, and excludes crypto. However, it does not mention response format or whether rates are mid-market, which are relevant behavioral traits for a rate lookup tool.

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

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

The description is a single, well-structured paragraph where every sentence adds value. It starts with a clear purpose statement, then expands with usage guidelines and exclusions, without redundancy 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 no output schema and no annotations, the description provides strong context: purpose, source, historical capability, usage conditions, and alternatives. It lacks an explicit mention of the return structure (e.g., converted amount and rate), which prevents a perfect score, but overall it is complete enough for effective tool selection.

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 (amount, from, to) already clearly described. The tool description adds no further parameter-level detail, so a 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?

The description explicitly states the tool's function: 'Retrieves live and historical fiat currency exchange rates from the Frankfurter API (sourced from the European Central Bank).' It also clarifies its distinct capability of supporting historical date lookups, which clearly differentiates it from sibling conversion 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 gives explicit usage guidance with concrete conditions: 'Use currency_rates when a rate from a specific past date is required (e.g. accounting, tax, or audit), or when the ECB source must be documented.' It further distinguishes alternatives like currency_convert, currency_convert_lite, currency_fx_lite, and currency_convert_open, making the selection criteria very clear.

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

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

With no annotations provided, the description carries the full transparency burden. It discloses that calculations run 'entirely locally with no external API dependency' and specifies what each calculation returns (e.g., 'returns return on investment as a percentage and absolute profit or loss'). This gives the agent a clear behavioral contract without relying on structured 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?

While the description is long (~200 words), every sentence earns its place: it front-loads the core purpose, then systematically details each calculation type, followed by usage guidance and exclusions. The structure is logical and not redundant, making the length justifiable for a multi-purpose tool.

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

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

Given the tool's complexity (11 parameters, no output schema, no annotations), this description is exceptionally complete. It covers all six calculation types with their inputs and outputs, explains when to use this tool vs alternatives, and explicitly warns against misuse for market data. 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?

Schema coverage is 100%, and each parameter already has a detailed description including units and applicable calculation types. The tool description echoes these details (e.g., periods: years vs months) but adds no new parameter-level information beyond what the schema already provides. Baseline 3 is appropriate because 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 starts with a specific verb ('Performs precise financial calculations') and enumerates all six calculation types with their exact outputs. It clearly distinguishes this tool from siblings by naming financial_calculator_lite and market data tools, making the purpose unmistakable.

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

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

Explicit when-to-use guidance is provided ('Use this tool when an agent needs to perform any structured financial calculation'). When-not-to-use is also clear: 'Do not use this tool to fetch live market prices or exchange rates,' with named alternatives (stock_quote, crypto_price, currency_convert). Additionally, it tells when to prefer financial_calculator_lite over this tool.

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

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

With no annotations provided, the description fully carries the behavioral burden. It discloses local execution with no external API dependency, returns only a numeric result rather than a breakdown, and explicitly states it does not fetch live market data. This is comprehensive transparency for a calculator tool.

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, starting with core functionality, then output format, differentiation, usage guidance, and limitations. Every sentence contributes valuable information with no redundancy, and the longest part is justified by the need to distinguish from sibling tools.

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 absence of an output schema and annotations, the description provides sufficient context: supported calculation types, output nature, and relationship to sibling tools. It also clarifies the lack of live data, which is critical for correct tool selection. The description is complete for its 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?

The input schema already provides 100% coverage, detailing each parameter and the accepted values for calculator_type. The description adds no additional parameter-level meaning beyond what the schema states, 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 performs common financial calculations locally, lists supported calculation types, and emphasizes it returns a single numeric result. It explicitly distinguishes itself from financial_calculator by being the lightweight variant, making the purpose unmistakable.

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

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

It provides explicit guidance: use this tool when only the headline figure is needed, prefer financial_calculator for full breakdowns, and use stock_quote, crypto_price, or currency_convert for live market data. This gives clear when-to-use and when-not-to-use instructions with named alternatives.

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

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

With no annotations, the description carries the full burden. It discloses the API key requirement, the exact data returned (price, intraday high/low, percentage change, previous close, sector, exchange), and the behavior of include_company_info (defaults true, false for faster response). It does not cover rate limits or error handling, but overall is transparent.

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

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

The description is longer than average but well-structured: purpose first, then output data, then usage guidance, then exclusions, then API key note. Every sentence adds value. Minor flaw: it refers to the tool as 'stock_quote' instead of 'finnhub_stock_quote', which could confuse an agent.

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

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

For a 2-parameter read-only tool with no output schema, the description is complete. It explains the returned data, prerequisite (API key), when to use, when not to use, and how it differs from sibling tools. No gaps that would prevent correct selection or invocation.

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

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

Schema coverage is 100% for both parameters, with detailed descriptions and examples for symbol and include_company_info. The description adds minor extra context (set include_company_info to false for faster response) but otherwise repeats schema content. 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 ('retrieves') and resource ('real-time stock price quotes and company information') and clearly distinguishes this tool from siblings like stock_price_lite, crypto_price, and currency_convert. It states exactly what it does, making it easy for an agent to identify its purpose.

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

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

Provides explicit when-to-use guidance ('Use stock_quote when an agent needs...'), explicit preference over stock_price_lite when richer data is needed, and clear exclusions ('Do not use for cryptocurrency... Do not use for fiat currency conversion'). Names specific alternative tools for these 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?

With no annotations, the description carries the full burden. It discloses read-only status ('strictly read-only'), token requirement ('Requires a TrueLayer access token'), and mock behavior ('returns structured mock data if no token is configured'). It also details return structure. Missing are error handling and rate limits, but overall it is transparent.

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

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

The description is front-loaded with the action and scope, then return details, usage guidance, exclusions, and auth. It is a single long paragraph but readable. Some redundancy (e.g., 'strictly read-only' after saying no payment initiation) but every sentence adds value. Not maximally concise, but well-structured.

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

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

Given no output schema, the description covers return shape (balance, ISO 4217 currency code, up to 100 transactions with date, merchant, amount, category), usage contexts, exclusions, and auth/mock behavior. This is sufficient for an agent to decide invocation and interpret results. Complete for this tool's 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 the baseline is 3. The description adds context that limit controls transaction count ('up to 100 recent transactions') and mentions optional date filtering, but largely relies on the schema's already-detailed parameter descriptions. No significant additional 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 opens with a specific verb ('Retrieves') and resource ('bank account balances and transaction history via PSD2 Open Banking'), naming TrueLayer and its coverage. It explicitly distinguishes the tool from stripe_payments by directing Stripe-related tasks to that sibling, making the purpose unmistakable.

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

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

It provides explicit when-to-use scenarios ('inspect a user's spending history, verify a payment has cleared, assess account affordability') and explicit exclusions ('Do not use for payment initiation', 'Do not use for Stripe-specific payment records... use stripe_payments instead'). This is textbook usage guidance.

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

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

With no annotations provided, the description carries the full burden. It discloses the search model, the return payload (tools, schemas, pricing tier, call instructions), and result limit. It could add a note about read-only behavior or failure modes, but overall it is transparent about its function.

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, front-loaded with the main purpose, followed by usage guidance and return details. Every sentence contributes information 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?

The description covers what the tool does, how it does it, when to use it, and what it returns. Given that there is no output schema, the description's mention of output contents is helpful. Minor gaps: no detail on default behavior or edge cases, but it is complete enough for effective use.

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

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

Schema description coverage is 100%, with each parameter well-documented. The description does not significantly add new meaning beyond the schema, but it does mention the 'exact call instructions' and 'pricing tier' in the output, which indirectly helps understand the purpose of the intent parameter. Baseline for high coverage is 3.

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 ('discovers the most relevant tools'), a specific mechanism ('local semantic search'), and clearly differentiates this tool from its siblings by framing it as a meta-tool for finding other tools. It is not vague or tautological.

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 tool first when you are connected to this server but do not know which specific tool to call' and 'Do not use this tool if you already know the tool name — call that tool directly instead.' This perfectly distinguishes when to use vs. avoid.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose what is returned (single numeric value) and what is omitted (high/low, percentage change, etc.), and it notes the limitation of not supporting crypto. However, it lacks details on data freshness/delay, error behavior for invalid tickers, or rate limits, which are relevant for a price lookup tool. This 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?

The description is efficient and front-loaded, with the core purpose in the first sentence. It uses a few sentences to convey purpose, scope, alternatives, and exclusions, and every sentence adds value. It is slightly longer than strictly necessary but remains clear and not verbose.

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

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

For a simple one-parameter tool with no output schema, the description is fairly complete: it explains the return type, what is omitted, when to use this versus stock_quote, and what not to use it for (crypto). Minor gaps remain about data sources, update frequency, and error handling, but these are not critical for a lightweight price lookup. The description competently covers the main contextual needs.

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 for the single parameter 'symbol', with a detailed description and examples. The tool description adds little beyond restating 'by ticker symbol,' so it does not meaningfully augment the schema. The baseline of 3 is appropriate since 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 immediately identifies the tool as retrieving the current trading price for a publicly listed stock by ticker, and specifies the output as a single numeric value. It also explicitly distinguishes itself from the sibling stock_quote by stating 'lightweight variant' and listing omitted fields, making the purpose and scope unmistakable.

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

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

The description provides clear when-to-use guidance: 'Use stock_price_lite when only the raw current price is needed for a quick lookup or calculation. Prefer stock_quote when the agent also needs price change, intraday range, company information, or a fully structured response.' It also explicitly excludes cryptocurrency and directs users to crypto_price or crypto_price_lite, offering clear alternatives.

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

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

With no annotations, the description carries the full burden and does well: it discloses the return format ('simple records array'), the filtering mechanism, the limitation compared to stripe_payments (no customer details, metadata, pagination cursors), and the authentication requirement ('Requires a Stripe API key to be configured on the server'). The only minor gap is not detailing exact record fields or error behavior, but the description strongly conveys the tool's 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 efficiently structured with five sentences, each serving a distinct purpose: core function, usage context, differentiation from stripe_payments, alternative recommendations, and authentication requirement. It is front-loaded with the main purpose and contains no redundant or unnecessary 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?

The description is comprehensive for a simple read tool, covering the action, filtering, limitations, alternatives, and a prerequisite. Since no output schema exists, it could explicitly list the fields in the returned records, but the characterization as a 'simple records array' and the lightweight scope make this acceptable. Overall, it is quite complete for the tool's 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?

The input schema already covers 100% of parameters with descriptions for limit (default/max) and query_type (accepted values). The tool description paraphrases the query types (recent charges, refunds, etc.) without adding new semantic details, so the 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?

The description explicitly states 'Retrieves payment and charge records from a Stripe merchant account' and 'Returns a list of payment records filtered by the requested query type,' clearly identifying the action and resource. It further distinguishes itself from stripe_payments by calling itself a 'lightweight variant,' making the purpose unambiguous and differentiating it from sibling tools.

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

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

The description provides explicit when-to-use guidance: 'Use stripe_payment_records when an agent needs to review recent charges, refunds, disputes, or subscription payments from a Stripe account.' It also names alternatives: 'Prefer stripe_payments when the agent needs complete Stripe charge objects' and 'Prefer open_banking_transactions or bank_accounts when the payment data source is a bank account.' This fully covers usage context and 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?

No annotations are provided, so the description carries the full burden. It discloses a prerequisite (Stripe secret key), describes output structure ('full Stripe charge objects'), and details what each query type returns. It doesn't mention rate limits or error handling, but for a read-only retrieval tool, the behavior is well covered.

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 minimal but every sentence serves a purpose: core function, query types details, use cases, alternatives, exclusions, and prerequisite. It is well-structured and front-loaded, though slightly verbose due to the detailed enumeration of query types.

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 compensates by explaining what each query type returns. It also covers prerequisite requirements and clarifies scope vs alternatives. A minor ambiguity exists in the claim that the tool returns 'full Stripe charge objects' for all query types, as customers/subscriptions likely return different object types, but overall it is sufficient for the tool's 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?

The schema describes both parameters with 100% coverage, but the description adds value beyond the schema by specifying exact return fields (status, amount, currency, error codes, etc.) for each query_type. The limit parameter is not mentioned in the description, but the schema already covers its semantics; thus, the description adds meaningful detail for query_type.

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

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

The description explicitly states the tool's function ('Retrieves live payment data from a Stripe account via the Stripe API') and enumerates four distinct query types, each with specific outputs. This clearly distinguishes it from siblings like stripe_payment_records, which is mentioned as a lighter-weight alternative.

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

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

The description provides explicit use cases ('investigate payment failures, audit recent transaction activity...'), a direct alternative recommendation ('Prefer stripe_payment_records for a lighter-weight...'), and exclusions with alternatives ('Do not use for bank account transactions... use open_banking_transactions instead'). This fully addresses when to use the tool.

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

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

No annotations are provided, so the description carries the burden. It states the return value ('Returns the converted local time in the target timezone') but does not disclose important behaviors such as daylight saving time handling, date boundary changes, or error cases. This is a moderate gap for a timezone tool.

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 somewhat verbose, with five repetitive examples that could be trimmed to one or two. It is front-loaded with the core purpose, but the examples pad the text without adding substantial value.

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

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

Given the moderate complexity and thorough schema, the description covers purpose, usage, and return value sufficiently. It lacks details on edge cases like DST or invalid inputs, but for a simple conversion tool this is not a major 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?

The input schema already provides 100% coverage with detailed descriptions for all parameters. The description adds value through examples that illustrate how parameters are used, but it mostly repeats parameter names without adding new semantic meaning.

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 converts time between timezones, which is a specific verb+resource. It provides multiple examples that illustrate its purpose, and there is no other timezone tool among the siblings to confuse it with.

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 when you need to' and gives several concrete scenarios, making it clear when this tool is appropriate. However, it does not mention when not to use it or name alternatives, though no direct alternative exists among the 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?

With no annotations provided, the description carries the full burden. It discloses 'No API key required', real-time retrieval, and the exact output fields. However, it does not explicitly mention rate limits, error behavior, or explicitly state that the operation is read-only, though this is strongly implied by 'Retrieves'.

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 return details, authentication note, usage scenarios, and exclusions. It is slightly longer than the minimal example, but each sentence contributes meaningful information with no filler.

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

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

Given the lack of an output schema, the description compensates by listing the exact returned fields (headline, description, source name, URL, publication date) and the sort order. It also covers use cases, exclusions, and source limitations, making it complete for an agent to decide when and how to 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%, so the schema already fully documents all three parameters. The tool description adds minimal extra value beyond the schema, with the only additional insight being the tip about using a lower limit for a quick briefing. 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 the specific verb 'Retrieves' and identifies exact sources (BBC News, The Guardian) and scope (nine topic categories). It also describes the return structure and sort order, and distinguishes itself from siblings by being the only news tool and explicitly contrasting with web_url_reader.

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

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

The description provides explicit when-to-use guidance ('Use this tool when an agent needs current news...') and clear when-not-to-use guidance with an alternative ('Do not use this tool to read the full content... use web_url_reader instead', 'Do not use when news from sources outside BBC News and The Guardian is required'). This goes beyond implied usage.

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

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

With no annotations, the description carries the full burden. It discloses important limitations (no JavaScript execution, won't work with paywalled/login-protected/SPA pages) and describes the transformation (stripping HTML/boilerplate). It omits error/status behavior, but this is a read-only fetch tool and the disclosures are substantial.

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

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

The description is a single well-organized paragraph: primary function, outputs, usage rationale, alternatives, and limitations. Every sentence adds value, and the core purpose 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 no output schema and no annotations, the description compensates by listing return fields (title, meta description, word count, body text) and highlighting limitations. It gives an agent enough context to select and invoke the tool correctly, even covering integration with web_news_headlines.

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 detailed descriptions for each parameter including defaults and constraints. The tool description itself does not add parameter-level meaning 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 uses a specific verb ('fetches') and resource ('public web page'), explicitly lists outputs (title, meta description, word count, main body text), and differentiates from sibling 'web_news_headlines' by cautioning not to use it for headline discovery. This clearly 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?

Provides explicit when-to-use ('when an agent needs to read the content of a specific web page or article URL'), concrete examples, and an explicit when-not-to-use ('Do not use this tool to discover current news headlines — use web_news_headlines instead'). It even instructs to pass article URLs from web_news_headlines to this tool.

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