Stratalize Intelligence

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

Annotations already indicate readOnlyHint=true and destructiveHint=false. The description goes beyond this by stating it returns current and prior quarter filing pairs with delta summary scaffolding, mentions the source (SEC EDGAR), the required identifier (ticker or cik), and the cost ($0.50 USDC). These are meaningful behavioral details that help the agent understand what to expect, adding value 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 two sentences, front-loading the purpose first, then detailing output, source, requirements, and cost. Every sentence provides necessary information without redundant phrasing. It is compact and efficient, with no wasted words.

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

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

For a tool with no output schema, the description explains what the agent receives: 'current and prior quarter filing pairs with delta summary scaffolding.' It also notes the source and identifier requirement. While the phrase 'delta summary scaffolding' is somewhat vague, it gives a sense of the output structure. Given the simplicity of the tool and the read-only nature covered by annotations, this is reasonably complete, though it could mention specific fields or limitations.

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

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

The schema has two parameters (cik, ticker) with no descriptions in the schema (schema_description_coverage=0%). The description states 'Requires ticker or cik,' which clarifies that at least one is needed, but does not explain the distinction, format, or behavior if both are provided. It adds essential guidance but leaves some ambiguity about the relationship between the two params. This is adequate but not comprehensive, given that the description must compensate for the lack of schema descriptions.

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

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

The description clearly states the tool retrieves institutional 13F-HR holdings changes between quarters, with a specific verb ('get') and resource (13F-HR holdings delta). It explicitly mentions the use case (QoQ holdings change context) and distinguishes from siblings like get_sec_insider_trading by the unique focus on 13F filings. The purpose is unambiguous and specific.

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 an explicit when-to-use scenario: 'Use when comparing institutional 13F-HR filing quarters for QoQ holdings change context.' It clearly defines the condition under which this tool is appropriate. It does not explicitly mention alternatives or exclusions, but the context is specific enough to guide selection among the many sibling tools. Given the clarity, a 4 is appropriate.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful context: data source (SEC EDGAR), pricing, and optional item-code filtering. However, it does not mention rate limits, return shape, or default lookback behavior, leaving room for more transparency.

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

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

The description is three short sentences with the use case front-loaded, followed by source and pricing. Every sentence earns its place and there is no redundant filler.

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

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

For a low-complexity, read-only tool with one required parameter, the core invocation is clear. However, with no output schema, the description only vaguely promises 'metadata' and leaves item-code values and the default lookback unspecified, so it is not fully self-sufficient.

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

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

Schema description coverage is 0%, so the description must compensate. It maps ticker to 'for a ticker,' days_back to 'recent,' and item_codes to 'optional item-code filter hints.' This adds value, but the item-code format and the meaning of 'filter hints' remain vague.

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 (recent 8-K filings from SEC EDGAR) and the behavior (monitoring material issuer events and returning filing metadata). This makes it distinguishable from SEC insider-trading and financials siblings even without explicitly naming them.

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

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

The description opens with an explicit use condition: 'Use when monitoring material issuer events via recent 8-K filings for a ticker.' It does not name alternatives or exclusions, but the stated use case is narrow enough that an agent can determine when to invoke it.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds substantial behavioral context beyond that: it clarifies scope (public mode reference data only), output shape (classification with stage criteria and remediation priorities), gives a concrete example, discloses the source, and states the cost per call ($0.02 USDC). This is rich transparency for a read-only lookup tool.

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

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

The description is longer than a single sentence but every clause earns its place: scope, use case, output values, example, alternative path, source, and cost. The most important scoping information is front-loaded ('Public mode returns... not org-specific scoring'), followed by use guidance and output details. No wasted words.

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

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

For a zero-parameter tool with no output schema, the description is fully self-contained: an agent knows what it does, when to use it, what it returns (with a concrete example), how it differs from org-specific scoring, the source, and the cost. There are no missing pieces that would prevent a correct call or interpretation.

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

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

The tool has zero parameters, and schema coverage is 100% (empty schema). Per the rubric, 0 params earns a baseline of 4. The description doesn't need to add parameter semantics because there are none, and it doesn't attempt to invent any.

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: 'returns FS AI RMF framework reference data' and 'Returns INITIAL, MINIMAL, EVOLVING, or EMBEDDED classification with stage criteria and remediation priorities.' It also differentiates from the org-specific scoring path by explicitly saying 'not org-specific scoring' and 'Connect org MCP for org-specific scoring,' making it distinguishable from the large sibling set.

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

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

Explicitly states when to use: 'Use when assessing an organization FS AI RMF governance maturity stage or preparing a regulatory AI roadmap presentation.' It also gives a clear when-not and alternative: 'not org-specific scoring' and 'Connect org MCP for org-specific scoring.' No inference is needed.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds useful behavioral context: return fields (USD price, unit, observation period), the data source, and the unusual cryptographic settlement receipt. No contradiction with annotations.

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

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

The description is front-loaded with purpose and return values, then covers source and attestation. The only waste is the redundant pricing statement: '$0.02 atomic' and '$0.02 USDC per call' say essentially the same thing twice.

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

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

For a single-enum-parameter read-only tool with no output schema, the description is complete: it names the commodities, return fields, source, and cost model. An agent has enough to select and invoke the tool correctly without further inspection.

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 one parameter is fully enumerated in the schema, and the description simply repeats the same commodity list. It adds slight context about what is returned per commodity but does not substantially deepen the meaning of the parameter beyond the enum.

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

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

States a specific verb and resource: retrieving a spot agricultural commodity price from FRED/IMF series for five named commodities. This is clearly distinguishable from broad siblings like get_commodity_benchmark and commodity-specific peers like get_copper_price_benchmark.

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

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

Explicitly names intended use cases: crop hedging, food cost modeling, and trade exposure agents. It does not explicitly contrast with get_commodity_benchmark or state exclusions, so it stops 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 establish readOnlyHint=true and destructiveHint=false, so no safety warning is needed. The description goes beyond this by disclosing the exact return payload, the interpretation signal ('high consensus...safe for board communications'), the data source, and the per-call cost. This is rich, non-obvious behavioral context.

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

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

The description is front-loaded with the most important use case, then proceeds through returns, an illustrative example, interpretation, source, and cost. Nothing is redundant, and every sentence earns its place without bloating the definition.

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 correctly carries the return-value burden by listing consensus score, sentiment mix, key themes, and platform breakdown. It also adds source and price context. The main completeness gap is the unexplained optional `category` parameter, plus the consensus scale (0–1) is only inferred from the 0.78 example rather than stated.

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

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

Schema description coverage is 0%, so the description must compensate. It does clarify what `topic` can be (vendor, category, trend, business topic) and gives a concrete example. However, the optional `category` parameter is never mentioned or explained, and no value format is given for either parameter, leaving a meaningful gap.

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

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

The description names a specific verb and resource: researching how AI systems characterize a topic across multiple platforms, returning a consensus score, sentiment mix, key themes, and platform breakdown. It clearly distinguishes itself from generic research or benchmark tools by focusing on cross-platform AI consensus, and the concrete healthcare example removes ambiguity.

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 opening 'Use when researching...' is an explicit condition for invoking the tool, and the scope is clear: vendors, categories, trends, or business topics across multiple platforms. However, it does not mention when not to use it or name a sibling alternative (e.g., get_platform_divergence or get_web_research_synthesis), so exclusions are left to inference.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds useful context beyond those: all inputs are optional, it returns a full framework composite, filters narrow the result, and the call costs $3.00 USDC. This gives the agent a clear behavioral model for a safe read operation.

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

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

Two well-structured sentences front-load the use case and output, then cover optional parameters, filtering behavior, and pricing. Every clause earns its place with no filler or repetition.

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

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

The description covers when to use, what it returns, what inputs are available, and the cost. Since there is no output schema, a bit more detail about the snapshot structure would be ideal, but an agent has enough to decide whether to call it and how to pass filters.

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

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

Schema coverage is 0%, so the description must compensate. It names all four parameters (nist_function, state, system_type, institution_type), calls them optional filters, and explains that omitting them returns the full composite. That adds real meaning beyond bare schema property names, though it does not detail the value formats or semantics of each filter.

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 purpose: standing up or auditing an AI governance program and getting one signed snapshot across multiple named frameworks. It clearly distinguishes itself from siblings like get_nist_ai_rmf_requirements, get_eu_ai_act_coverage, and get_colorado_ai_act_requirements by advertising an aggregated composite rather than a single framework.

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

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

The description explicitly says when to use it: when standing up or auditing an AI governance program and needing one signed snapshot. It does not explicitly state when not to use it or name the individual framework siblings as alternatives, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description is consistent with them. It adds useful context such as the per-call cost ('$0.50 USDC per call') and data coverage, but it does not describe return format, data freshness, or update 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?

One tightly worded sentence front-loads the core resource, itemizes the data coverage, names the audience, and states the price. There is no filler or 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?

With no output schema and no parameter descriptions, the description gives the essential data scope and cost but omits return-value structure, parameter mapping, and data-cadence details. It is minimally viable for an unfiltered default call, but not fully complete for focused queries.

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

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

Schema description coverage is 0%, so the description must compensate. It implicitly maps to focus enum values: 'BSA enforcement fine history' aligns with 'enforcement', 'FinCEN SAR filing rates' aligns with 'sar_filing', and 'OFAC SDN counts' aligns with 'ofac'. However, it never names 'focus' or 'institution_type', leaving part of the parameter semantics to inference.

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

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

The description opens with 'AML regulatory benchmarks' and itemizes concrete data categories: 'FinCEN SAR filing rates, OFAC SDN counts and recent additions, BSA enforcement fine history, travel rule thresholds, and compliance staffing benchmarks.' This clearly identifies the resource and its scope, distinguishing it from screening tools like get_ofac_sanctions_screening, though it is phrased as a noun phrase rather than an explicit action verb such as 'retrieves'.

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 audience line 'For compliance agents and financial institution risk officers' gives context, but the description does not explicitly state when to use this tool versus sibling alternatives or provide exclusions. The usage is implied by the content list rather than directly guided.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds useful behavioral context beyond that: it identifies the data source (ASCA and CMS 2024 composite), the per-call cost ($0.02 USDC), and the nature of the returned metrics. No contradiction with annotations.

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

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

The description is front-loaded with usage context, then states outputs, provides an illustrative example, and closes with source and pricing. It is reasonably concise and every sentence adds useful information, though the example is a bit detailed.

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 benchmark tool with two optional string parameters and no output schema, the description covers purpose, outputs, source, pricing, and usage scenarios. However, it lacks parameter value guidance and any description of the returned data structure, leaving an agent to guess valid state and specialty inputs.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'by specialty' and gives 'Orthopedic' as an example specialty, but it never explains the 'state' parameter, valid values, formatting, or whether parameters are optional. This is a significant gap for two undocumented string parameters.

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

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

The description states a specific output ('cost per case medians and revenue mix percentages by specialty') tied to a clear resource (ASC financial performance). It also gives concrete use cases and an illustrative example, making it easy to distinguish from the many generic benchmark siblings.

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

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

It explicitly says 'Use when benchmarking ASC financial performance, evaluating an ASC acquisition, or preparing an administrator board report.' This provides clear context for when to call the tool, though it does not name alternatives or state when not to use it.

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

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

Annotations already mark the tool as read-only and non-destructive. The description adds useful behavioral context beyond that: source is Audit Analytics public aggregate data, and each call costs $0.02 USDC. No contradiction with annotations.

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

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

The description is front-loaded with the use case, then provides the data scope, source, audience, and price in a compact form. The 'Used by CFOs and audit committees' sentence is somewhat redundant with the RFP context, but it does not add significant bloat.

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 adequately specifies the returned benchmark dimensions and data source. The main gap is that it does not clarify how the optional industry input affects results or describe the exact output shape, but the tool is simple enough for an agent to proceed.

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 only 33%, and the description partially compensates by linking annual_revenue_usd to revenue bands and auditor_tier to Big 4 vs national vs regional tiers. However, it gives no guidance on the optional industry parameter, leaving its role and expected format 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?

Description opens with concrete use cases and states exactly what data the tool returns: audit fee benchmarks, total fees, and fees as a percentage of revenue, segmented by revenue band and auditor tier. This clearly distinguishes it from sibling benchmark 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?

Explicit 'Use when benchmarking audit costs, evaluating auditor proposals, or preparing an audit committee RFP' provides clear trigger conditions. It does not name when-not-to-use or an alternative tool, but the use cases are specific enough for selection.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: it states the tool 'fans in' multiple sources and 'degrades per-section on source_unavailable,' which describes partial result behavior. It also discloses the cost ($3.00 USDC per call). These go beyond the annotations and help the agent understand what to expect.

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

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

The description is a single sentence that front-loads the usage context, then lists the aggregated sources, then notes the degradation behavior and required input. It's efficient and free of fluff. The list of sources is a bit long but necessary. Overall, concise and well-structured.

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

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

The description covers the tool's purpose, usage context, aggregation behavior, degradation, cost, and required input. However, it does not describe the optional parameters, which are essential for fine-tuning the query. Additionally, with no output schema, the agent has no idea what the result structure looks like. For a composite tool of this complexity, this is a moderate 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 description coverage is 0%, meaning the description should explain the parameters. It only mentions 'institution_name (required)' and ignores the four optional parameters (aml_focus, asset_size_tier, institution_type, credit_union_asset_tier). While their enum values provide some clues, the description does not clarify their purpose or interaction. This is a significant gap for a tool with 5 parameters.

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

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

The description clearly states the tool's purpose: 'diligencing a bank or financial institution counterparty before onboarding, funding, or transaction approval.' It specifies the resource (bank/financial institution counterparty) and the action (diligence). It also lists the data sources it aggregates, distinguishing it from individual sibling tools like get_bank_regulatory_benchmark or get_aml_regulatory_benchmark, which are single-source tools.

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

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

The description gives explicit when-to-use context: 'before onboarding, funding, or transaction approval.' It does not explicitly state when not to use it or name alternatives, but by listing the fanned-in sources it implies that for a specific source alone, an agent might use the sibling tool. This is reasonable guidance, though not exhaustive.

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

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

With annotations already declaring readOnlyHint=true and destructiveHint=false, the safety profile is covered. The description adds behavioral context by citing the source ('FDIC BankFind synced call report data'), stating the per-call cost ('$0.02 USDC per call'), and giving a concrete output example with benchmark comparisons. It does not mention error handling, pagination, or rate limits, but the added source and cost details go beyond the minimum.

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: immediate use case, then data content, then an illustrative example, then source and cost. Every sentence earns its place—the example clarifies output format, and the cost is essential for agents making cost-aware decisions. No filler or redundancy.

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

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

For a tool with one parameter, no output schema, and annotations covering safety, the description provides a strong context: what data is returned, from what source, at what cost, and a realistic example with peer comparison. It does not specify the exact response structure or how to handle missing banks, but the example and field list make the expected output sufficiently clear 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 coverage for the single parameter bank_name is 100%, including examples ('e.g. JPMorgan, Wells Fargo, First National Bank'). The description does not add parameter-specific guidance, such as whether to use legal names, common trade names, or FDIC certificate numbers. The example in the description ('Midwest Community Bank') reinforces the idea of using a recognizable bank name, but it adds little beyond the schema.

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

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

The description opens with a clear use context ('evaluating a bank for acquisition, partnership, correspondent banking, or competitive analysis') and then specifies the exact data returned: 'FDIC-sourced assets, deposits, capital ratios, loan quality, and peer benchmark positioning.' This goes beyond a generic verb+resource by naming distinct outputs and a data source, which differentiates it from siblings like get_bank_regulatory_benchmark or get_cra_performance_ratings.

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

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

The description explicitly states when to use the tool: 'Use when evaluating a bank for acquisition, partnership, correspondent banking, or competitive analysis in a local market.' It provides clear contexts, but it does not mention when not to use it or name alternative sibling tools, so it falls short of the top score.

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

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

Annotations already mark this tool as read-only and non-destructive. The description adds genuinely useful operational context beyond the annotations: the data source (FDIC call report public aggregates) and the $0.02 USDC per-call cost. It does not mention update frequency or response format, but the annotated safety profile lowers the burden, making this adequate.

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 resource and metric list before adding source, audience, and pricing. Each sentence carries distinct information, with no filler or repetition.

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

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

For a two-parameter tool with no output schema, the description provides the key facts an agent needs: required grouping dimension, the metrics in the returned benchmark, data source, audience, and cost. It lacks a concrete example of the return payload or a note on benchmark vintage, but nothing critical to selecting or invoking the tool 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 description tells the agent the outputs (CET1, NIM, etc.) and that results are grouped by asset size tier, which maps to the required parameter. It does not explain the optional bank_type parameter or the meaning of the tier enum values, though those values are largely self-describing. With 0% schema description coverage, the description only partially compensates.

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 identifies the resource ('bank regulatory capital and financial performance benchmarks'), names specific metrics (CET1, Tier 1 leverage, NIM, efficiency ratio, charge-off rates, loan-to-deposit ratio), and the grouping dimension ('by asset size tier'). It is clear enough to be distinguished from most siblings, but it never explicitly contrasts it with adjacent tools like get_bank_financial_intelligence or get_credit_union_benchmark, so differentiation is implicit rather than stated.

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 intended audience ('bank CFOs, risk officers, and bank analysts') and the 'FDIC call report' source provide clear context for when this bank-benchmark tool is appropriate. There are no explicit exclusions or pointers to alternative tools (e.g., get_credit_union_benchmark for credit unions), so it stops short of a 5.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds useful context: the source (CMS/OIG composite), an illustrative HIGH-risk example, and the $0.02 USDC cost. It doesn't describe response structure or pagination, but the safety profile is already 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 well front-loaded with use cases, then outputs, then a concrete example, then source/pricing. Each sentence serves a distinct purpose; it is slightly wordy but not padded.

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 lists the returned categories and provides an end-to-end example connecting inputs to a risk verdict. It does not specify exact output shape or whether parameters are required, but for a read-only benchmark tool it is adequate for an agent to invoke correctly.

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

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

Schema coverage is only 33%, so the description must compensate. The Cardiology example clarifies that specialty is a practice type and level_4_5_percentage is a percentage (67% vs 48%), but it does not clarify annual_claim_volume units, number format (0-1 vs 0-100), or whether inputs are required. It partially compensates for the low schema coverage but not fully.

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

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

The description opens with explicit use cases (OIG audit prep, RAC review, revenue integrity) and enumerates specific outputs: E/M distribution benchmarks, upcoding risk signals, OIG audit priority themes, and RAC watchlist. This goes well beyond the tool name and clearly distinguishes it from the generic get_*_benchmark family.

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

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

Provides explicit 'Use when' guidance for three distinct compliance scenarios. It does not mention when not to use it or name a specific alternative sibling, but the stated scenarios are specific enough to guide tool selection.

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

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

The annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds the source (BLS CPI), the $0.10 USDC cost, and the useful insight that medical care and housing CPI diverge from headline inflation. However, it does not disclose response format, frequency, regional scope, or any other behavioral detail beyond the annotation baseline.

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

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

The description is moderately sized and every sentence adds value: use cases, domain caveat, illustrative example, source, and price. Starting with 'Use when...' front-loads the most important selection guidance. It is slightly longer than strictly necessary, but there is no filler.

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

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

With no output schema and no required parameters, the description should clarify what the tool actually returns. The example implies YoY CPI figures, but the description does not state units, data vintage, response shape, or whether it returns a single category or a comparison against headline CPI. For low complexity the use-case guidance is strong, but the return contract is left underspecified.

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

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

Schema description coverage is 0%, so the enum carries most of the parameter meaning. The description does add context by referencing 'spending category', 'medical care CPI', 'housing CPI', and 'headline inflation', which partially explains the category parameter. It does not enumerate or define each enum option, including the default all_items, so it only partially compensates for the absence of schema descriptions.

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

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

The description clearly frames the tool as a source of category-level CPI data via 'analyzing inflation exposure by spending category' and the medical care/housing CPI discussion. It does not explicitly say 'retrieves CPI components', but the name, categories, and source make the function clear. It does not explicitly distinguish from sibling get_inflation_benchmark, though 'components' and 'spending category' imply a narrower scope.

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

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

The description begins with explicit use cases: inflation exposure analysis, vendor contract escalation clauses, healthcare/real estate cost benchmarking, and CFO/treasury monetary policy context. It also gives a concrete scenario showing when medical care CPI divergence matters. It does not mention alternatives or exclusions, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds valuable context: the official establishment survey covering 650,000 US worksites, the Federal Reserve usage reference, source attribution, trend classification, and a concrete example. It does not discuss data lag or revisions, but none are safety-critical for a read-only retrieval.

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

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

The description is front-loaded with usage intent, then delivers the return value, source, example, and cost without redundancy. The example is especially efficient, showing the exact shape and interpretation of the data an agent should expect.

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

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

With a single required enum parameter, readOnly annotations, and no output schema, the description fully specifies what the tool returns: employment level, MoM change, YoY change, and trend classification, including a concrete example. An agent has enough information to select and invoke this tool correctly.

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

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

The schema has 0% description coverage, so the description carries some burden for explaining the 'sector' parameter. It says 'by major sector' and gives a Healthcare example, which adds context, but it does not enumerate the allowed sector values or explain options like 'all_private'; the enum schema remains the primary source of parameter meaning.

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

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

The description states a specific resource and action: it returns BLS payroll employment by major sector with MoM change, YoY change, and trend classification. This clearly distinguishes it from sibling labor-market tools like get_bls_inflation_components or get_employment_cost_index.

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

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

The description explicitly lists four use cases: workforce planning benchmarking, industry growth assessment, board reporting context, and talent acquisition timing. It does not explicitly name alternatives or state when not to use the tool, but the use-case framing is strong enough for an agent to route correctly.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context beyond annotations: it reveals the cost ($0.02 USDC per call), the data source (Stratalize brand index), and the exact output shape with an example. It does not contradict the annotations and provides useful operational details like pricing.

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

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

The description is front-loaded with the 'Use when' clause and then specifies returns. The example adds clarity and realism, and the source/pricing lines are short. It is slightly verbose with the interpretive phrase 'competitive signal requiring CMO attention,' but overall each sentence earns its place and the structure is logical.

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 is a simple read-only query with one parameter, the description adequately covers return values, source, cost, and an example. It does not explain the interpretation of 'momentum score' or 'trend direction' beyond the example, but that is acceptable for a benchmark-style tool. No output schema exists, so the description handles the return contract well.

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

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

The input schema only defines brand_name as a string with no description (0% schema coverage), so the description must compensate. It gives an example (HubSpot) implying a company/brand name, but does not clarify naming conventions, accepted formats, or whether aliases are allowed. This partial guidance raises it above a 2 but leaves ambiguity for an agent trying to validate inputs.

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

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

The description clearly states the tool's purpose: monitoring vendor brand trajectory in AI recommendations and week-over-week competitor momentum. It lists the specific output (4-week momentum score, trend direction, weekly movement series) and provides an illustrative example. This distinguishes it from sibling tools like 'get_competitive_displacement_signal' or 'get_ai_consensus_on_topic' by focusing on brand momentum with a named 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 explicitly says 'Use when monitoring a vendor brand trajectory in AI recommendations or tracking week-over-week competitor momentum for a CMO brief,' providing clear usage context. It does not mention alternatives or exclusionary criteria, so it falls short of the full 5 for naming when not to use it, but the use cases are specific and actionable.

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/non-destructive. The description adds useful behavioral context beyond that: it discloses the data source (Stratalize go-to-market composite) and per-call cost ($0.02 USDC), and shows the kind of output values via the example. No contradiction with annotations.

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

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

The key use cases are front-loaded, followed by return content, one illustrative example, and source/cost line. It is compact but information-dense; the example is the only slightly expendable part.

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

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

For a read-only benchmark tool with one required parameter and no output schema, the description gives enough context: when to use, what is returned, an example output, source, and price. It doesn't explicitly explain optional parameters, but the schema covers those.

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

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

Schema covers 67% of parameters; the description reinforces that results are organized 'by industry and GTM motion' but adds little about avg_contract_value_usd beyond the schema's own 'ACV for LTV:CAC calculation' note. The example ('Mid-market SaaS with field sales') loosely hints at ACV and sales-led motion but doesn't clearly map to the enum values.

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 exactly what the tool is for — evaluating sales/marketing efficiency, setting CAC targets, and benchmarking GTM performance — and what it returns (CAC payback ranges, LTV/CAC guardrails, channel efficiency benchmarks). This scope clearly distinguishes it from the many sibling *benchmark* 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?

Opens with explicit 'Use when' triggers tied to workflow context (board review, target setting). It doesn't name when not to use it or alternative benchmark tools, but the use cases are specific enough to guide selection.

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

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

Annotations already signal read-only and non-destructive behavior. The description adds useful operational context beyond annotations: provenance (CBRE and JLL quarterly surveys), update cadence, and a per-call cost of $0.02 USDC. It does not describe response shape, but the annotation coverage lowers that burden.

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

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

Three concise, purposeful sentences: the first front-loads the core function, the second gives source and cadence, and the third adds audience, use case, and cost. There is no filler or redundancy.

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

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

For a simple three-parameter read-only benchmark lookup, the description covers the essential decision factors: what is measured, the source, the cost, and typical use cases. It is not fully complete because it omits the metric's unit/format and doesn't distinguish itself from adjacent CRE benchmark tools, but the lack of an output schema lowers the expectation.

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

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

Schema description coverage is 0%, so the description must compensate. It maps to the three filtering dimensions from the schema—asset class, market tier, and geography—which helps align intent with parameters. However, it does not define the values, defaults, or required-optional semantics beyond what the enum names already imply.

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

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

States the resource precisely: commercial real estate cap rate benchmarks segmented by asset class, market tier, and geography. It lacks an explicit verb like 'returns' or 'provides' and doesn't contrast with adjacent siblings such as get_cre_debt_benchmark, so it stops short of 5.

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

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

Provides clear usage context by naming the intended audience (CRE acquisition teams, asset managers, real estate CFOs) and the use cases (property pricing, portfolio valuation). It does not explicitly state when not to use it or which alternative to prefer, so it is strong but not maximal.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds value beyond those by disclosing the data source (CourtListener 60M+ opinions), the cost ($0.50 USDC per call), and the cryptographic settlement receipt verification workflow. Minor redundancy in pricing disclosure slightly weakens it.

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

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

The core purpose is front-loaded and readable, but the price is stated twice ('$0.50' and '$0.50 USDC per call') and the attestation/verification details add length without helping tool selection or invocation. A tighter single pricing mention would improve it.

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

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

For a tool with no output schema and 0% parameter schema coverage, the description explains return fields well but leaves two of four parameters (limit, date_after) entirely unexplained. It also omits the output format. Given the low structured coverage, the description is not complete enough for an agent to invoke it optimally.

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

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

Schema description coverage is 0%, so the description carries the full burden for parameter meaning. It only implicitly covers 'topic' via 'legal topic' and mentions 'court' as an output field, but does nothing to explain 'limit' or 'date_after' semantics, formats, or constraints. This is a significant gap for a 4-parameter tool.

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: it returns top cases by relevance for a legal topic with citation counts, court, and precedential status, sourced from CourtListener. This clearly distinguishes it from sibling tools like get_federal_case_law, get_federal_court_cases, and get_citation_authority by emphasizing the synthesis aspect.

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 names use cases: legal research agents, litigation intelligence, and compliance gap analysis. However, it does not provide exclusions or name alternative tools for adjacent tasks, so it stops short of full when/when-not 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 mark the tool as readOnlyHint=true and destructiveHint=false, so the description does not need to repeat safety. It adds useful context: the source (Stratalize AI citation index), pricing ($0.10 USDC per call), and the methodology (unprompted AI mention frequency across 100 queries). However, it does not disclose response format, pagination, or edge-case behavior (e.g., empty categories), but that is not critical given the simple read-only nature.

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

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

The description is well-structured: it starts with the usage scenario, then states the return value, provides a concrete example, and ends with source and cost. Each sentence adds value, with no fluff. The length is justified given the need to convey the methodology and pricing.

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 is fairly complete: it explains the purpose, gives an example of the output, and notes the cost. It does not describe the exact return structure (array vs. object), but the example implies a ranking list, which is sufficient for most agents to infer the expected output.

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

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

The input schema provides only the parameter name 'category' with no description (0% coverage). The description compensates by giving an example ('CRM category') and implies the parameter is a software category name. However, it does not specify allowed formats, case sensitivity, or if there are standard canonical names. It adds partial meaning but leaves some ambiguity.

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

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

The description clearly states the tool's purpose: to return vendors ranked by AI mention frequency in a software category. It uses a specific verb ('Returns') and resource ('vendors ranked by unprompted AI mention frequency'), and the example with Salesforce, HubSpot, and Microsoft Dynamics makes the exact deliverable unmistakable, distinguishing it from generic vendor tools like get_top_vendors_by_category.

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

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

The description explicitly says when to use it ('Use when assessing brand visibility in AI-generated recommendations or researching which vendors dominate AI platform responses'). It provides a clear context but does not mention when not to use it or name alternatives. The adjacent get_top_vendors_by_category or get_ai_consensus_on_topic could be similar, but the description's specificity is adequate for most agents.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds valuable context beyond that: the return format (score 0 to 1 with evidence strings), the underlying methodology (citation volume heuristics), and the per-call cost. This gives the agent a clear picture of what the call will produce and what it will cost.

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

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

The description is compact and front-loaded: use case first, output format second, concrete example third, then source and pricing. Every sentence adds distinct information, and the example makes the abstract scoring concrete without bloating the text.

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

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

For a single-parameter, read-only tool with no output schema, the description is complete: it explains when to use it, what it returns, what the score means, the evidence format, an example, the data source, and the cost. An agent has enough information to invoke it correctly without further lookup.

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

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

With schema description coverage at 0%, the description must carry the parameter meaning. It does convey that the 'category' parameter refers to a software category and gives an ERP example, which helps. However, it does not enumerate valid categories, naming conventions, or format requirements, leaving some ambiguity for an agent.

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: assessing near-term displacement risk for a software category and returning a disruption risk score. The verb 'assessing' plus the specific resource ('software category') and the numeric score output make the purpose unmistakable, even among many similarly named siblings.

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

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

The description opens with explicit use cases: 'Use when assessing whether a software category faces near-term displacement risk, or timing a market entry or exit decision.' It does not mention when not to use the tool or name alternative sibling tools, so it stops short of the strongest possible guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds useful context beyond that: what data will be returned, the source ('Stratalize enterprise spend composite'), and a per-call cost of $0.10 USDC. It does not mention latency or error conditions, but the safety profile is already covered.

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

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

Three front-loaded sentences with no filler. The usage trigger, return summary, illustrative example, source, and price all earn their place. The example adds practical interpretative value rather than padding.

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

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

Description covers what the tool returns, when to use it, the data source, and cost. There is no output schema, but the return values are summarized. The main missing piece is accepted values for company_size and industry, which keeps this from full completeness.

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 only 33%, so the description must compensate. It clarifies category and relates company_size to 'same-size peers,' but it does not define allowed company_size buckets or explain the industry parameter at all. This is passable but leaves meaningful gaps.

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 uses a specific verb-resource pair: 'benchmarking total spend in a software category against same-size peers.' It states the concrete return items (median monthly spend, p25/p75 band, sample size) and is clearly distinguishable from siblings like get_industry_spend_benchmark or get_spend_by_company_size.

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 opening phrase 'Use when benchmarking total spend in a software category against same-size peers' gives explicit invocation context. It does not name exclusions or alternative sibling tools, but the 'Use when' framing is clear 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 declare readOnlyHint and destructiveHint, and the description adds non-obvious context: data source (CFPB Consumer Complaint Database synced data) and per-call cost. It does not mention update frequency or pagination, but the added source and cost context go 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 front-loaded with the primary use cases and return summary, followed by a concrete illustrative example, source, and price. It is efficient and each sentence adds useful context, though the example is slightly longer than strictly necessary.

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 gives a good high-level picture of purpose, output contents, source, and cost. However, with no output schema and 0% schema description coverage, it leaves uncertainty about exact response shape and how the product parameter behaves. It is adequate but not fully complete for a 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?

Schema description coverage is 0%, so the description carries the burden for explaining parameters. It mentions 'by company and product' and the example implies company_name, but it never defines the product parameter, its allowed values, optionality, or how the response is filtered. The description does not adequately compensate for the undocumented 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 what the tool does: returns CFPB complaint rollups by company and product, including volume, issue themes, and response rate trends. This is a specific verb-plus-resource statement that differentiates it from sibling financial benchmarks and intelligence 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 explicitly says when to use it: assessing consumer finance risk, benchmarking complaint volume against peers, and pre-acquisition due diligence. It does not mention alternatives or exclusion cases, so it is clear context but not full discrimination guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds valuable behavior beyond annotations: it is a live data snapshot from DeFiLlama, includes specific output fields, and discloses the $0.02 USDC per-call cost. No contradiction exists.

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

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

The description is compact and front-loaded with the core resource, then specifics, then cost. Every sentence adds useful information with no filler or repetitive phrasing.

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

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

For a simple read-only tool with two optional parameters and no output schema, the description covers the main output contents, source, and pricing. However, it omits parameter semantics and does not clarify defaults or sorting behavior, leaving slight ambiguity for an agent deciding 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?

Schema description coverage is 0%, so the description must compensate for the undocumented limit and sort_by parameters. It does mention '1D and 7D change', which loosely maps to sort_by enum options, but it never explains limit or default behavior. The agent is left to infer parameter meaning from field names and schema constraints.

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 resource ('TVL by blockchain'), the source (DeFiLlama), and specific deliverable metrics (rankings, 1D/7D change, protocol counts, Ethereum dominance, Base vs ETH comparison). This differentiates it from dozens of sibling benchmark 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 phrase 'for x402 agent context' implies an intended use case, but the description does not explicitly say when to choose this tool over related siblings like get_crypto_correlation_benchmark, get_defi_yield_benchmark, or get_stablecoin_yield_benchmark. It offers context but no exclusions or alternative routing.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful context beyond the annotations: the data source (CourtListener), cryptographic attestation with a verification URL, and the $0.10 per-call cost.

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

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

The core purpose is front-loaded in the first sentence, and the commercial/trust details (source, attestation, price) are packed efficiently. Slightly padded by the verification URL and pricing, but these earn their place as operationally relevant facts.

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 does a reasonable job describing the return content (citation counts, citing courts, authority signal). However, it omits how parameters should be supplied and what happens when none are provided, leaving a notable gap for a two-parameter, zero-required tool.

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

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

Schema description coverage is 0%, so the description carries the full burden of explaining the two parameters, 'citation' and 'case_name'. It never mentions either field or how they relate (e.g., alternatives vs. both required), so an agent cannot tell which parameter to populate or whether a zero-parameter call is valid.

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

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

The description names a specific resource (citation authority of a case) and the concrete outputs: citation counts, citing courts, and authority signal. It is clear about what the tool computes, though it does not explicitly differentiate itself from legal siblings like get_federal_case_law or get_case_law_synthesis.

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 the tool is for citation authority analysis but gives no guidance on when to choose it over the many legal siblings in the list (e.g., get_federal_case_law, get_judge_analytics, get_docket_intelligence). There are no exclusions, prerequisites, or alternative routings.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds useful context by naming sources (FEMA NFIP, NGFS scenarios) and disclosing the $0.02 USDC per call cost. It does not describe return format, coverage limitations, or data freshness, but the annotations cover the core safety profile.

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

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

The description is compact and front-loaded with the main purpose, followed by useful context: sources, audience, and price. Every clause earns its place, though the dash-heavy structure makes it slightly fragmentary.

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 tool with three optional enum parameters, the description covers purpose, sources, audience, and cost. It is missing guidance on parameter semantics and differentiation from nearby climate/ESG tools, which leaves some selection and invocation ambiguity.

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

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

Schema description coverage is 0%, so the description must compensate for the three enum parameters. It partly maps to risk_type by naming physical and transition risks, but it does not explain the region or property_type parameters at all, nor how they affect results.

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 climate financial risk benchmarks and enumerates the covered risk categories (physical, transition) and lender implications. It is specific about the resource, though it does not explicitly distinguish itself from siblings like get_climate_risk_score or get_esg_benchmark.

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 offers context by targeting 'ESG and risk agents' and cites data sources, which implies an intended use case. However, it never states when to use this tool instead of alternatives such as get_climate_risk_score, get_noaa_disaster_economics, or get_esg_benchmark.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context beyond that: the $0.10 USDC cost per call, the data sources, and a concrete example of the output. This helps the agent set expectations for cost and response 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 front-loaded with the primary use case, then efficiently covers output, example, sources, and cost. The example is lengthy but serves to illustrate the output structure and adds value. No sentence is redundant, and the structure is logical.

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

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

For a read-only single-parameter tool with annotations covering safety and no output schema, the description supplies essential context: output composition, a detailed example, data sources, and cost. The example compensates for the missing output schema and gives the agent a solid picture of what to expect. Slightly more detail on the exact return structure would round it out, but it is largely complete.

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

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

The schema provides 100% coverage for the location parameter, so the baseline should be 3. However, the description's example uses 'Miami-Dade FL' (a county) while the schema specifies 'US city and state' (e.g., Miami FL). This inconsistency could mislead an agent into passing a county name when the tool expects a city, actively reducing the clarity of 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 states a specific function ('pricing physical climate risk for a location') and lists concrete use cases such as real estate acquisition and underwriting. It identifies the output as a composite risk score across six perils, which distinguishes it from generic benchmark tools. However, it does not explicitly differentiate from sibling tools like get_climate_risk_benchmark, so it misses the top tier.

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 opens with 'Use when pricing physical climate risk' and enumerates specific scenarios, which is clear contextual guidance. It does not mention when not to use the tool or alternatives, but the when-to-use guidance is explicit and actionable.

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 readOnlyHint=true and destructiveHint=false; the description adds useful behavior context: it is a lookup that returns peer-group context, percentiles, metadata, source attribution, and optional database_row detail, and it discloses the per-call cost of $0.02. 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?

Four sentences, all substantive: use case, return payload, concrete example, source/pricing. The example earns its place by grounding parameter semantics; 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?

With no output schema and 0% schema descriptions, the description compensates by listing return components and the matching basis. It also includes source attribution and pricing, making it actionable for an agent choosing whether to call. Minor gaps (exact value formats) remain, but overall complete.

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

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

Schema has 0% description coverage, so the description must carry meaning. It explains the matching logic ('by bed size, state, and hospital type') and gives a concrete 300-bed Illinois example. However, it does not specify formats (e.g., state abbreviation vs full name, allowed hospital_type values), leaving ambiguity for the agent.

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

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

States a specific action: benchmarking hospital operating costs against a CMS peer cohort and returns named output components (peer_group context, benchmark_percentiles, metadata). The 'by bed size, state, and hospital type' phrasing immediately distinguishes it from sibling hospital/benchmark 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?

Leads with an explicit 'Use when...' clause that names the benchmark scenario and even a presentation use case. It does not name alternatives or exclusion criteria, so it earns a 4 rather than 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 cover read-only safety, so the description adds value by disclosing the source database, per-call cost, output content, and a concrete example. It does not discuss rate limits or authorization, but the annotation coverage lowers the burden and this description adds meaningful context beyond it.

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?

Compact and front-loaded: use cases first, then return shape, an illustrative example, source, and cost. No filler; each sentence earns its place and helps with both selection and invocation.

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

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

With no output schema, the description adequately explains return values through the aggregate description and the Dr. Smith example. It does not explicitly state how manufacturer_name and program_year combine, but the input schema covers requiredness and the tool is a straightforward read-only retrieval.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that the tool aggregates by physician or manufacturer, and the example implies manufacturer_name and program_year act as filters. It does not explicitly map each parameter to its role, so it is strong but not exhaustive.

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

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

States a specific verb and resource: 'Returns CMS Open Payments aggregates by physician or manufacturer' with payment amounts, types, and program year breakdown. The 'Sunshine Act' and 'CMS Open Payments' phrasing clearly distinguishes it from siblings like get_cms_facility_benchmark or get_cms_star_rating.

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

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

Explicitly frames when to use: physician payment transparency risk, manufacturer relationship evaluation, and Sunshine Act compliance reporting. It does not name alternatives or when-not-to-use, so it falls just short of a 5, but the context is clear and actionable.

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 call read-only and non-destructive, and the description adds useful behavioral context: the source methodology, a $0.02 USDC cost, and concrete example outputs. It does not contradict the annotations, and it discloses the return categories without specifying result formatting.

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

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

The description is front-loaded with the use trigger, followed by output categories, a concrete example, source, and cost. It is slightly verbose because the example sentence carries illustrative numbers, but each component adds some value.

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

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

The description covers the use case, high-level outputs, source, and cost, making it minimally viable. It is incomplete for an agent because the optional parameters are not explained and no output schema exists, so the expected response shape and parameter effects remain unclear.

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

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

Schema coverage is 0% and the description never explains how state, hospital_name, or current_star_rating influence the call. With three undocumented parameters and no required fields, the agent gets no guidance on whether to pass a filter or what the values mean.

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

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

Description clearly identifies a specific resource (CMS Hospital Star Rating) and the actionable outputs: domain weights, national distribution benchmarks, and improvement priorities. It does not explicitly distinguish itself from sibling tools like get_hospital_care_compare_quality, so it falls short of full differentiation.

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

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

Opens with an explicit 'Use when' condition covering strategy advice and benchmarking, which tells the agent when to invoke it. It offers no exclusions or named alternatives, so it stops short of full usage routing.

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

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

Annotations already mark the tool as read-only and non-destructive. The description adds useful behavioral context beyond those annotations: per-call cost, effective date, source, enforcement detail, and the concrete nature of the returned obligations. It does not mention rate limits or output format, but the annotation coverage lowers the bar.

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

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

The description is long but every sentence earns its place: use cases, effective date, return categories, a concrete example, source, and cost. The most important selection information is front-loaded, and the example clarifies both parameter use and expected output.

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

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

Despite having no output schema, the description enumerates the major content areas returned and adds operational facts like the effective date, penalty amount, enforcement body, source citation, and cost. An agent has enough context to select and invoke the tool correctly, including how a system_type value tailors the analysis.

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% for the single optional system_type parameter, so the baseline is 3. The description adds value by showing a concrete example: an AI-based loan underwriting system mapped to specific obligations like impact assessment, disclosure, audit trail, and certification. This gives the agent a practical sense of how the parameter influences the response.

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 does: it returns Colorado SB 205 AI compliance obligations, including developer/deployer duties, high-risk criteria, consumer rights, penalties, and an EU AI Act comparison. The specific legal resource (Colorado SB 205) and content list make its purpose concrete and easily distinguishable from generic state-AI or EU-focused siblings.

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

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

The description gives explicit use cases: building an AI governance roadmap, advising on Colorado high-risk AI obligations, or briefing boards on upcoming US state AI regulation. It does not explicitly name sibling alternatives or state when not to use this tool, but the context is clear enough for 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?

The description discloses valuable behavioral context beyond the readOnlyHint/destructiveHint annotations: it names the upstream source (FRED), update frequency (daily), failure behavior (HTTP 503 with no charge, with a specific threshold '>50% of fields'), cost ($0.10 USDC), and the provenance field (data_source: fred_api/fred_csv/fred_mixed). No contradiction with annotations.

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

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

The description is moderately concise but contains redundancy: the HTTP 503 (no charge) clause appears twice in slightly different forms, and 'Live source' is repeated near the 'Live commodity price benchmarks' opener. The structure front-loads the core purpose, but the extra detail could be tightened.

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 tool with one optional enum parameter and no output schema, the description is fairly complete. It covers data source, update frequency, target audience, failure behavior, cost, and hints at response content (weekly/monthly changes, inflation signal, data_source field). It lacks an explicit description of the return structure, but given the low complexity, the gap 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?

The schema has one optional parameter 'category' with an enum (energy/metals/agriculture/all), but the description does not explain how this parameter affects the response. It lists example commodities from different categories but never directly maps the 'category' parameter to filtering behavior. With schema description coverage at 0%, the description should compensate, but it fails to do so.

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 live commodity price benchmarks for a specific set of commodities (WTI crude, natural gas, gold, copper, wheat, soybeans) plus weekly/monthly changes and an inflation signal. It is a specific verb+resource+scope, but it does not explicitly distinguish itself from siblings like get_copper_price_benchmark or get_agricultural_commodity_benchmark.

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 ('For traders and macro analysts') and lists the specific commodities covered, which implies usage scenarios. However, it does not explicitly state when to use this tool versus sibling tools, nor does it mention when not to use it. The guidance 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 declare readOnlyHint=true and destructiveHint=false, so the description is not relied upon for safety. It adds useful behavioral context: the 'live' nature, a signed receipt (ML-DSA-65), and pricing ($1.00 USDC per call). However, it stops short of describing response structure or any edge-case behavior, so it earns a middle score.

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

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

The description is a single sentence that packs in the core purpose, content domains, receipt detail, and pricing. It is concise and front-loaded, though the long comma-laden structure could be split into two sentences for readability without losing information.

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

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

With no output schema and 0% schema description coverage, the description leaves important gaps: what 'focus' accepts, what the returned synthesis looks like, and any caveats about the 'named company' requirement. The pricing and receipt are helpful but do not compensate for the missing parameter semantics and selection guidance.

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

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

Schema description coverage is 0%, so the description must carry the burden of explaining the two parameters. It indirectly covers 'company' via 'named company' but says nothing about the 'focus' parameter, its purpose, or its relation to the synthesis. This is a significant gap for a paid, parameterized tool.

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 ('synthesis') and resource ('company intelligence') and names concrete content areas: recent litigation, regulatory exposure, financial and news developments. This is clear and distinguishable from many siblings (e.g., get_case_law_synthesis, get_regulatory_news_synthesis) by its comprehensive scope, though it does not explicitly name any sibling as a contrast.

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

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

The description mentions a use case ('for due diligence workflows') but provides no guidance on when to use this tool versus the many related siblings, nor any exclusions or alternatives. Given the huge sibling list, an agent receives no routing help beyond the broad 'company intelligence' purpose.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds useful behavioral context beyond that: the cost ($0.02 per call), the data source (DOL Office of Foreign Labor Certification), and that it returns aggregates. No contradiction is present. It stops short of mentioning rate limits or request quotas, but for a read-only tool this is solid.

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, each earning its place: use case, return summary, illustrative example, and source/cost. The example is somewhat verbose but highly illustrative. It is front-loaded with the trigger scenario and the core return statement.

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

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

Given the tool's moderate complexity (4 params, no output schema, read-only annotations), the description provides purpose, usage, a concrete output example, data source, and cost. It does not describe the exact response structure, but the example compensates. An agent can confidently decide when 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?

Schema description coverage is 0%, so the description carries the entire burden of explaining parameters. It explicitly lists the grouping dimensions: employer, job title, state, and fiscal year, which maps directly to the four parameters. The concrete example (Microsoft, software engineer, Washington/California, 2023) illustrates expected values. It doesn't specify exact string formats (e.g., state abbreviation), but it adds substantial meaning to the bare schema.

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

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

The description states a specific verb and resource: 'Returns DOL LCA and H-1B wage aggregates by employer, job title, state, and fiscal year.' It also opens with a clear use case ('benchmarking compensation against disclosed employer wages'). It doesn't explicitly distinguish from the highly similar sibling get_employer_h1b_wages, but the purpose is unambiguous and concrete.

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

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

The description provides explicit 'Use when' triggers: benchmarking compensation or assessing H-1B wage practices before a talent acquisition. This is clear context for when to call the tool. It does not offer an explicit exclusion or name alternatives, which keeps it just short of a 5.

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

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

Annotations already mark this as read-only and non-destructive. The description adds a concrete example of the output shape, the source ('Stratalize citation displacement composite'), and a per-call cost ($0.10 USDC), which are behavioral traits not available in structured form. It does not discuss failure modes or rate limits, but the additional context is valuable.

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

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

The description is efficient: it opens with usage, then describes the return, illustrates with a concrete example, and closes with source and cost. Every sentence adds operational information, but the long example makes it slightly less tight than ideal.

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

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

For a single-parameter, no-output-schema tool, the description covers the necessary bases: what it returns, an example of the returned data, the data source, and pricing. It does not document edge cases or error handling, but these are less critical for a read-only lookup tool.

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

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

With 0% schema description coverage, the description must explain vendor_name. It does so implicitly by referring to 'a target vendor' and using 'Salesforce' as an example, making clear the parameter is the incumbent vendor's name. It stops short of specifying exact formatting or canonical name requirements.

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 'Returns vendors mentioned as replacements for a target vendor with switch narrative and mention counts,' which is a specific verb and resource. The Salesforce/HubSpot/Dynamics example clarifies the displacement concept and differentiates it from siblings like get_vendor_alternatives or get_competitive_landscape_synthesis.

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 opens with 'Use when tracking competitive threats to an incumbent vendor or identifying switching trends in a software category,' giving a clear trigger context. However, it does not name alternative tools or provide when-not-to-use guidance, so it stops 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 read-only and non-destructive behavior, so the description carries a lower burden for safety. It adds important behavioral context: the synthesis is built from live web sources, includes a signed provenance receipt, and costs $1.00 USDC per call. It does not disclose return format, latency, or rate limits, but for a read-only call the added details are meaningful.

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 short sentences, front-loaded with purpose and followed by the critical cost detail. There is no filler or repetitive boilerplate beyond the minor 'synthesis/synthesized' repetition, and each sentence adds essential information.

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

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

For a one-parameter, read-only tool, the description is largely complete: it identifies what the tool returns (a synthesis plus provenance receipt), the data source, and the cost. It lacks an explicit output schema or return format, but the core details needed to invoke and understand the tool are present.

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 sole parameter 'market' has no schema description, and the description only clarifies it should be a 'market category'. This is minimal compensation for 0% schema coverage—no examples, format, or allowed values are given—but the single parameter is reasonably self-explanatory.

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 synthesizes a competitive landscape for a market category and enumerates its core outputs: current leaders, positioning, and dynamics. It also adds distinguishing elements—live web sources and a signed provenance receipt—that separate it from generic sibling signals or benchmarks.

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 context is implied: it is for obtaining a synthesized competitive landscape for a market category. However, it provides no explicit when-to-use/when-not-to-use guidance and does not mention alternatives like get_category_ai_leaders or get_competitive_displacement_signal, leaving the agent to infer tool selection.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds details about the data contents (hard cost, soft cost, contingency, escalation) and the per-call price, but does not disclose any potential behavioral caveats such as data freshness, rate limits, or what happens with missing data. It is consistent with the read-only annotation and adds some context, but not rich behavioral insight.

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

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

The description is concise, front-loading the core purpose with a dash, then listing sources, audience, and price. It avoids unnecessary fluff and every sentence adds value. It could be slightly tighter by merging the audience and price, but it is well-structured and easy to parse.

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

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

Given there is no output schema, the description does not specify the response format or structure, which is a gap for a benchmark tool. It also fails to explain construction_class, which is a required selection among A/B/C. While it covers the data types and sources, it leaves the agent guessing about how to interpret the output and what the class parameter means, so the description is not fully complete for a tool with 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?

Schema description coverage is 0%, so the description must compensate for the parameters. It explicitly mentions 'by building type and region,' which covers building_type and region, but it does not explain the construction_class parameter (A, B, C) at all. While the enum values are self-explanatory for building_type and region, construction_class lacks any description of its meaning or how it affects the output. The description is incomplete for one of three parameters.

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

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

The description clearly states the tool's purpose: providing construction cost benchmarks including hard cost per SF, soft cost ratios, contingency standards, and material cost escalation signals. It names specific sources (NAHB, Turner, RSMeans) and the target audience, which gives a concrete sense of the deliverable. It doesn't explicitly differentiate from sibling tools like get_development_pro_forma_benchmark, but the focus on construction cost is distinct enough that an agent can infer the scope.

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

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

The description does not provide any guidance on when to use this tool versus alternatives. It mentions the intended audience (developers, lenders, project owners) but does not state when this tool is preferred over other real estate benchmarks (e.g., cap rate, development pro forma, or rental market). No exclusion criteria or alternative tool references are given, leaving the agent to guess based on the name alone.

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

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

Annotations already declare read-only and non-destructive, but the description adds significant behavioral context: live data source, HTTP 503 with no charge when upstream data is unavailable, a $0.10 USDC per-call SLA, and a data_source field for provenance. This goes well beyond annotation coverage and provides agents with critical failure and cost information. No contradiction with annotations.

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

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

The description is front-loaded with a clear purpose, but it repeats the HTTP 503 no-charge behavior twice: once with '>50% of fields' and once as 'when upstream data sources unavailable.' This redundancy is unnecessary and reduces conciseness.

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 (one optional parameter, no output schema), the description covers data sources, usage context, failure modes, cost, and provenance. It hints at output via 'Strong/moderate/weak consumer signal' but does not detail the response structure. Sibling tools follow a similar pattern, so the missing output schema details are less critical.

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

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

The schema has a single optional parameter 'focus' with enum values, but the description's schema coverage is 0%. The description lists sentiment, spending, and saving categories that map to the enum values, giving indirect meaning. However, it does not explicitly explain how the 'focus' parameter affects the output, leaving the mapping implicit.

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

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

The description clearly identifies the tool as providing live consumer sentiment benchmarks from FRED, enumerating specific indicators (University of Michigan sentiment, Conference Board confidence, retail sales, PCE, personal saving rate). This distinguishes it from sibling tools that focus on individual benchmarks (e.g., get_personal_savings_benchmark, get_retail_sales_benchmark).

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 for when to use the tool: 'Strong/moderate/weak consumer signal for GDP and equity agents.' It implies that this aggregate benchmark is appropriate for broad economic analysis, while sibling tools cover individual metrics. However, it does not explicitly state when not to use it or name alternatives.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds meaningful operational context: cost per call ($0.02 USDC), cryptographic attestation, verification URL, and data source (FRED / IMF). These go beyond the annotation safety profile and help an agent anticipate side effects and trust 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 front-loaded with the core content and then gives usage, source, cost, and verification details. However, it suffers from minor redundancy ('$0.02 atomic' and '$0.02 USDC per call') and an unclear term ('atomic') that adds confusion rather than clarity.

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

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

For a zero-parameter, read-only tool with no output schema, the description covers the key aspects: what data it returns, the source, a usage signal, cost, and verification steps. It does not specify the response structure, but the primary content is clearly described and sufficient for correct invocation.

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

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

The tool has zero parameters and schema description coverage is 100%, so no parameter documentation is required. The description still adds value by explaining the output content (price, YOY change, demand significance note), which partially compensates for the absence of an output schema.

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

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

The description names a specific resource ('IMF Grade A copper price in USD per metric ton') and details what it returns (price, year-over-year change, demand note). This clearly distinguishes it from generic siblings like get_commodity_benchmark or get_gas_benchmark.

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

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

The description gives a clear usage context: 'Use as a coincident indicator for global manufacturing and construction cycles.' It does not explicitly name alternatives or exclusions, but the specialized copper-scope makes the intended use unambiguous 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 declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context beyond that: data sources (S&P Capital IQ public aggregates and Damodaran), the user audience, and the $0.02 USDC per-call cost. It does not describe response format or data freshness, but the annotations lower the bar for this dimension.

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

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

The description is front-loaded with the most actionable 'Use when' guidance and covers source, use case, and cost in a compact format. The sentence about CFOs and treasurers partially repeats the opening scenario list but still adds audience context. It is slightly longer than necessary but each major element 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?

Given there is no output schema, the description does a good job of stating what will be returned: Net Debt/EBITDA, interest coverage, and debt maturity profiles broken down by industry and credit rating tier. It also names sources and pricing. It does not specify exact response shape or data frequency, but for a benchmark lookup tool the coverage is largely sufficient.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It does connect the two parameters to output dimensions by saying benchmarks are broken down 'by credit rating tier and industry,' and the schema's enums are fairly self-descriptive. However, it does not explain what each enum value represents, why credit_rating_tier is optional, or what happens when it is omitted.

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: assessing debt capacity, benchmarking leverage against sector peers, and preparing refinancing or credit rating discussions. It names specific outputs—Net Debt/EBITDA, interest coverage, and debt maturity profiles—which gives a concrete resource, though it does not explicitly differentiate from closely named siblings like get_cre_debt_benchmark or get_real_estate_debt_stress_benchmark.

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

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

It opens with explicit 'Use when' guidance covering multiple relevant scenarios: debt capacity assessment, peer leverage benchmarking, refinancing, and credit rating discussion. It does not mention when not to use it or point to alternative tools, but the stated use cases are clear enough for an agent to decide when it applies.

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 indicate read-only and non-destructive behavior. The description adds substantial context: the cost+15% pricing model, $0.02 USDC per call SLA, 503 error handling with no charge, and provenance disclosure via data_sources[] and synthesis.output_hash. This goes far 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 dense but well-organized, covering use case, return fields, example, cost, error handling, and provenance. Each sentence adds value without excessive fluff, though it could be marginally streamlined.

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 two-parameter read-only tool with no output schema, the description provides enough context: purpose, output fields, an example, cost, failure behavior, and data source. It is sufficiently complete, though quantity_units semantics could be more explicit.

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 has zero description coverage, so the description must carry the burden. It explains that ndc_or_name takes an NDC (with example 42385096230) and implies quantity_units affects 'optional quantity quote.' However, it does not mention that ndc_or_name may accept a name, and quantity_units is not fully detailed.

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 Mark Cuban Cost Plus Drugs transparent retail pricing for a specific NDC, with expected return fields and an example. This distinguishes it from sibling tools like get_nadac_drug_benchmark, which target different pricing 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 explicitly states when to use this tool: 'Use when a patient, benefits manager, or procurement agent needs... transparent retail pricing for a specific NDC.' It provides clear context but does not explicitly mention alternatives or when not to use it, though the niche is sufficiently specific.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description is consistent with them. It adds genuine value beyond the annotations by disclosing the data source (FFIEC official federal record), the per-call cost ($0.10 USDC), and the regulatory consequence timeframe. It doesn't cover auth needs, rate limits, or not-found behavior, but for a read-only lookup the added context is solid.

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

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

The description is front-loaded with the 'Use when' usage trigger and efficiently packs the rating categories, source, and price. However, the Heartland Community Bank example and the 12-24 month delay detail are somewhat promotional and could be trimmed; for a one-parameter lookup tool the ~125-word description is longer than strictly necessary.

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 low-complexity tool with one required parameter, no output schema, and read-only annotations, the description covers the essentials: the rating scale implies what the response contains, the hour source and cost are disclosed, and the example hints at response fields (exam date, consecutive ratings). It doesn't specify exact response structure or not-found behavior, but nothing an agent needs to invoke it correctly is missing.

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

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

With 0% schema description coverage for institution_name, the description carries the burden of explaining the parameter. It partially compensates — 'a bank's CRA track record' and the example 'Heartland Community Bank' imply the parameter is a bank name — but it never explicitly states the expected format (exact legal name, handling of subsidiaries) or valid values. This is partial, not complete, compensation.

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

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

The description clearly states the tool retrieves a bank's CRA performance ratings from the FFIEC CRA Ratings Database and lists the full rating scale (Outstanding, Satisfactory, Needs to Improve, Substantial Noncompliance). The resource is unmistakable and no sibling tool overlaps with CRA, though the description never explicitly names an alternative or uses an explicit verb like 'retrieve'.

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 enumerates when to use the tool: before a merger application, charter acquisition, branch expansion approval, or community lending partnership, and explains the regulatory stakes (a 'Needs to Improve' rating can delay or block approval by 12-24 months). It provides clear situational context but no when-not-to-use guidance or named alternatives, 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?

Annotations already establish read-only and non-destructive behavior; the description adds useful behavioral context by stating that results degrade per-section when source data is unavailable and that the call costs $3.00 USDC. It does not go into output format, authentication, or rate limits, but the added degradation detail is meaningful.

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?

Four short sentences front-load the purpose, then cover degradation behavior, inputs, and cost with no filler. Every sentence adds decision-relevant 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 read-only composite tool with five inputs and no output schema, the description covers the core invocation details: use case, required/optional inputs, degradation, and cost. It is slightly thin on what the returned composite looks like and how to format 'location', but it is generally complete enough to call 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 only parameter information in the description is required/optional status, which duplicates the input schema. With 0% schema description coverage, the description needed to explain what values 'location'/'state' should take and how asset_class, property_type, and market_tier interact, but it does not.

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 use case ('underwriting a CRE acquisition') and a specific deliverable: one signed composite spanning cap rates, CRE debt, operating costs, property tax, debt-stress, and climate risk. This clearly differentiates it from the many single-benchmark siblings such as get_cap_rate_benchmark or get_cre_debt_benchmark by emphasizing the composite nature.

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?

Opens with an explicit when-to-use condition and describes what the returned composite contains, so an agent can recognize the appropriate context. It does not name alternative tools or give when-not-to-use conditions, which prevents a 5.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so no safety duplication is needed. The description adds valuable non-obvious behavior: the data sources (MBA CREF databook and Trepp public data) and the per-call cost ($0.02 USDC). These are meaningful beyond the annotations. It does not discuss pagination or default behavior, but for a simple benchmark lookup with a safety profile already provided, this is solid.

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 short sentences, each earning its place: the core subject matter, the source, the audience, and the cost. It is front-loaded with the most important information and contains no filler or redundancy. This is an example of efficient, well-structured prose.

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

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

For a tool with only two simple parameters, no output schema, and a read-only annotation, the description is largely complete. It explains what the tool offers, who it serves, and the data provenance, plus the cost. It does not describe the output format or defaults, but given the 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?

With schema_description_coverage at 0%, the description carries the burden for explaining parameters. It does name the two dimensions (property type and lender type) and lists some lender type values (bank, agency, CMBS, life company), but it omits 'debt_fund' and 'bridge' and gives no examples of property types. It tells the agent what the parameters mean at a high level but does not fully compensate for the missing schema descriptions or enumerate all allowed values.

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 commercial real estate debt benchmarks and specifies the exact metrics (DSCR minimums, LTV maximums, spread ranges) and dimensions (property type, lender type). This goes beyond a bare restatement of the name, and the specificity distinguishes it from siblings like get_cap_rate_benchmark or get_credit_spread_benchmark. However, it lacks an explicit verb like 'retrieves' or 'returns', so the purpose is clear but slightly less direct than a 5.

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

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

The description gives a clear target audience ('For CRE CFOs and capital markets teams structuring financings') and an implicit use case, but it does not name any alternative tools or state when not to use it. It implies usage via context rather than explicit guidance, so an agent might struggle to choose between this and closely related benchmarks like get_real_estate_debt_stress_benchmark.

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 destructiveHint, and the description adds meaningful behavioral context such as HTTP 503 error handling when upstream sources are unavailable, the x402 SLA cost, and the data_source provenance field. It does not contradict the annotations, though it stops short of detailing the complete success response structure.

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 fairly detailed and front-loads the main content, but it contains redundant error messaging: 'Returns HTTP 503 (no charge) if upstream source unavailable for >50% of fields' is repeated in slightly different words later. This redundancy makes it less concise than it could be.

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

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

For a simple tool with one optional parameter and no output schema, the description provides a good overview: it lists the data series returned, update frequency, source, error behavior, pricing, and provenance field. It is not exhaustive, but it is sufficiently 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?

With schema description coverage at 0%, the description must clarify the single parameter. It mentions 'OAS by rating tier' which relates to rating_tier, but it does not explain the enum values (all, ig, hy, bbb) or how the parameter affects other metrics like TED spread and 2s10s. The enum is somewhat self-explanatory, but the description does not fully compensate for the lack of schema documentation.

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

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

The description clearly states the tool provides live investment-grade and high-yield credit spread benchmarks from FRED ICE BofA indices, listing specific metrics (OAS by rating tier, TED spread, 2s10s Treasury spread, distress signal). It distinguishes itself from sibling benchmark tools by focusing on credit spreads and targeting credit analysts and fixed income PMs.

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 for when to use the tool: for credit analysts and fixed income PMs, with daily updates and a live source. However, it does not explicitly mention alternatives or when not to use this tool, which prevents a higher score.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds useful context about the data source (NCUA quarterly call report public data) and cost per call, but does not disclose other behavioral details such as response format, rate limits, or whether the data is aggregated at cohort level.

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 tool's core purpose, and each sentence adds information: metrics, source, use case, and cost. It is slightly less tight than a two-sentence definition, but there is no wasted 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 low-complexity tool with only two parameters and no output schema, the description provides enough context about what the tool returns, the source, and the intended use. It could be strengthened by describing the response shape or clarifying whether charter_type applies to both federal and state credit unions.

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

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

Schema description coverage is 0%, so the description must compensate for the lack of field-level documentation. It mentions grouping 'by asset size,' which loosely maps to asset_size_tier, but it does not explain the meaning of charter_type or clarify how each metric is filtered by these parameters.

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

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

The description clearly states that the tool provides credit union financial performance benchmarks, naming specific metrics (capital ratios, net interest margin, loan growth, delinquency rates) and the grouping by asset size. It is clear and specific, though it does not explicitly differentiate itself from the similar sibling get_ncua_credit_union_financials.

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 indicates the intended audience and context (credit union CFOs, NCUA exams, board reporting), which implies when it might be used. However, it does not provide explicit guidance on when to prefer this tool over alternatives like get_ncua_credit_union_financials or when not to use it.

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 valuable behavioral context beyond the readOnlyHint and destructiveHint annotations: it discloses HTTP 503 responses with no charge when upstream sources are unavailable, an SLA of $0.10 USDC per call, and a data_source field for provenance. The repeated 503 sentence and irrelevant FRED provenance mention detract slightly, but the disclosure is substantial.

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

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

The description front-loads the core purpose but becomes repetitive, with two identical statements about HTTP 503 behavior and an out-of-place reference to 'fred_api/fred_csv/fred_mixed' that is irrelevant to crypto. These redundancies and inconsistencies make it longer than necessary without adding value.

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

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

The description covers the output components (Pearson pairs, beta, dominance, diversification signal), source, error behavior, and cost, which is good for a tool without an output schema. However, it fails to explain the only parameter (period), and the duplicate 503 text plus FRED provenance error leave gaps in the tool's operational semantics.

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

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

The input schema has one optional parameter 'period' with an enum of 7d/30d/90d, yet the description never explains this parameter. It mentions '30-day rolling' as a fixed attribute, which conflicts with the parameter's ability to vary the window. With 0% schema description coverage, the description should compensate but does not.

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 and resource: it computes a 30-day rolling correlation matrix for BTC, ETH, and SOL, including Pearson pairs, beta, dominance, and diversification signals. This distinguishes it from sibling benchmark tools, which focus on different asset classes or metrics.

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 implicitly targets 'crypto portfolio agents' and mentions a live source, giving some usage context. However, it does not explicitly state when to use this tool versus alternatives or provide exclusions, so guidance 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 declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds useful context by naming the data source (DeepDAO public data) and the per-call cost ($0.02 USDC), but it does not disclose behavior such as result limits, output format, pagination, or how filters affect results.

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. It includes only high-value details: the metrics returned, median values, data source, and pricing. No filler or redundant repetition of the schema.

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, optional-parameter benchmark fetch, the description gives enough context to understand the tool's domain and cost. However, it is incomplete in that parameter semantics are not documented and there is no output schema to clarify return shape or sorting behavior.

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

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

The input schema has 0% description coverage, and the description does not explain sort_by or min_treasury_usd. The listed metrics partially map to the sort_by enum values (treasury, stablecoin_pct), but the behavior of min_treasury_usd and value formatting is left entirely to inference.

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 (DAO treasury benchmarks) and the specific data returned: top DAOs by treasury size, stablecoin percentage, runway, and governance token concentration, plus median benchmark values. This is specific enough to distinguish it from the many sibling benchmark tools, especially stablecoin and DeFi benchmarks.

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 through the domain phrase 'DAO treasury benchmarks' and the listed metrics, but it does not explicitly say when to choose this tool over alternatives. There are no exclusion criteria or mentions of related sibling tools that might be confused with it.

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 readOnlyHint=true and destructiveHint=false. The description adds that it returns list_version and as-of metadata, is post-quantum signed, and costs $1.00 USDC. This is useful context beyond annotations, and no contradiction exists.

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

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

Two well-structured sentences. The use case and output are stated upfront, with pricing at the end. 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 a single parameter, no output schema, and read-only annotations, the description covers purpose, input values, output contents (list_version and as-of metadata), and cost. Nothing essential is missing.

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

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

With schema providing no description for the 'dataset' parameter (0% coverage), the description compensates fully by listing the allowed values: ofac, oig, or sam. This gives the agent the necessary semantic information to invoke correctly.

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

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

States a specific verb ('Get') and resource (data freshness attestation), specifies the exact purpose (post-quantum signed attestation of screening-list currency), and names the datasets (OFAC, OIG LEIE, SAM). It clearly differentiates from likely siblings like get_ofac_sanctions_screening by focusing on attestation metadata rather than actual screening.

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

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

Explicitly says 'Use when an examiner or compliance workflow needs a post-quantum signed attestation of screening-list currency.' It also notes the attestation is for the same versions bound into screening responses, tying to related tools. However, it doesn't explicitly list alternative tools or state when not to use it, though the context strongly implies it.

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 establish read-only/non-destructive behavior. The description adds meaningful external context: free public API, no key required, $0.02 USDC per call, and DeFiLlama as the upstream source. No contradiction with annotations.

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

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

Three dense sentences with no filler: main output first, then filters, then default universe and cost. 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?

Comprehensive for a low-complexity read-only tool: output fields, filter semantics, default behavior, auth requirements, and cost are all covered. No output schema is provided, but the description supplies enough about return content.

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 are already fully described in the schema, so the baseline is 3. The description reinforces protocol/asset substring behavior and optionality but adds little 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?

Clearly identifies the tool as a DeFi lending/stable yield benchmark from DeFiLlama Yields, listing concrete outputs like APY bands, TVL, chain, and pool ID. However, it does not explicitly distinguish itself from the closely named sibling get_stablecoin_yield_benchmark.

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 useful context on optional filters and the default stablecoin-marked pool universe. Lacks explicit guidance on when to prefer this tool over overlapping siblings such as get_stablecoin_yield_benchmark.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful context beyond the annotations, such as data sources (NAHB, ULI, industry composite) and per-call pricing, but it does not disclose response shape, update cadence, or any other behavioral traits.

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: metrics first, then audience, then sources and price. Every sentence earns its place, with no redundant phrasing or restatement of the tool name.

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

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

For a low-complexity, read-only benchmark lookup with two enum parameters and no output schema, the description provides purpose, metrics, target users, sources, and cost. The only minor omission — not describing market_tier in prose — is fully covered by the input schema enum, so nothing critical is missing for correct invocation.

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

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

Schema description coverage is 0%, so the description needed to compensate. It mentions 'by product type,' which maps to the required product_type parameter, but it completely omits market_tier and gives no meaning to either parameter's enum values. The schema enums do the heavy lifting; the description adds little parameter-level understanding.

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

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

The description names a specific resource — development pro forma benchmarks — and enumerates the exact metrics returned (yield on cost, profit-on-cost, construction-to-perm spread, return hurdles). It clearly distinguishes itself from sibling tools like get_cap_rate_benchmark and get_construction_cost_benchmark by its metric set and real-estate development focus.

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

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

The description gives explicit context for when to use the tool: developers underwriting new projects and lenders sizing construction loans. It does not explicitly name sibling alternatives or state when not to use it, but the use-case framing is clear enough to guide selection.

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

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

Annotations already declare the tool as read-only and non-destructive. The description adds valuable context about the data source (FDA 510(k) database), the settlement receipt attestation, and a verification URL, giving extra trust and provenance details beyond the annotations. It does not cover pagination or error behavior, but the added context is meaningful.

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 core function, then returns fields, use cases, and trust/verification details. Every sentence earns its place, and there is no redundant or filler 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 one-parameter tool with no output schema, the description is complete: it explains what the tool returns, provides use cases, and includes trust/verification info. The annotations cover safety, so no further behavioral disclosure is necessary.

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

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

The schema has 0% description coverage, but the description states 'by device name,' which clearly identifies the sole parameter's semantic role. Since there is only one parameter and no enums, this compensation is sufficient, though it does not add format or syntax details beyond the schema's min/max length.

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

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

The description clearly states the tool retrieves FDA 510(k) device clearance history by device name, listing specific return fields (K numbers, applicants, decisions, receipt dates). This distinguishes it from sibling tools like get_fda_recall_history, which cover recalls rather than clearances.

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

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

The description provides explicit use cases: medtech competitive intelligence, regulatory pathway research, and supplier qualification. It does not spell out when-not-to-use or name alternatives, but the context is clear enough for an agent to select it appropriately.

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 establish a safe read-only operation, so the description adds value by disclosing the data source (CourtListener), the $0.10 USDC cost, and the cryptographic attestation with verification URL. It does not cover rate limits or result counts, but for a read-only, low-risk call the added behavioral context is meaningful.

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: core behavior first, then use case, then cost and verification details. No sentence is redundant, though the attestation and fee details are secondary to invoking the tool correctly.

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 helpfully lists key return fields: open cases only, last filing date, nature of suit, and most active courts. However, it omits expected result shape, pagination behavior, and the meaning/effect of the optional court parameter, so the context is adequate but incomplete.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining parameters. It implicitly maps party_name to 'a named party,' but it provides no semantics for the optional court parameter, leaving the agent to guess whether it filters results or appears only in output.

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 action and resource: retrieving active federal dockets for a named party, including open-case scope, last filing date, nature of suit, and most active courts. It differentiates from siblings by emphasizing 'open cases only' and 'federal dockets,' but it does not explicitly name or contrast an overlapping sibling like get_party_litigation_profile.

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

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

The description gives an explicit use case: 'Use for ongoing litigation monitoring.' This tells the agent when the tool is appropriate. However, it does not state when not to use it or name alternatives, such as get_party_litigation_profile or get_federal_court_cases.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description doesn't need to cover safety. It adds useful context about data source (DOL WHISARD), cost ($0.10 USDC per call), and an example of output values, but it does not discuss pagination, failure modes, or auth requirements. Given the annotations cover the risk profile, this is adequate.

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

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

The description is front-loaded with the use case, then lists return content, a predictive insight, an illustrative example, and source/cost. Each sentence adds value, though the example is somewhat lengthy. Overall it is well-structured and not overly verbose for the information conveyed.

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 partially explains return values ('back wages assessed and employees affected') and gives a concrete example. It lacks a formal return structure or error handling info, but for a simple read-only tool with two parameters, the information is sufficient for most call scenarios. Missing state semantics is the main 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 description coverage is 0%, so the description must compensate for parameter meaning. It mentions 'employer, vendor, or acquisition target' and gives an example with 'Logistics Co LLC', which implies employer_name. However, it never explicitly explains the 'state' parameter or how it filters results. The description provides an example but does not fully define the parameters.

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

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

The description clearly states a specific verb and resource: 'Returns DOL Wage and Hour Division enforcement history — FLSA overtime violations, minimum wage violations, child labor violations — with back wages assessed and employees affected.' This distinguishes it from siblings like get_osha_enforcement or get_employer_h1b_wages by explicitly naming the DOL WHD and its data types.

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 opening sentence provides explicit use contexts: 'Use when screening an employer, vendor, or acquisition target for wage and hour compliance risk before a contract award, supply chain partnership, PE acquisition, or HR due diligence review.' It does not mention when not to use it or point to alternatives, but the guidance is clear and actionable.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds return content and provenance (FDA FAERS), plus an unusual attestation/receipt feature, but does not disclose rate limits, error handling, or permission requirements. With annotations covering the essential behavior, the extra detail is moderate but not rich.

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

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

The description is a single dense sentence that front-loads the main purpose but then appends pricing and attestation details, making it less structured. It is not overly long but could benefit from clearer separation of core purpose, use cases, and meta-information. It does not waste words, but the flow is a bit run-on.

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 two-parameter read-only tool with no output schema, the description covers the main purpose, return types, source, and even pricing/verification. It lacks explicit details on the `limit` parameter's effect on results, but overall it is reasonably complete for an agent to judge whether 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?

Schema description coverage is 0%, so the description must compensate. It implicitly clarifies drug_name through 'by medicinal product name' but does not mention the `limit` parameter at all. The description adds some meaning for the required parameter but fails to explain the optional limit, leaving a significant gap.

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

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

The description clearly states the verb ('get') and resource ('FAERS drug adverse event reports from OpenFDA by medicinal product name'), and further details the specific return data (serious event counts, reactions, outcomes, chronology). This distinguishes it from siblings like get_openfda_adverse_events by its specific focus on product name and serious-event analysis.

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

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

The description explicitly lists use cases: 'pharmacovigilance monitoring, safety signal detection, and clinical risk agents.' This provides clear context for when to use the tool, though it does not mention when not to use it or name direct alternatives, 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds useful context: source (FDA labels), cost ($0.10), and cryptographic attestation. But it does not disclose return format, pagination, or limitations, so the added value is moderate.

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

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

The description is front-loaded with purpose and outputs, followed by use cases and cost/verification details. Each sentence adds some value, though the attestation note could be trimmed for an AI agent.

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

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

For a simple 1-parameter read-only lookup, the description covers the key return fields, source, cost, and verification. It lacks any mention of drug_name format, but overall is reasonably complete given the lack of an output schema and low parameter complexity.

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

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

Schema description coverage is 0% for the single parameter drug_name, and the description does not elaborate on its expected format (e.g., brand vs generic, case sensitivity). The param name and tool context imply it's a drug name, but the description fails to compensate for the missing schema detail.

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

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

The description clearly states it returns FDA drug label intelligence with specific fields (brand/generic names, manufacturer, route, indications, warnings). It distinguishes this from sibling tools like get_drug_adverse_events by focusing on label content, though it doesn't explicitly name alternatives.

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

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

It provides explicit use cases: formulary review, pharmacology research, and adverse event context. However, it lacks exclusions or alternative tool suggestions, so it doesn't fully meet the 'when not to use' bar.

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

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

Beyond the readOnlyHint annotation, the description discloses several crucial behaviors: match_confidence distinguishes exact NDC matches from name matches, the 'never silently returning' guarantee protects against misidentification, HTTP 503 (no charge) when upstream sources are down, and data_sources[] provenance with synthesis.output_hash. It also provides pricing (SLA cost) and an illustrative example, offering rich operational transparency.

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

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

The description is information-dense yet compact. Every sentence adds value: use case, return fields, behavioral guarantee, example, source, SLA/cost, error behavior, and provenance. It is well-structured, starting with the primary use and flowing to operational details, with 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?

Given the minimal schema (one parameter, no descriptions) and no output schema, the description offers a comprehensive picture: what inputs are accepted, what outputs to expect, how errors surface (503), and how provenance is disclosed. It also explains the match_confidence semantics and gives a realistic example, making it fully self-contained for an agent to use effectively.

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

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

The input schema has only a single string parameter with zero description coverage (0%), so the description must fully compensate. It does so by stating the parameter accepts either an NDC or drug name and provides a concrete example ('NDC 41163-703-10'), clarifying the expected format. This gives the agent exactly what it needs to invoke the tool correctly despite the bare schema.

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

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

The description clearly states the tool's function: retrieving FDA drug recall status for an NDC or drug name. It specifies the target users (pharmacy, supply chain, compliance agents), the key return fields (status, classification, reason, dates), and the unique guarantee of not silently returning a different product's recalls. This goes beyond a generic statement and distinguishes it from siblings like get_fda_recall_history.

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 starts with 'Use when a pharmacy, supply chain, or compliance agent needs FDA drug recall status,' providing clear context for when to invoke the tool. It does not, however, explicitly mention when not to use it or name alternative tools, so it falls short of the highest bar for exclusionary guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds useful context: the SEC EDGAR aggregate source, the Sloan accruals academic model, and per-call pricing, but it doesn't disclose output format, update cadence, or rate limits. This is adequate but not rich.

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

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

Four short sentences with the core deliverable front-loaded and the source, audience, and price in logical order. No filler, though pricing could arguably live outside the description.

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

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

For a low-complexity, read-only benchmark lookup with one required enum parameter, the description covers what it returns, the data source, the intended use case, and cost. The main gap is that the optional revenue_recognition_model parameter is not explained, but the schema's enum values are self-explanatory and no output schema exists to demand more.

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

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

Schema description coverage is 0%, so the description needed to carry the parameter burden. It maps 'sector' with 'by sector' and loosely signals revenue recognition via the metric name, but it never explains the optional revenue_recognition_model parameter or how selecting a model changes results. The enum values are left entirely to the schema.

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

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

The description names a specific deliverable — earnings quality and financial statement risk benchmarks — and lists the exact metrics (accruals ratio, cash conversion, revenue recognition risk) and the key dimension (by sector). This is specific enough to distinguish it from the many other benchmark tools in the sibling list.

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 names the target users and scenario: CFOs, auditors, and analysts assessing financial reporting risk before M&A or investment. It doesn't explicitly rule out alternatives, but it gives clear context for when the tool is appropriate.

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 establish readOnly/non-destructive, and the description adds behavior beyond safety: it returns a benchmark per bed, offers optional gap analysis when actual cost and bed count are provided, cites source data, and discloses per-call pricing. No side effects, but all relevant invocation behavior is covered.

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

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

Front-loaded with the use case, then return value, example, source, and pricing—each sentence adds actionable context without padding. The size is appropriate for the tool's complexity.

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

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

Despite no output schema, the description explains what is returned (benchmark per bed, optional gap analysis) and when optional inputs matter. It also gives data provenance and cost, so an agent has enough context to select and invoke the tool correctly for a straightforward 3-parameter lookup.

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

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

Schema description coverage is 0%, so the description carries the parameter burden. It maps bed_count and annual_cost via 'actual cost and bed count', names vendor context with Epic, and clarifies bed count is per licensed bed. It does not enumerate accepted vendor values or define currency/units precisely, but it adds meaningful semantics to all three parameters.

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

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

Description begins with a specific use case ('benchmarking EHR maintenance costs before a contract renewal') and names the exact metric ('benchmark cost per licensed bed'), making it distinct from sibling benchmark tools. The example (Epic maintenance median $4,500/bed) pinpoints the resource domain.

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

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

Explicitly states when to use ('before a contract renewal or evaluating health IT budget efficiency'), which is clear direction. It does not explicitly name sibling alternatives or state when not to use it, 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=true and destructiveHint=false, so safety is covered. The description adds useful behavioral context beyond that: it depends on EIA API configuration, returns specific spot prices, is sourced from EIA, costs $0.02 USDC per call, and includes an example output. This meaningfully exceeds the structured annotation signal.

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

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

The description is front-loaded with the triggering use case and return value, followed by a concrete example, source attribution, and cost. Every sentence earns its place and none are redundant. It is compact while covering purpose, output, cost, and caveat.

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

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

For a zero-parameter read-only snapshot tool with no output schema, the description is complete: it states what data is returned, with units and a concrete example, names the data source, notes the API configuration dependency, and gives the per-call cost. An agent has enough to decide whether and how to call it correctly.

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

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

The tool has zero parameters and schema description coverage is 100%, so the description cannot add parameter-level meaning. The description does explain what data the no-parameter call returns, which is the relevant semantic content here. Baseline 4 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 names a specific resource and data scope: 'Returns WTI crude and natural gas spot prices' from the EIA. It also grounds the purpose in concrete use cases (commodity brief, input cost analysis, CFO/investment brief), which clearly distinguishes it from the many sibling benchmark 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 explicitly states when to use the tool: 'Use when current energy price data is needed for a commodity brief, input cost analysis, or energy sector context.' It doesn't explicitly name alternatives or exclusions, but the use-case framing is clear enough for an agent to select it appropriately.

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 as read-only and non-destructive. The description adds valuable behavioral detail: it discloses the return fields (wave position, degree, target high/low, invalidation, confidence), the asset universe, and the per-call cost, which is useful given no output 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 front-loaded with the key use case and keeps to three sentences. The 'Example:' sentence largely restates the preceding return-field list, introducing minor redundancy, but overall it is efficient.

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

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

For a one-optional-parameter read-only tool, the description covers purpose, invocation context, supported assets, return fields, and cost. It does not contrast with sibling trading-signal tools, but nothing critical is missing for calling it correctly.

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

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

The schema already documents the single 'asset' parameter with 100% coverage. The description adds concrete valid asset symbols (BTC, SPY, TLT, Gold) and reinforces the default behavior, making the parameter more actionable.

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 use case ('technical trader needs wave counts, targets, and invalidation levels') and names the concrete assets (BTC, SPY, TLT, Gold). This clearly distinguishes it from generic benchmarking or market-data siblings.

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

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

It explicitly says when to use the tool ('Use when a technical trader needs wave counts, targets, and invalidation levels'). It does not name sibling alternatives or exclusions, but the context is specific enough to guide selection.

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

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

Annotations already flag readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds valuable behavioral context: data source (DOL LCA public data), the types of statistics returned (prevailing wage, certified job titles, wage levels, state distribution), and a per-call cost ($0.02 USDC). This goes beyond the annotations and gives the agent a clear idea of what to expect.

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

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

The description is efficient: use case, return summary, a concrete example, source, and cost. The example is somewhat lengthy but serves a pedagogical purpose. The information is front-loaded with the usage trigger. No wasted sentences, though a slightly tighter phrasing would push it to 5.

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

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

With no output schema, the description must explain return values, and it does: prevailing wage statistics, certified job titles, wage levels, and state distribution. The Google example gives a realistic sense of the data shape and magnitude. It also covers source and pricing, making the description complete for a simple single-parameter read-only 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 the parameter `employer_name` is already described with examples in the schema. The description only reinforces this with a Google example without adding new constraints, formats, or edge-case semantics. Baseline 3 is appropriate since the schema carries the descriptive load.

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

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

The description explicitly states a specific use case ('analyzing an employer H-1B compensation strategy or benchmarking tech sector wages against DOL prevailing wage data') and names the exact resource (DOL LCA filings). It distinguishes itself from siblings like get_salary_benchmark and get_labor_market_benchmark by focusing on employer-specific H-1B wages, making the tool's purpose unambiguous.

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

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

It provides clear context with 'Use when...' and gives a concrete example. However, it does not explicitly mention when not to use it or point to alternatives such as get_salary_benchmark for general wage data. Thus it meets the 'clear context' level but stops short of full exclusion/alternative 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 indicate readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: the data source (BLS ECI), the cost ($0.10 standard), and the cryptographic attestation and verification process. This goes beyond minimal safety disclosure and informs the agent of trust and contractual aspects.

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 earning its place: the first states the data content, the second gives usage context, and the third provides provenance and verification. It is front-loaded with the core meaning, and there is no wasted verbiage.

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 zero parameters and no output schema, the description still tells the agent exactly what the tool returns (year-over-year change for three compensation components) and when to use it. It also covers source, cost, and verification, making it complete for an agent to invoke and trust the result.

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