MCPFax Public-Data Utility API

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

Annotations already cover read-only/idempotent safety. The description adds critical behavioral context: it's a paid call ($0.002 USDC via x402) and unpaid calls return a payment challenge, not data. This is significant for agent invocation.

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 front-load the purpose, then source and payment. Every clause carries information; no fluff.

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 schema and annotations cover safety and params, the description adds source, costing, and payment behavior. It adequately conveys return type (IATA/ICAO by distance) despite 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?

All four parameters have schema descriptions with examples, so description adds no additional parameter semantics. The phrase 'Coordinates → nearest airports' merely aligns with the lat/lon fields already documented.

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+resource: coordinates map to nearest airports with IATA/ICAO codes and distance. It distinguishes from sibling tools like geocode/reverse_geocode by focusing on airports.

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 implies usage context: when you have coordinates and need nearest airports. It doesn't explicitly mention exclusions or alternatives, but the purpose 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 readOnly, openWorld, idempotent, and non-destructive behavior. The description adds valuable context by disclosing the $0.001 USDC cost per call and the fact that an unpaid call returns a payment challenge instead of data, plus the equivalent HTTP route and 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 three sentences: first states purpose, second covers source and cost, third provides an equivalent HTTP route. Every sentence earns its place, and 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?

Given the tool's simplicity, no output schema, and strong annotations, the description covers the essential context: what data is returned, the source, the payment requirement, and the unauthorized-call behavior. It could mention response format or limitations, but the core context is 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?

Schema description coverage is 100%, so the schema already documents all three parameters. The description only vaguely references 'by coordinate' and does not explain the relationship between q and lat/lon or any precedence rules, adding minimal 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 returns US & European AQI and pollutant concentrations by coordinate, which distinguishes it from siblings like v1_weather or v1_geocode. However, it lacks an explicit verb and omits the place-name parameter (q) that the schema supports.

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 for air quality data and includes an important note about payment costs and the unpaid-call behavior. It does not explicitly state when to use this tool over alternatives or mention that v1_weather is for weather, so guidance remains implied rather than direct.

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 a critical behavior beyond annotations: 'Costs $0.001 USDC per call via x402 on Base — an unpaid call returns the payment challenge, not data.' This adds valuable context that readOnlyHint/idempotentHint do not cover, such as the payment requirement and the challenge response 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 front-loaded with the primary purpose. Each sentence adds distinct value: purpose, data source, payment/challenge behavior, and the equivalent HTTP route. No redundancy exists.

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 computational tool with no output schema, the description covers all essential aspects: the two operation modes, holiday handling, country parameter (via schema), payment behavior, and source. An agent can confidently decide when and how to invoke this tool.

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

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

The input schema provides 100% coverage with descriptive text and examples for all four parameters. The description summarizes the two modes but does not add syntactic detail beyond what the schema already documents. This aligns with the baseline of 3 when schema coverage is high.

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: 'Count business days in a range, or add/subtract N business days, skipping weekends & holidays.' This specific verb+resource combination distinguishes it from sibling tools like v1_holidays, which only deals with holiday dates.

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 outlines two usage modes: counting within a range (start/end) and offsetting by a number of business days (start/days). It clearly conveys when to use the tool, but it does not mention alternative tools or exclusions, 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 declare readOnlyHint and idempotentHint, but the description adds critical behavioral context: costs $0.003 USDC via x402, unpaid calls return a payment challenge instead of data, and data source is eCFR (GovInfo). 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?

Two compact sentences, front-loaded with purpose, then essential cost/source details. Every sentence earns its place; 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?

No output schema exists, but the description states it returns 'text', which is adequate for a simple fetch tool. It covers cost, payment failure behavior, and source. Lacks explicit response format but sufficient for the tool's simplicity.

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 descriptions and examples for all parameters. The description only generically mentions 'citation' and adds no extra meaning 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?

States specific verb 'Fetch' and resource 'Code of Federal Regulations text for a citation', with scope 'current'. The domain is distinct from sibling tools, making it clear what this tool does.

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 purpose implies use for CFR text queries, but there is no explicit guidance on when to use this vs alternatives or when not to use it. No exclusions or alternative tool references are provided.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, and no contradiction exists. The description adds significant non-obvious behavioral context: the per-call cost of $0.001 USDC, the x402 payment mechanism on Base, and that an unpaid call returns a payment challenge rather than data. This goes well beyond the annotations and is critical for correct invocation.

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 front-loaded with the core mapping, then cost and route. Every clause adds unique value: what the tool returns, the data source, the payment behavior, and the equivalent HTTP route. No fluff 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 simple lookup tool with one parameter and no output schema, the description covers all essential context: output fields, data source, cost, authentication/payment behavior, and an alternative access route. It is self-sufficient for an agent to decide whether and how to invoke 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?

The schema already provides 100% coverage of the single parameter (q) with an example, so the baseline applies. The description's arrow notation ('Name/ISO code → ...') reinforces the parameter's meaning but adds no additional format details or 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 clearly identifies the resource (country) and the transformation (Name/ISO code → currency, capital, calling code, languages, flag), which distinguishes it from sibling tools like v1_geocode or v1_timezone. However, it lacks an explicit verb like 'lookup' or 'retrieve,' relying on a metadata label and arrow notation, so it falls just short of the 5-level specificity.

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 via the mapping and mentions the payment requirement and HTTP route, but it does not explicitly state when to prefer this over alternatives or list exclusion scenarios. The sibling context is external; the description itself provides no direct when-to-use vs. when-not-to-use guidance.

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

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

Annotations already cover read-only, idempotent, non-destructive behavior. The description adds valuable context beyond annotations: payment cost ($0.001 per call), payment mechanism (x402 on Base), the behavior of unpaid calls (return payment challenge, not data), and data source. This is transparent about the cost and failure mode.

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, dense sentence that packs purpose, source, cost, payment behavior, and HTTP route without any fluff or repetition. Every element earns its place and it is front-loaded with the core purpose.

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

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

For a simple read-only price lookup with two well-documented parameters and rich annotations, the description covers all essential aspects: what it does, data source, cost, payment behavior, and alternative HTTP route. No output schema is needed for this straightforward 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 both parameters (symbol, vs) are documented with examples in the schema. The description adds no additional parameter-specific meaning beyond the schema, 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 verb and resource: 'Spot price for a crypto asset in a fiat/crypto quote currency.' It distinguishes from siblings by naming 'crypto' and sources (Coinbase/CoinGecko), clearly differentiating it from v1_fx or v1_stock_quote.

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 is implied by the purpose (crypto spot price), but there is no explicit guidance on when to prefer this over alternatives like v1_fx or v1_stock_quote, nor any exclusions for non-crypto assets. No when-not guidance is provided.

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

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

Beyond the readOnlyHint and idempotentHint annotations, the description discloses critical behavioral traits: each call costs $0.001 USDC, requires x402 payment on Base, and an unpaid call returns a payment challenge instead of data. It also identifies the exact HTTP route, adding practical integration knowledge 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?

The description is compact and front-loaded with the core purpose ('DNS lookup'), followed by equally necessary operational details: source, cost, payment behavior, and HTTP route. Every sentence adds distinct value with 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 tool is simple, the schema and annotations cover parameters and safety, and the description adds cost, source, and error behavior. With no output schema, a slightly more explicit explanation of what response format to expect would improve completeness, but 'Resolve DNS records' sufficiently conveys the return type for most use cases.

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

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

The input schema already provides 100% parameter coverage with descriptions for both 'name' and 'type', including an example and default value. The tool description does not add any additional parameter semantics beyond what the schema already states, 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 resolves DNS records via DNS-over-HTTPS, using a specific verb ('Resolve') and resource ('DNS records'). It distinguishes this tool from sibling data-lookup tools by naming the unique DNS functionality and the underlying DoH source.

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 operational context: it names the source (Google/Cloudflare DoH), states the cost and payment requirement via x402 on Base, and warns that unpaid calls return a payment challenge rather than data. It does not explicitly mention alternatives or exclusions, but the use case 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?

Beyond the annotations (read-only, idempotent, non-destructive), the description discloses that the tool costs $0.003 USDC per call via x402 and that unpaid calls return a payment challenge. It also mentions the equivalent HTTP route, adding useful behavioral context not covered 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 compact and front-loaded with the primary purpose. Every sentence provides value: data source, content, payment requirement, payment failure behavior, and equivalent HTTP route. No filler or redundant repetition of schema fields.

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, the schema coverage, and the annotations, the description covers key operational aspects: what data it returns, the source, cost, and payment behavior. It does not explain the return format, but no output schema is present, and the description's core details are sufficient for basic 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 input schema already provides 100% coverage with descriptions and examples for all parameters (q, field, limit). The tool description adds no additional parameter-specific meaning, so the baseline score of 3 is appropriate as the schema fully handles parameter semantics.

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

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

The description clearly identifies the tool as retrieving FDA drug label information from openFDA, specifying content areas (uses, warnings, dosage). It is specific enough to distinguish from sibling tools, though it lacks an explicit verb like 'retrieve' or 'search'.

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 context about the data source and payment model but does not explicitly state when to use this tool versus alternatives. No exclusions or alternative tools are mentioned, leaving usage guidance implied rather than 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 read-only, open-world, idempotent, and non-destructive behavior. The description adds valuable extra context: cost ($0.002 USDC via x402 on Base), failure mode if unpaid (returns payment challenge, not data), and the equivalent HTTP route. This goes beyond annotations and helps the agent anticipate 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 two sentences, front-loaded with the purpose, then cost and route. Every sentence earns its place with no redundant 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?

This is a simple two-parameter lookup tool with full schema annotations. The description covers purpose, source, cost, payment failure mode, and HTTP route. The term 'time series' adequately implies the return format, and the tool is unmistakable among siblings.

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

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

The schema provides 100% coverage for both required parameters, including descriptions and examples ('US', 'NY.GDP.MKTP.CD'). The description does not add parameter-level detail beyond what the schema already contains, so the baseline 3 applies.

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

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

The description clearly states the tool's function: it provides World Bank indicator time series for a country (GDP, unemployment, etc.). It names the resource (World Bank Open Data) and is specific enough to distinguish it from sibling tools, none of which cover economic indicator time 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 gives clear context: use it for country-level World Bank economic indicators. It implies when to use it (e.g., when needing GDP or unemployment data) but does not explicitly mention alternatives or exclusions. The cost and payment note also provide practical 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?

The annotations already declare readOnlyHint, openWorldHint, idempotentHint, and no destructiveness. The description adds substantial extra behavioral context: the $0.001 USDC cost per call via x402 on Base, that an unpaid call returns the payment challenge rather than data, and the equivalent HTTP route. This is beyond the annotations, revealing a critical payment requirement and response 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 three sentences, each serving a distinct purpose: the primary function, the data source, and the cost/payment behavior. No redundant words or filler; it is front-loaded with the core purpose. This is an exemplary concise 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?

The tool has no output schema, so the description assumes some burden for explaining what the caller receives. It does not describe the response structure, but it does specify the data source and that paid calls return data (while unpaid calls return a challenge). For a simple 3-parameter read-only tool, this is nearly complete; the missing return format 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?

The input schema provides 100% coverage with descriptions for all three parameters, including the default for amount and the comma-separated format for to. The description's mention of 'optional amount conversion' adds negligible extra meaning beyond the schema. Therefore, the 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 identifies the resource as currency exchange rates with optional amount conversion, sourced from ECB/Frankfurter. This distinguishes it from sibling tools like crypto_price or stock_quote, which cover different asset classes. The verb+resource structure ('Reference FX rates (ECB)') makes the purpose explicit.

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 context (reference rates, source) but does not explicitly state when to use this tool over alternatives or when not to use it. There is no mention of alternatives like crypto_price or unit_convert, so the guidance is implied by the resource type rather than explicit. This gives a score of 3.

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

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

Despite annotations already indicating read-only, idempotent, and non-destructive behavior, the description adds valuable behavioral context: the data source (Open-Meteo/Nominatim), the cost per call in USDC, the x402 payment mechanism, the behavior of unpaid calls (returns payment challenge, not data), and the equivalent HTTP route. This goes well 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?

The description is compact, with three sentences that each add distinct value: the core direction, the source/cost/payment behavior, and the HTTP route. There is no filler or repetition, and the main 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?

For a straightforward geocoding tool, the description covers the essential context: what it does, the source, the cost model, and the failure mode. The schema documents all parameters, annotations document safety, and no output schema exists. Nothing critical 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 already provides descriptions for all three parameters (q, count, country) with examples, giving 100% coverage. The description adds no additional parameter-specific information beyond the schema, so it meets the baseline but does not exceed it.

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 a place name to coordinates, country, and timezone with the direction explicitly shown as 'Place name → coordinates, country, timezone'. The title 'Forward geocoding' directly contrasts with the sibling 'v1_reverse_geocode', providing unambiguous purpose.

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

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

The description gives clear context for when to use this tool: when you have a place name and need geographic data. It implicitly distinguishes from reverse geocoding by using 'Forward'. However, it does not explicitly mention alternatives or when-not-to-use, so it misses the full 'when to use vs alternatives' guidance.

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

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

The description adds significant behavioral context beyond the annotations: the data source (Nager.Date), the cost per call ($0.001 USDC via x402 on Base), and crucially that an unpaid call returns a payment challenge rather than data. This is essential for the agent to understand failure modes and prerequisite payment requirements.

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

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

The description is concise and front-loaded with the core purpose, followed by critical cost and payment details. The slight redundancy of repeating 'Public holidays' twice is a minor flaw, but each sentence adds useful 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 simple 2-parameter tool with no output schema, the description covers purpose, source, cost, payment behavior, and an equivalent HTTP route. It does not describe the return format, but the tool is simple enough that 'public holidays' implies a list of holiday items, and annotations cover safety.

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 full descriptions for both parameters (country as ISO-3166 alpha-2, year with default current). The description adds no additional parameter semantics beyond what the schema already covers, landing at 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 clearly states the tool provides 'Public holidays for a country & year,' which identifies the resource and scope. It lacks an explicit verb like 'get' or 'list,' but the purpose is unambiguous and distinct from sibling tools such as v1_business_days.

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

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

The usage context is implied: if you need public holidays for a country and year, this is the tool. There is no explicit mention of when to use it over alternative tools, nor any exclusions or alternative tool references.

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 provide readOnly/idempotent/openWorld hints, and the description goes beyond them by disclosing the $0.002 USDC cost via x402 and explicitly warning that an unpaid call returns a payment challenge rather than data. This is valuable behavioral context that the structured annotations do not convey, such as payment gate behavior. No contradictions exist.

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, with two sentences, and packs source, cost, failure behavior, and HTTP route into the second sentence. The first phrase 'ICD-10-CM search:' is redundant with the title, which is a slight inefficiency, but overall it is well-structured and front-loaded with the core purpose.

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

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

For a simple search tool with 3 optional parameters and no output schema, the description covers the essential context: purpose, source, cost, payment behavior, and equivalent HTTP route. It does not describe the return data structure, but given the absence of an output schema and the readOnly/openWorld annotations, this is a minor gap. The description is sufficiently complete for an agent to select and 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 coverage is 100%, with each parameter (q, code, maxList) already having descriptions and examples. The description's phrase 'by term or code' loosely maps to q and code, but it adds no new semantic detail beyond what the schema provides. Baseline score of 3 is appropriate since the schema carries the parameter documentation 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 clearly states 'Search ICD-10-CM diagnosis codes by term or code' with a specific verb and resource. It distinguishes itself from sibling tools by focusing on medical diagnosis codes and name-dropping the NLM Clinical Tables source. The title and first phrase are slightly redundant but the core 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?

Usage is implied by describing the search function and source, but no explicit guidance is given about when to choose this tool over siblings like v1_drug_label or v1_naics. It does not state exclusions or alternatives. The description makes clear it is for ICD-10-CM diagnosis codes, so a user can infer when to use it, but it lacks explicit when-to-use vs alternatives guidance.

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

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

Annotations declare readOnly/idempotent safety. Description goes beyond by disclosing the paid nature ($0.002 USDC) and the fact that unpaid calls return a payment challenge, which is critical behavioral information not captured in 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, each providing distinct value: core function, data source, and payment behavior. No redundancy or fluff.

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 4-parameter calculator with no output schema, the description covers purpose, data origin, payment behavior, and HTTP equivalent. It doesn't detail return format, but that's not required. Slight gap: no mention of default year behavior beyond schema.

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

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

Schema already covers all four parameters with descriptions (100% coverage). The description adds only broad references (e.g., 'amount between years') and doesn't introduce new param 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?

Description states a specific action: 'Adjust an amount between years using CPI' and clarifies scope ('any country, not just US'), clearly distinguishing this from unit conversion or financial 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?

No explicit 'when to use' or alternative tools are mentioned. It provides context like 'any country' and 'World Bank CPI' but doesn't guide selection versus sibling tools such as v1_unit_convert or v1_econ_indicator.

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 the per-call cost, the x402 payment mechanism, and the behavior of unpaid calls (payment challenge instead of data). This adds valuable behavioral context that annotations alone do not cover.

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 efficiently pack purpose, data source, cost, payment behavior, and HTTP route. Every clause adds value without redundancy, and 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 a simple one-parameter read-only tool with no output schema, the description covers the essential context: what it does, where data comes from, cost, and failure mode. The payment challenge is critical and well disclosed. Missing response format is acceptable given the simple transformation.

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 the single 'ip' parameter with type and example (100% coverage). The description only repeats the high-level transformation ('IP address → location, ASN, ISP') and adds no additional syntax or format details beyond the schema, so baseline 3 applies.

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

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

The description clearly states 'IP address → location, ASN, ISP', providing a specific verb and resource that distinguishes this from siblings like geocoding or weather. The title and opening phrase align, and the tool's unique focus on IP addresses 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 gives clear context: it is for IP geolocation. It also discloses the payment requirement and that unpaid calls return a challenge, which is essential usage guidance. Though it doesn't explicitly name alternatives, the domain is distinct enough that the 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?

Beyond the annotations (readOnly, openWorld, idempotent, non-destructive), the description adds critical behavioral details: a $0.002 USDC cost per call via x402 on Base, and that an unpaid call returns a payment challenge rather than data. This is significant operational context that annotations alone do not convey.

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

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

The description is three sentences, each carrying distinct value: what the tool does, the source, the cost/payment behavior, and the equivalent HTTP route. It is front-loaded with the core purpose and contains 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 simple lookup tool with two optional parameters and no output schema, the description covers the key context: purpose, source, cost, payment failure mode, and HTTP equivalent. The openWorldHint and readOnlyHint are already in annotations, so the description need not repeat them. The absence of output schema details is acceptable given the tool's simplicity.

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 full descriptions for both parameters ('q' and 'lei') with examples, so schema coverage is 100%. The description only restates that lookups can be done by LEI code or entity name, adding no additional parameter-specific semantics 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 starts with 'LEI lookup' and specifies 'Legal Entity Identifier record by LEI code or entity name.' It names the concrete resource (LEI records) and the two query modes, distinguishing it from the sibling data-lookup tools. The source 'GLEIF' adds further specificity.

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 states the tool is used to look up an LEI record by LEI code or entity name, and the reference to GLEIF gives context. It does not explicitly list alternatives or when-not-to-use scenarios, but the query modes imply the intended use cases clearly enough.

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 idempotent, and the description adds significant behavioral detail: the $0.002 USDC per-call cost via x402 on Base, and that an unpaid call returns a payment challenge rather than data. This is essential runtime behavior not derivable from annotations or schema.

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

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

The description is a single, front-loaded sentence that covers purpose, modes, source, cost, and payment behavior—all with zero redundancy. It is information-dense without being verbose, and the structure leads with the core functionality.

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's mention of return content (title, hierarchy, children) is valuable, and the payment challenge detail is crucial. However, it does not specify behavior when both parameters are provided or when neither is supplied, leaving a gap in understanding edge-case interactions.

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 both 'q' and 'code' with examples, but the description maps each parameter to its specific output semantics: 'code → title, hierarchy, children; or keyword search'. This adds contextual meaning beyond the schema field descriptions, clarifying what each parameter accomplishes.

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

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

The description clearly states the tool performs a 'NAICS lookup' and specifies the two modes: code-to-title/hierarchy/children and keyword search. The verb+resource pairing is unambiguous, and the specific output details distinguish it from all unrelated 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 conveys when to use the tool (for NAICS lookups) and includes the source and cost model, which is useful contextual guidance. It does not explicitly exclude alternatives, but no sibling covers NAICS, so this is sufficient. The lack of explicit 'when not to use' is a minor gap.

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 read-only and idempotent behavior, and the description adds valuable context such as the $0.001 USDC cost, x402 on Base payment mechanism, and what happens on unpaid calls. This goes beyond the annotations, though it doesn't detail other potential behaviors like return 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 concise and front-loaded, conveying purpose, source, cost, payment behavior, and HTTP route in a compact, well-structured format. Every sentence adds value 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 simple lookup tool with rich annotations, the description covers purpose, cost, and payment failure behavior. It lacks mention of return format (no output schema exists) and does not specify behavior when both parameters are provided, but overall it is sufficiently complete for basic 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?

The schema provides 100% coverage for both parameters (`ip` and `domain`) with descriptions and examples. The description only repeats the domain/IP scope without adding new semantics, so it matches 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 clearly identifies the tool as an RDAP-based whois lookup for structured domain/IP registration data, which distinguishes it from sibling tools like DNS or IP geolocation. However, it does not explicitly name alternatives or provide a direct comparison, so it misses the top score.

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 for getting registration data and explicitly discloses the payment requirement and failure mode for unpaid calls. It does not, however, provide guidance on when to use this tool versus alternative tools or mention 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds significant behavioral information: the call costs $0.001 USDC via x402, an unpaid call returns a payment challenge rather than data, and the underlying data sources are Nominatim and BigDataCloud. This goes well 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?

The description is a single, concise sentence that front-loads the core purpose, then efficiently adds payment details and an equivalent HTTP route. Every clause provides actionable information without redundancy.

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

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

With no output schema, the description carries the burden of explaining return values and does so by stating the result is the 'nearest address.' It also covers purpose, data sources, cost, payment failure behavior, and an HTTP route, making it fully adequate for a simple two-parameter 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?

Both parameters (lat, lon) are fully documented in the schema with descriptions and examples, providing 100% coverage. The description adds no extra parameter syntax or format details beyond the general 'coordinates' mention, 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 clearly states the tool performs reverse geocoding with a specific verb and resource: 'Coordinates → nearest address.' It explicitly labels it 'Reverse geocoding,' distinguishing it from the likely sibling v1_geocode (forward geocoding).

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

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

The description gives clear context: this tool is for converting coordinates to an address, which implies forward geocoding (address to coordinates) belongs to v1_geocode. However, it does not explicitly name an alternative tool or state when not to use this tool, stopping 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?

The description discloses cost ($0.001 USDC), payment challenge behavior, and direct fetch source. These details go beyond the readOnlyHint and idempotentHint annotations, providing critical operational context that affects real usage.

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 main action, followed by cost and route details. Every sentence adds value without redundancy.

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

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

For a simple tool with one parameter, the description covers purpose, source, cost, and failure mode. It does not explicitly describe the return format, but given no output schema and the straightforward nature of fetching robots.txt/llms.txt, it is complete enough.

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 'url' with description and example. The tool description adds no additional parameter semantics, but none are needed given the schema's clarity.

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: 'Fetch and parse a site's robots.txt and llms.txt.' It uses specific verbs and resources, making it distinct from sibling tools like v1_dns or v1_geocode.

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 what the tool does and even notes the payment requirement and equivalent HTTP route. It does not explicitly mention alternatives or when not to use it, but the uniqueness of the tool makes usage intuitive.

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 read-only, idempotent, and non-destructive behavior. The description adds valuable behavioral context: the $0.003 USDC fee via x402 on Base and that unpaid calls return a payment challenge instead of data. This is crucial for an agent to understand the side-effect of payment and failure mode, going 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 compact yet informative, covering purpose, source, cost, payment behavior, and an HTTP route in four sentences. Each piece contributes essential context, though the HTTP route is somewhat redundant given tool name and description. Overall, it is well-structured 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?

The tool has moderate complexity with two distinct modes and no output schema. The description mentions the modes but does not explain how parameters interact (e.g., what happens if both cik and concept are provided), nor the structure of the returned data. While annotations and schema cover safety and parameters, the missing details on parameter combinations and return format leave moderate 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?

The input schema provides descriptions and examples for all four parameters (cik, ticker, concept, taxonomy), achieving 100% schema coverage. The description does not add extra semantic detail about parameter interactions or the two operational modes (company vs. concept). It stays at the baseline 3 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 clearly identifies the tool as providing SEC EDGAR company facts, with two specific modes: company profile + recent filings, and XBRL financial facts for a concept. It explicitly names the data source (SEC EDGAR) and distinguishes from all sibling tools, none of which cover SEC-specific company data.

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

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

The description establishes clear context: it's the tool for SEC EDGAR company data, and there is no competing sibling tool for this specific purpose. It does not explicitly state when to avoid using it, but the niche is so well-defined that the intended use case is obvious. The cost and payment mechanism also clarify usage behavior.

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 read-only and idempotent hints from annotations, the description discloses that unpaid calls return a payment challenge rather than data, along with the $0.001 cost and Yahoo Finance source. This adds operational transparency not present in 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: the first defines the purpose and source, the second covers cost, payment behavior, and the alternative HTTP route. Every sentence provides necessary information without redundancy.

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

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

For a simple tool with a single parameter and robust annotations, the description covers critical operational behavior, including payment failure mode. It lacks output structure detail, but no output schema exists and 'key stats' gives a reasonable indication.

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 fully documents the single 'symbol' parameter with an example ('AAPL'), achieving 100% coverage. The description adds no additional parameter semantics, 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 it provides a delayed quote and key stats for equities, ETFs, and indices, which clearly differentiates it from siblings like v1_crypto_price and v1_fx. The resource type and scope are precisely defined.

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 contextual details such as cost and payment behavior but does not explicitly state when to use this tool over alternatives. There is no mention of exclusions or specific use cases beyond being a stock quote endpoint.

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

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

Annotations already declare readOnlyHint and non-destructive. The description adds valuable context about the $0.001 USDC cost per call via x402 on Base and the behavior that unpaid calls return a payment challenge rather than data, which goes 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?

The description is reasonably concise, front-loading the core purpose before adding source, cost, and HTTP route details. The first sentence repeats the title but expands with solar noon and day length, so it 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 covers purpose, data items, source, cost, and HTTP route, which is helpful. However, it omits critical usage details like the precedence between q and lat/lon and the expected response format (no output schema exists). These gaps make the description incomplete for a fully autonomous agent.

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

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

Although schema descriptions cover each parameter individually (100% coverage), the description does not clarify that q is an alternative to lat/lon, nor that at least one of these should be provided. The phrase 'by coordinate' hints at lat/lon but ignores q, leaving the mutual relationship unclear.

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 what the tool returns (sunrise, sunset, solar noon, day length) by coordinate. However, it lacks an explicit verb like 'Get' or 'Compute' and does not differentiate from siblings like v1_weather that may also provide sun times.

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 for solar data by coordinate, but it does not explicitly state when to use this tool versus alternatives, nor does it mention any excluded cases. No guidance is given about choosing between q and lat/lon.

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 read-only and idempotent annotations, the description adds crucial behavioral details: the Open-Meteo source, the exact cost per call (USDC on Base), the payment challenge behavior for unpaid calls, and the equivalent HTTP route. 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 compact and front-loaded: it leads with purpose, then source, cost/payment behavior, and HTTP route. Every sentence adds distinct value with no fluff.

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 2-parameter tool with no output schema, the description provides sufficient context: input type, output fields, source, cost, and payment failure behavior. It is complete for an agent to invoke the tool correctly.

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

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

The input schema already covers 100% of parameters with descriptions and examples for lat and lon. The description adds no additional parameter meaning, 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?

The description clearly states the tool converts coordinates to IANA timezone, UTC offset, and local time. It distinguishes itself from sibling geolocation tools by explicitly naming the timezone-specific output, and includes source and cost context.

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 the tool is for coordinates-to-timezone lookups. It does not explicitly mention when not to use it or name alternative tools, but the context is clear enough for correct 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?

Beyond the annotations (readOnlyHint, idempotentHint, etc.), the description adds critical behavioral details: deterministic edge compute, the exact cost of $0.001 USDC per call, and the behavior of unpaid calls (returns payment challenge). These insights are essential for an agent to handle the tool correctly and do not contradict any 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 succinct (approximately 40 words) and front-loaded with the core purpose, followed by a compact list of supported unit categories and essential payment/route details. Every sentence contributes valuable information without redundancy.

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

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

For a simple tool with three well-documented parameters and strong annotations, the description covers purpose, supported categories, payment behavior, and an alternative HTTP route. It does not mention the output format, but given the tool's simplicity and the absence of an output schema, this is not a significant 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 schema already provides 100% coverage with clear descriptions and examples for each parameter (value, from, to), so the description does not need to add parameter-level detail. No additional semantics are provided, aligning with the baseline score 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 clearly states 'Convert between units' and lists supported categories (length, mass, volume, etc.), making the tool's function unambiguous. This distinguishes it from sibling data-lookup tools like v1_weather or v1_country.

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 the tool by noting the payment requirement and that unpaid calls return a challenge rather than data. It does not explicitly state when not to use it or name alternatives, but no sibling tool overlaps with unit conversion, so this is adequate.

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 read-only, idempotent, open-world, non-destructive. Description adds critical behavioral details: the call costs $0.001 USDC via x402, and an unpaid call returns a payment challenge rather than data. It also notes the source (edge compute + DoH), which gives context about reliability without contradicting 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, front-loaded with the purpose. It includes useful operational details (cost, payment challenge, HTTP route) without significant redundancy, though source details could be trimmed.

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, and the description doesn't specify the return format or fields. It does state what aspects are checked (syntax, MX/deliverability, disposable flag) and the failure mode for unpaid calls, but agents are left to infer the response structure. Given a single simple parameter, it's mostly adequate but incomplete regarding return value.

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 'email' is fully described in the schema with an example. The tool description doesn't add parameter-specific semantics beyond the schema, so baseline 3 applies.

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

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

The description clearly states the tool validates emails via syntax check, live MX/deliverability, and disposable-domain flag. It distinguishes itself from sibling tools like v1_dns or v1_country by specifying its unique function.

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 for email validation but doesn't explicitly state when to use vs alternatives. It provides cost and payment behavior, which is useful context for deciding whether to invoke, but lacks explicit exclusions or alternative tool 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 read-only and idempotent behavior. The description adds critical behavioral details: cost per call, payment challenge on unpaid calls, NHTSA source, and equivalent HTTP route. This goes 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 concise and front-loaded, covering purpose, source, cost, payment behavior, and route in one efficient sentence. No superfluous 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 simple 2-parameter read-only tool, the description covers purpose, scope, source, cost, and failure behavior. Missing return format details, but with no output schema and strong annotations, this is acceptable.

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% (vin and year both described, with year as 'Model year hint'). The description adds no additional parameter detail, so the baseline score 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 and resource: 'Decode a US-market Vehicle Identification Number.' This clearly distinguishes it from sibling tools, none of which relate to VIN decoding.

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 context such as US-market scope, NHTSA source, and cost. Usage is implied when a VIN needs decoding, but no explicit alternatives or exclusions are mentioned beyond the US-market qualifier.

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, idempotent, non-destructive. The description adds key behavioral details: cost per call ($0.001 USDC), payment mechanism (x402 on Base), and the consequence of unpaid calls. This goes beyond 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: main purpose, source, cost/payment behavior, and HTTP route. No filler, all informative.

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 simple, annotations and schema are thorough. The description adds critical payment context and source, making it complete for an agent to decide to call. Return format not specified, but output schema absent, 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?

Schema covers all four parameters with descriptions and examples (100%). The description's mention of 'coordinate or place' and 'multi-day forecast' aligns with parameters but adds no new information 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 provides weather forecasts with current conditions and multi-day forecast, and distinguishes from siblings like v1_weather_alerts by focusing on general forecast data rather than alerts.

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 inputs by coordinate or place, and importantly discloses that unpaid calls return a payment challenge instead of data, guiding proper use (must pay). It doesn't explicitly name alternatives, but the sibling list provides 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 mark it read-only and non-destructive. The description adds crucial behavioral context: the $0.002 USDC cost per call via x402, and that an unpaid call returns a payment challenge instead of data. This goes beyond the annotations, helping the agent handle payment requirements.

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

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

The description is three sentences, front-loaded with the main purpose, and every sentence adds value: purpose, source, and cost/payment behavior. No redundancy or fluff.

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 the data source, cost, and payment challenge, and gives an HTTP equivalent. While no output schema exists, the description does not detail the response format, but for a simple alerts lookup it is largely sufficient. Slight gap on response structure.

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?

All 3 parameters (q, lat, lon) have schema descriptions (100% coverage), so the schema provides full meaning. The description only adds that coordinates are for the US, which is a minor extension. Baseline 3 applies.

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

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

The description states the tool returns active NWS watches/warnings for a US coordinate, naming the specific resource (NWS alerts) and scope (US coordinate). It distinguishes from sibling tools like v1_weather by specifying 'watches/warnings' rather than general weather.

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 context that this is for active alerts, sourced from NWS, and mentions cost/payment behavior. However, it does not explicitly compare with alternative tools or state when not to use, so usage is implied rather than 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 confirm read-only, idempotent, non-destructive behavior. The description adds important context beyond this: the $0.001 USDC cost, the x402 payment mechanism on Base, and that unpaid calls return a payment challenge rather than data. This is valuable behavioral disclosure that annotations do not cover.

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, front-loaded with the core purpose, followed by source, cost, payment note, and route. Every sentence provides distinct information with no redundancy or fluff.

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 two-parameter lookup with complete schema and safety annotations, the description covers purpose, source, cost, and error behavior. It lacks explicit return format details, but the phrase 'Lead summary/extract' indicates the output. Minor gap, but overall adequate.

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 input schema fully documents both parameters with examples. The description does not add additional parameter-level detail, but it does not need to since the schema handles it. 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 the tool provides 'Lead summary/extract for a Wikipedia page', which is a specific verb+resource combination. It distinguishes itself from sibling tools by naming the source (Wikipedia REST) and the route, making its purpose clear.

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 does not explicitly state when to use this tool vs. alternatives, nor give exclusions. However, the context strongly implies use for Wikipedia lookups, and sibling tools cover different domains. This is implied usage, not explicit 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?

While annotations already declare read-only/idempotent safety, the description adds critical behavioral disclosure: the $0.001 USDC cost per call, the fact that unpaid calls return a payment challenge rather than data, and the data source. These are meaningful traits not captured 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 three concise sentences, front-loading the core purpose and adding essential cost/route details without redundancy. 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 read-only lookup tool with no output schema, the description is complete: it explains the mapping, source, cost, payment behavior, and equivalent HTTP route. No critical operational 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% (both 'code' and 'country' are documented with examples). The description adds no param-specific details beyond the schema, which is acceptable per baseline; no gaps need compensating.

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 with a specific verb ('lookup') and resource ('ZIP/postal code → place(s) & coordinates'). It distinguishes itself from likely siblings like v1_geocode by focusing strictly on postal code to place/coordinate resolution.

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 context ('Postal code lookup') but does not explicitly state when to use this tool over alternatives like v1_geocode or v1_reverse_geocode. It provides supplementary details (cost, payment behavior) but no exclusions or alternative tool mentions.

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