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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the description's main transparency contributions are the aggregation detail (last 100 calls) and the token requirement. It does not discuss rate limits or error handling, but for a simple read operation, this is adequate. No contradictions with annotations.

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

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

The description is extremely concise, consisting of two short sentences. The main purpose is front-loaded in the first sentence, and the second sentence adds practical details (free, token required). No redundant or irrelevant information.

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

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

Given the tool's simplicity (no parameters, no output schema), the description covers the essential information: what is checked, the aggregation scope, and the token requirement. It does not detail the response format, but for a status check this is acceptable. It lacks any discussion of edge cases or failure modes.

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

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

The input schema has zero parameters, and schema description coverage is 100% (since no parameters exist). According to the guidelines, this baseline is 4. The description correctly implies no parameters are needed, and no additional semantics are required.

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: checking the configured TensorFeed token for current credit balance and recent per-endpoint usage (last 100 calls aggregated). The verb 'Check' and specific resource 'TensorFeed token' make the action unambiguous. It distinguishes itself from sibling status tools by focusing on token-specific 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 provides a prerequisite ('requires TENSORFEED_TOKEN') and mentions it's free, which helps the agent decide if it can use the tool. However, it does not explicitly state when to use this tool versus alternative status tools (e.g., get_ai_status), nor does it give cases where it should not be used. This leaves the agent to infer usage context.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false. Description adds value by disclosing cost and token requirements for longer windows, which is beyond annotation scope. No contradiction.

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

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

Two sentences: first clearly states purpose, second provides key usage constraints. No filler or redundant information. Perfectly front-loaded.

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

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

Despite no output schema, the description explains what the tool returns (daily scores) and covers cost model. For a simple read-only tool with full schema coverage, this is 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 coverage is 100%: all parameters (model, benchmark, days) are described in the schema. The description does not add additional parameter meaning beyond what schema provides, so baseline 3 is appropriate.

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

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

The description clearly states the tool returns daily benchmark scores for a single model+benchmark over a window, and lists valid benchmark keys. This specific verb+resource combination distinguishes it from siblings like compare_models or pricing_series.

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

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

Provides explicit context: days 1-7 free, 8-90 costs 1 credit and requires TENSORFEED_TOKEN. Implies use for trend analysis over longer windows. No explicit exclusions or alternatives, but context is clear.

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

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

Annotations indicate read-only and non-destructive. Description adds behavioral details: preview is free with rate limits, full requires token and credit, and explains output differences between tiers. No contradictions.

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?

Description is well-structured but somewhat lengthy. It prioritizes key information upfront. Minor redundancy could be trimmed, but overall 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?

Given 3 parameters, no required, good annotations, and no output schema, the description adequately covers usage, tier flavors, and output details. Lacks explicit return type info but summarizes 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?

Schema covers all parameters (100% coverage). Description adds meaning: explains tier options, and how benchmark and category filter results. Goes beyond schema by clarifying behavior.

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: a TensorFeed signed ruling on benchmark trustworthiness, outputting a trust band and score. It differentiates from sibling verdict tools by focusing on 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?

Provides explicit guidance on tier selection (preview vs full) with cost and limits, and input options (benchmark, category, or neither). However, lacks direct comparison to sibling verdict tools.

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

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

Adds value beyond annotations by stating the tool costs 1 credit ($0.02) and produces side-by-side rankings. Annotations already confirm read-only and non-destructive nature, so description fills remaining gaps.

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

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

Two concise sentences: first describes the full functionality and value, second states the cost. Every sentence adds essential information without redundancy.

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

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

Given no output schema, the description adequately hints at the output (side-by-side comparison with rankings) but could briefly mention the presentation format. Still sufficient for an AI agent to understand the tool's purpose.

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 100% schema coverage, the description nonetheless adds critical context: the acceptable range of 2-5 models, comma-separated format, and concrete examples of both IDs and display names, making usage unambiguous.

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

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

Clearly states the verb 'Pick between models' and specifies the resource (models) and the provided dimensions (pricing, benchmarks, status, news) with rankings, distinguishing it from sibling tools that focus on individual aspects.

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?

Implicitly clarifies when to use: for multi-model comparison across several criteria, avoiding scraping each provider. Does not explicitly list negative use cases or alternatives, but the sibling context makes differentiation clear.

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

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

The description goes beyond annotations by detailing the cost (1 credit/$0.02), lifetime (90 days), delivery mechanism (HMAC-signed POST to callback_url), and authentication requirement (TENSORFEED_TOKEN). 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 concise (four sentences) and front-loaded with the primary purpose. Each sentence provides essential information: registering a watch, type options, cost/lifetime/auth, and fire mechanism. No redundant 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?

Given 10 parameters (2 required), rich schema, and no output schema, the description covers the core concepts, constraints, and behavioral traits well. It could mention the response format (e.g., watch ID) but is otherwise thorough.

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%, but the description adds value by explaining the meaning of the 'type' enum and how other parameters relate to each type (e.g., 'model' and 'field' for type=price, 'provider' for status/leaderboard_rank). This supplements the schema descriptions.

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

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

The description starts with 'Register a webhook watch,' clearly stating the verb and resource. It then elaborates on what types can be watched (price, status, digest, leaderboard_rank), which distinguishes it from sibling tools like delete_watch or list_watches.

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

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

The description provides clear context on when to use the tool: to register a webhook watch for different event types. It explains each type's purpose but does not explicitly mention when not to use it or contrast with 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 destructiveHint=true and idempotentHint=true; description adds token requirement and cost (free), providing useful context beyond annotations. No contradiction.

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?

Single sentence with no fluff; front-loads action and resource, achieving maximum 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?

Adequately complete for a simple delete tool with one parameter and annotations; lacks error behavior details but minimal impact given idempotency hint.

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 the single parameter with 100% description; the description adds no extra parameter-specific meaning beyond 'by id' and the free/token note.

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 action (delete), resource (webhook watches), and identifier (by id), distinguishing it from sibling tools like create_watch and list_watches.

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

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

The description implies usage for deletion but does not explicitly state when to use it vs alternatives or mention prerequisites beyond the token requirement.

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

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

Beyond annotations (readOnlyHint true), the description discloses internal process (confirms against live feed, fusion, exclusion), tier behavior with return differences, rate limits (10 calls/day per IP for preview), auth requirements (TENSORFEED_TOKEN for full), and cost ($0.02 for full). 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 core purpose, then efficiently covers process, tier details, and requirements. It is packed with information without being verbose.

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

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

Given no output schema, the description explains return values for both tiers in detail (candidate, latency, quality, alternatives, incident, receipt). It also covers credits and auth. Complete for this tool's complexity.

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

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

Schema coverage is 100% and parameters are well-described in the schema. The description adds some context for 'from' (degraded provider) and 'tier' (explains differences), but largely repeats schema info. No new semantics for 'task'.

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

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

The description states a specific verb ('get ruling') and resource ('single best operational provider to fail over to'), clearly distinguishing this tool from siblings like route_verdict by mentioning 'route-verdict fusion' and 'excluded A and any provider already in failover'.

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 when to use (when a provider is degraded) and explains tier differences (preview vs full). However, it does not explicitly compare to alternative tools or state when not to use, which would improve clarity.

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, destructiveHint, idempotentHint, and openWorldHint as true/false. The description adds valuable behavioral context: returns 2-3 best-matching endpoints with path, description, and cost; free and no auth; paid endpoints accessible via x402 or credits token. No contradictions.

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

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

The description is somewhat long but well-structured: it starts with the core purpose, then explains the output and context (many endpoints, paid vs free), and ends with usage advice. Every sentence adds value, though a bit verbose.

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

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

Given the tool's role as a discovery gateway for 100+ endpoints and no output schema, the description thoroughly covers input, output format, authentication, cost, and use case. It is fully self-contained and actionable.

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

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

Schema coverage is 100%, so the schema already describes both 'query' (plain-language) and 'limit' (max endpoints, default 3). The description restates the default and gives examples but adds no new semantic meaning beyond the schema.

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

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

The description uses a specific verb ('discover') and resource ('TensorFeed endpoints') and distinguishes that this is for finding the right endpoint when no dedicated tool fits, clearly differentiating from the many sibling tools.

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

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

Explicitly states 'Use this first when no dedicated tool obviously fits,' providing clear when-to-use guidance. Includes examples of plain-language queries, making usage intuitive.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, openWorldHint=true. The description adds useful context: it aggregates 15+ sources, returns a ranked list, and is free and auth-free. This complements annotations without contradicting them, though pagination or rate limits are not mentioned.

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 consists of two front-loaded sentences. The first sentence states the core purpose and outputs, the second adds context about aggregation and ease of use. No extraneous information.

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

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

Given 3 parameters with full schema descriptions and no output schema, the description adequately explains the tool's function, inputs, and unique value (aggregation). It is complete for an agent to understand 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 100%; all three parameters (category, limit, digest) are described in the input schema. The description only reiterates filterability by category, adding no new meaning beyond the schema. Baseline of 3 is appropriate.

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

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

The description clearly states the verb 'Get' and resource 'latest AI news from TensorFeed.ai', specifies outputs (title, source, URL, snippet, publish time) and filterability by category. It distinguishes from sibling tools (none of which are news-focused) by highlighting the unique aggregation function.

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

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

The description explicitly states when to use: to get a consolidated feed of AI news from 15+ sources, avoiding the need to poll each outlet. It notes 'Free, no auth,' indicating ease of use. It does not mention when not to use or alternatives, but sibling tools are unrelated, so the context is clear.

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

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

Annotations already declare safe read-only behavior. Description adds value by specifying real-time, per-component breakdowns, rollup, and that it's free with no auth, enhancing transparency beyond annotations.

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

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

Three sentences, front-loaded with purpose, then details and usage value. No unnecessary words, 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?

Despite no output schema, description adequately explains return content (per-component breakdowns, rollup). Simple tool with zero params, so completeness is fully achieved.

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

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

No parameters, so schema coverage is 100%. Description doesn't need to add param details but provides helpful context about the output structure, justifying a score above baseline.

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

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

Clearly states it gets real-time operational status of major AI services, lists specific providers, and mentions per-component breakdowns and rollup. Distinguishes itself from sibling tools like 'is_service_down' by emphasizing cross-provider coverage.

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 it's useful before routing requests to a model that may be impaired, and notes it replaces checking each vendor's status page, providing clear when-to-use guidance and implicit 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, destructiveHint=false, idempotentHint=true. The description adds that it is free and requires no auth, which aligns with annotations. No contradictions.

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

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

Two sentences: first defines scope and fields, second adds value and use case. No redundant words, front-loaded with key 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 no-parameter, no-output-schema tool, the description fully covers what the tool returns (specific pricing fields, providers) and its context (free, no auth). Complete for an agent to decide when to invoke.

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

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

There are zero parameters, so the description naturally has no param details. Baseline for 0 params is 4. The description implicitly confirms no input is needed.

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

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

The description specifies the tool's purpose: getting AI model pricing across major providers (Anthropic, OpenAI, Google, Meta, Mistral, Cohere) in one normalized table. It clearly distinguishes from sibling tools like provider_deepdive or pricing_series by offering a cross-provider comparison.

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 advises using this tool for a consolidated pricing view instead of scraping multiple pages. It implies the use case for cost-conscious model selection but does not explicitly mention when not to use it or how it compares to specific siblings.

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

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

Annotations already indicate read-only, idempotent, and open-world behavior. The description adds context about how matching works, including listing available services on no match and providing component-level breakdown. 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?

Three sentences, front-loaded with purpose. Each sentence is useful: purpose, matching behavior, usage guidance, and free/no auth. Could be slightly tighter but effective.

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 health-check tool with one parameter and no output schema, the description covers purpose, behavior, and usage context. Missing details on response format are minor given the tool's simplicity.

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

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

Schema covers the parameter with examples. The description goes beyond by explaining matching behavior and what happens if no match is found, adding value over schema alone.

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 checks the operational status of named AI services, listing examples like 'claude' and 'openai'. It also mentions matching behavior and listing available services on no match, which distinguishes it from siblings like 'get_ai_status'.

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 'so an agent can gate a call on live status before sending traffic', providing a clear use case. It also notes the tool is free and requires no auth, aids in decision-making. However, it does not explicitly state when not to use or mention 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, destructiveHint=false, etc. The description adds that it's free and requires a token, which is useful but not extensive. No contradiction.

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 with no wasted words, front-loading the key action and prerequisites.

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

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

Given the tool has no parameters and annotations cover behavioral traits, the description is complete and sufficient for a simple list operation.

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

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

There are zero parameters, so schema coverage is 100%. The description does not need to add parameter details, and it provides sufficient context.

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 lists active webhook watches owned by a specific token, which is a specific verb+resource and distinguishes it from siblings like create_watch and delete_watch.

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 it's free and requires TENSORFEED_TOKEN, providing clear context for use. It does not explicitly list alternatives, but given sibling names, the usage is well-defined.

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 safe read-only operation. Description adds key context: credit cost, token requirement, and addition of min/max/delta summary for longer windows. No contradictions.

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. First delivers core purpose, second details cost, token, and summary. Front-loaded, no redundancy.

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

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

Adequately explains cost model, token need, and summary addition. Lacks explicit output format description, but given no output schema, the hints are sufficient for a simple data retrieval 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 covers 100% parameters with descriptions. Description adds value by specifying token requirement and output summary behavior not in schema, though partially repeats cost info already present.

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

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

Clearly states it provides 'daily price points for one AI model over a window', indicating time-series data. Mentions free/paid tiers and summary statistics. Differentiates from siblings like 'get_model_pricing' by name and scope, but does not explicitly 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?

Describes when to use (free for 1-7 days, paid for 8-90 days) and prerequisites (TENSORFEED_TOKEN for paid windows). No explicit alternatives or when-not-to-use guidance, leaving selection among siblings implied.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds behavioral details beyond annotations: it aggregates multiple data sources, costs credits, and is premium. No contradictions.

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

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

Two sentences with zero waste. The first sentence packs all key information (what it does, what it replaces). The second adds cost and access constraints. Front-loaded and efficient.

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

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

For a complex consolidated tool with no output schema, the description explains the scope (status, models, news, traffic) adequately. Could mention verbosity or format, but sufficient for understanding.

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?

Only one parameter 'provider' with schema coverage 100%, so baseline is 3. The description does not add parameter details, but the schema already provides examples and case-insensitivity info, making it adequate.

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 'everything about one AI provider' including live status, models with pricing/tier/benchmarks, news, and agent traffic. It explicitly says it replaces four separate lookups, distinguishing it from individual sibling tools like get_ai_status, get_model_pricing, get_ai_news, etc.

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 it costs 3 credits ($0.06) and is 'Strict premium, no free trial', indicating when to use (comprehensive provider info) and a constraint (premium access). It implies not to use individual lookups for this consolidated view, though no explicit exclusions are given.

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

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

Beyond annotations (readOnly, not destructive), the description discloses the scoring method (availability and tail consistency equally), rate limits (10 calls/day/IP for preview), authentication needs (TENSORFEED_TOKEN for full), and the signed receipt feature (AFTA). No contradictions with annotations.

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

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

The description is packed with essential information in a few sentences: purpose, scoring, tier options, pricing, limits, and token link. Every sentence adds value; no fluff. It is front-loaded with the main purpose.

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

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

Given the complexity (scoring, tiers, signed receipts, limits) and absence of output schema, the description adequately explains what the tool returns for each tier, the authentication and payment details, and the reasoning behind the scoring. No obvious gaps remain.

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

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

The single parameter 'tier' is fully described in both schema (enum, description) and the tool description, which adds context about pricing, rate limits, and output differences. Schema coverage is 100%, so baseline is 3; the description adds marginal value, justifying a 4.

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

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

The description clearly states it provides a 'signed dependability ruling' on AI providers, naming the specific output: 'the single most-dependable provider to build on and the riskiest'. It distinguishes from siblings by focusing on provider reliability and mentioning unique features like scoring and signed receipts.

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

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

The description explains when to use each tier ('preview' free vs 'full' paid), including rate limits and token requirements. However, it does not explicitly compare to sibling tools (e.g., failover_verdict, benchmark_trust_verdict) or state when not to use this tool.

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

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

Beyond annotations (readOnlyHint=true), the description adds critical behavioral context: it is a paid operation (credit cost), has rate limits (10/day for preview), requires authentication for full tier (TENSORFEED_TOKEN), and describes output contents (reasoning, runners-up, signed 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 concise (three sentences) and front-loaded with the tool's purpose. It efficiently covers multiple aspects (purpose, tiers, costs, auth) without unnecessary verbosity. Slightly dense but acceptable.

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

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

For a complex tool with 8 parameters and no output schema, the description provides substantial context: data sources, tier behavior, constraints, authentication, and output summary. Missing details on exact output format, but overall sufficient for an agent to decide and invoke correctly.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds marginal value beyond the schema, such as explaining tier differences and that task or model must be provided. The schema already adequately documents all 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 returns a signed model-routing decision, specifying it fuses multiple data sources (pricing, benchmarks, latency, etc.) to recommend the single best model for a task or named model. It distinguishes between free preview and paid full tiers, avoiding tautology and providing specific verb+resource.

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

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

The description explains when to use (for model routing decisions) and provides context on tier costs, rate limits, and authentication needs. However, it does not explicitly mention when not to use or list alternative sibling tools (e.g., failover_verdict, benchmark_series), leaving some ambiguity for the agent.

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

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

The description goes beyond annotations (readOnlyHint: true, etc.) by detailing the exact behavioral differences between tiers: preview returns decision points and provenance without the computed decision; full adds the computed Act/Attend/Track/Track* decision, per-level reasoning, CISA KEV cross-check, and AFTA-signed receipt. It also discloses rate limits, credit cost, and authentication requirements, providing full transparency.

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

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

The description is well-structured but somewhat lengthy. It is front-loaded with the main purpose and uses clear sections for tiers. Every sentence adds value, but could be slightly more concise. Still, the information density 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 having no output schema, the description fully explains what each tier returns, including the decision points, provenance, computed decision, envelope, reasoning, KEV cross-check, and receipt. It also covers rate limits, costs, and authentication. Given the tool's complexity and the absence of an output schema, the description is complete enough for an agent to use correctly.

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

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

Schema coverage is 100%, but the description adds significant meaning beyond the schema. For the 'tier' parameter, it explains what each value returns and the associated cost/authentication. For the 'cve' parameter, it clarifies it's required and gives an example. This added context helps the agent understand the trade-offs and prerequisites.

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: 'TensorFeed's signed SSVC patch-urgency decision for one CVE'. It explains the two tiers (preview returns decision points and provenance; full adds computed decision, envelope, reasoning, KEV cross-check, receipt). This is specific and distinguishes it from sibling verdict tools like failover_verdict or stack_safety_verdict.

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 guidance on when to use each tier: preview is free but rate-limited (10 calls per day per IP), full costs 1 credit and requires a TENSORFEED_TOKEN. It explicitly states the required CVE id. While it doesn't explicitly say when not to use this tool (e.g., for other CVE lookup tools), the tier differentiation and requirements give strong usage context.

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

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

Adds significant context beyond annotations: fusion of CVE batch with KEV catalog, conservative design, tier differences, token requirement, and call limits. 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?

Single paragraph that is dense but not overly long. Front-loads main purpose. Could be more structured, but information is well-packed with minimal 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?

Covers inputs, gate logic, tier behavior, and output components reasonably. Missing explicit output structure format, but given no output schema and low parameter count, description 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?

Schema coverage is 100%, so baseline is 3. The description adds extra detail: 'preview' is free with caps, 'full' costs credit and includes evidence, and packages format is explained. Adds value beyond schema.

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

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

Describes a specific verb ('get gate') and resource (AI software stack packages). Clearly states output: overall BLOCK/HOLD/PASS/UNKNOWN gate plus per-package verdict. Distinguishes from siblings by focusing on AI-stack safety, not general benchmark or SSVC verdicts.

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?

Explains when each gate applies (BLOCK on exploited with no fix, HOLD on known CVE, etc.) and tier limitations. However, no explicit comparison to alternative tools like ssvc_verdict or benchmark_trust_verdict.

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 behavior, and the description adds valuable context: it computes from minute-resolution counters, and for longer windows returns additional fields (incident_count, mttr_minutes). It also discloses cost and token requirements, going beyond what annotations provide.

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

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

The description is concise with two sentences, each sentence adds value: first explains the main purpose and data source, second explains parameter behavior and prerequisites. 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?

Given the simple input and no output schema, the description covers input behavior, costing, and additional data, but fails to describe the output format (e.g., list of providers with uptime percentages). The agent would need to infer or test the response structure.

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

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

The schema description for the 'days' parameter is complete, and the tool description adds significant meaning by linking the parameter value to free/paid tiers, credit cost, and additional returned fields. This helps the agent understand the impact of the parameter value.

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 is a cross-provider uptime leaderboard ranked by uptime % descending. The purpose is specific and conveys the resource and action. However, it does not differentiate from sibling tools like status_uptime, which might also provide uptime information.

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 usage context by explaining free vs paid windows and the need for a TENSORFEED_TOKEN for longer periods, but does not explicitly state when to use this tool versus alternatives or 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 indicate readOnlyHint=true, and the description confirms a read operation. It adds value by disclosing the cost structure and token requirement for longer windows, as well as the degradation half-credit rule, which is a behavioral nuance not in annotations.

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

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

Two sentences, no redundant words. The first sentence clearly defines the function and output; the second covers key usage constraints. Every sentence adds 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?

Despite no output schema, the description adequately explains the return values (day counts, uptime %, per-incident details for longer windows). It also covers authentication and pricing, making it complete for a simple 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%, baseline 3. The description adds pricing and detail context for the 'days' parameter (free vs. paid, per-incident-day detail) that goes beyond the schema's basic description.

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

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

The description clearly states the tool computes a 'daily uptime rollup for one provider over a window' with specific outputs (operational/degraded/down counts and uptime %). It distinguishes from sibling tools like status_leaderboard by focusing on a single provider.

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

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

The description explains when to use different window lengths (free for 1-7 days, paid for 8-90 days) and the need for a TENSORFEED_TOKEN. However, it does not explicitly contrast with sibling tools 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 declare readOnlyHint=true and destructiveHint=false, ensuring safe operation. The description adds useful behavioral context, such as the cost of 1 credit and the broad scope of data returned, without contradicting annotations.

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

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

The description is extremely concise: two sentences clearly conveying purpose, scope, and cost. No redundancy or unnecessary details.

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 lacking an output schema, the description thoroughly explains the tool's return content (pricing, models, status, news) and use case. It is complete for a read-only overview tool given the sibling context.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds context about the window and content but does not significantly enhance understanding beyond what the schema already provides.

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

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

The description clearly states the tool's purpose: to provide a comprehensive summary of recent AI changes including pricing, models, status incidents, and news within a configurable time window (1-7 days). This distinguishes it from more specific sibling tools like get_ai_news or get_model_pricing.

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

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

The description implies usage for initializing agent context with current AI updates, and mentions cost. However, it does not explicitly state when not to use the tool or provide alternatives, leaving room for ambiguity.

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

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

Annotations indicate read-only and open-world. The description adds critical behavioral details: rate limits (10 free calls/day/IP), cost structure (1 credit for full), additional data for full tier, and the need for token/auth. No contradictions.

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 relatively long but well-structured, starting with the purpose, then detailing tiers. Every sentence adds value, though some minor redundancy could be trimmed. Still, it is clear and informative.

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

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

Given the complexity (two tiers, pricing, rate limits, auth) and no output schema, the description covers prerequisites, output expectations, and links to get credits. Slightly lacking in exact output format, but sufficient for an agent to use correctly.

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

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

Schema coverage is 100% and description adds meaningful context: tier parameter is explained with free vs paid, example domain given, and required domain is emphasized. The description significantly enhances understanding beyond the schema.

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

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

The description clearly states the tool provides a signed trust verdict on a specific x402 publisher, listing possible outcomes (actively settling, quiet, etc.), and distinguishes it from sibling tools like x402_settlement_verdict.

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

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

The description explains the domain requirement, tier options with pricing and rate limits, and mentions the need for a token for the full tier. It does not explicitly state when not to use it, but provides clear context for appropriate use.

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

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

Annotations declare read-only, non-destructive, open-world. The description adds that it's a signed ruling computed over its own index, forward-only from launch, with rate limits and cost details, providing useful context beyond annotations.

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

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

The description is front-loaded with purpose, followed by tier details. It is slightly verbose but each sentence adds value, making it appropriately concise 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 outlines what each tier returns but not the exact structure or format. For a data-providing tool, this could hinder an agent's ability to parse the response, though the description covers key aspects.

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

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

Schema coverage is 100%, baseline 3. The description adds detail on tier costing, rate limits, token requirement, and window defaults, providing marginal but useful additional meaning beyond the schema.

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

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

The description clearly states the tool provides a signed ruling on the x402 USDC settlement market on Base, covering momentum, concentration, and leading publisher. It distinguishes itself from the sibling x402_publisher_verdict by focusing on the overall market, though not explicitly contrasting.

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

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

The description explains when to use preview vs full tiers based on need for details and cost. However, it does not discuss when to use this tool over siblings or provide explicit 'when-not-to-use' guidance.

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