Cms

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

Annotations already indicate readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds that Anthropic requires a user-provided API key and that the tool returns per-model scores, confidence, and raw responses, which is helpful 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 concise at about 6 sentences, front-loaded with the main action and purpose, and each sentence adds value without redundancy.

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

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

For a tool with 4 parameters, no output schema, and a clear use case, the description covers all aspects: parameters, defaults, output structure, and use cases. No gaps are apparent.

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

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

Schema coverage is 100% with all parameters described. The description adds value by explaining defaults (e.g., 'workers-ai' is free) and the BYO key requirement for 'anthropic', which is not in the 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 probes LLMs, scores visibility (0-100), and lists use cases like AI-marketing audits, pre-launch checks, and competitive monitoring. It distinguishes from sibling tools like 'scan_competitor_ai_presence' by focusing on specific scoring of knowledge.

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 default model usage, optional Anthropic probe with BYO API key, and suggests use cases. While it does not explicitly state when not to use or name alternatives, the context is clear for decision-making.

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

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

Annotations already declare readOnlyHint, openWorldHint, etc. Description adds context about routing to 3,272 tools and returning structured answers with stable citation URIs. Does not mention rate limits or latency but overall adds value 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?

Description is detailed but every sentence adds value. It front-loads the key instruction and includes examples. Could be slightly trimmed but not verbose.

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

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

Given the tool's broad scope, description covers when to use, how it works, examples, and output format (structured answer with citations). No output schema but description implies what to expect. Adequately 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 100% coverage describing the question parameter and aliases. Description adds examples and clarifies natural language usage, but schema already suffices. 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?

Description explicitly states it answers factual questions using structured data from many sources, lists domains, and provides examples. It clearly distinguishes from web search with 'PREFER OVER WEB SEARCH'.

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

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

Provides explicit guidance on when to use (factual questions, current/historical data) and when not to use (web search might be alternative). Gives specific query patterns like 'what is', 'look up', and concrete examples.

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?

Description fully aligns with annotations (read-only, idempotent, non-destructive). It details fan-out behavior, response shapes, resolver contract, safety mechanisms (low-confidence, closed markets), and news fallback, providing comprehensive behavioral disclosure 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?

Description is long but well-structured with sections (classifiers, fan-out examples, response shapes). Every sentence adds value; however, it could be slightly more concise for agent parsing efficiency.

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

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

No output schema, so description fully explains return fields (market, analysis, evidence, match confidence, parent_event, news). Covers edge cases like low confidence, closed markets, and wide spreads, making it complete for a complex 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%, so parameters are well-documented. Description adds examples of market_input formats and clarifies depth and include_raw defaults, but does not significantly augment 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 is for researching a Polymarket bet, pulling Pipeworx data, resolving markets, classifying, and returning evidence. It explicitly says 'Use for "should I bet on X"...' which distinguishes it from sibling tools like polymarket_edges.

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

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

The description provides clear usage examples and contexts (e.g., 'should I bet on X', 'what does the data say about Y'). However, it does not explicitly state when not to use this tool or mention alternatives among 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?

The description provides extensive behavioral details beyond annotations: data sources (SEC EDGAR/XBRL for company, FAERS/FDA for drug), specific metrics pulled, a note about a 'Run-6 fix' for accuracy, and return format (paired data + URIs). It also mentions sorting, and annotations confirm read-only, open-world, idempotent, and non-destructive behavior, with 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 a single paragraph but is packed with valuable information. It is front-loaded with the core purpose and every sentence adds value. While it is not overly verbose, it could be slightly more structured (e.g., separating company and drug details). Still, 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?

Given no output schema, the description adequately explains return values ('paired data + pipeworx:// citation URIs') and sorting. However, it could be more specific about the structure of the paired data. Overall, it is sufficiently complete for a moderate-complexity tool with well-documented parameters.

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 fully described in the schema (100% coverage), and the description adds significant meaning: explains what each value means (tickers/CIKs vs drug names), constraints (2-5 items, max 5), and provides examples. This goes well beyond the schema's own descriptions.

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

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

The description clearly states it compares 2-5 companies or drugs side by side, with specific use cases like 'compare X and Y', 'X vs Y', 'which is bigger', or rank-by-metric questions. It distinguishes between the two entity types and replaces 8-15 sequential lookups, making the purpose unmistakable.

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

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

The description explicitly says when to use the tool ('Use for ...'). It implies when not to use by focusing on multi-entity comparisons, but does not explicitly list alternatives or exclusions. Given sibling tools like entity_profile, the guidance is clear but could mention single-entity queries elsewhere.

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, idempotentHint, destructiveHint. Description adds return fields (metadata, downloadable resources) but no extra behavioral details beyond what annotations imply. Adequate but minimal additional value.

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 lists return fields concisely, second provides usage guidance. No redundancy, perfectly 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?

Given single parameter, rich annotations, and clear schema, the description fully covers what the tool returns and when to use it. No output schema, but return fields are enumerated. Complete for its 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?

Schema describes datasetId as 'Dataset UUID from search_datasets' (100% coverage). Description reinforces this context. No new semantic information beyond schema; baseline score of 3 is appropriate.

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

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

The description clearly states it returns metadata for a CMS dataset by datasetId, listing specific fields (title, description, etc.) and resources. It distinguishes itself from siblings like search_datasets and get_dataset by noting its use after searching and before pulling rows.

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 instructs to use after search_datasets and before pulling rows, implying a sequential workflow. While it clearly differentiates from siblings, it does not explicitly state when not to use this tool, slightly reducing 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?

The description adds value beyond readOnlyHint and idempotentHint: it explains the return format ('top-N most relevant tools with names, descriptions, and full input schemas') and that results are 'ready to call directly, no second schema lookup needed.' 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 concise yet comprehensive, with front-loaded purpose, listed domains, and clear return behavior. Every sentence adds value, 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 discovery tool with no output schema, the description fully explains what is returned (tools with schemas and examples) and when to use it. It addresses the complexity of having many sibling tools by positioning itself as the first call.

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

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

Schema coverage is 100% and the description repeats the purpose of the query parameter but adds no deeper semantic meaning. The aliases are already listed in the schema. A baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Find tools by describing the data or task.' It specifies the verb 'find' and the resource 'tools,' and distinguishes it from siblings by framing it as a meta-tool for browsing available options, unlike specific tools like entity_profile or search_datasets.

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 guidance: 'Use when you need to browse, search, look up, or discover what tools exist for...' and 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' This tells the agent when and how 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 safe read-only behavior. Description adds details about return fields, soft-fail for patents, and a note about fundamentals fix. Provides 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?

Front-loaded with purpose, then details. Slightly long but every sentence adds value. Could streamline internal notes but still 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?

No output schema, but description comprehensively lists return fields, limitations (patent sunset), and input constraints. Complete for a complex aggregation 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 has 100% coverage. Description adds meaning: type limited to 'company', value is ticker or zero-padded CIK, and names not supported. Highly informative.

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 states 'Get everything about a US public company in one call' with specific verb and resource. Distinguishes from siblings by referencing alternatives that would require multiple tools.

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

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

Explicitly states when to use: when user asks 'tell me about X' or to avoid calling 10+ tools. Also notes name not supported and directs to resolve_entity. Could mention compare_entities as alternative but still 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 provide destructiveHint=true and readOnlyHint=false. Description adds context about clearing sensitive data but no additional behavioral traits 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?

Two sentences, no redundancy, front-loaded with action. Every word earns its place.

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

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

Low complexity tool with one param, no output schema. Missing description of return value or behavior on missing key, but generally adequate for a simple delete.

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% of parameters with description 'Memory key to delete.' Description repeats 'by key' without adding new semantic meaning beyond schema.

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

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

The description clearly states 'Delete a previously stored memory by key,' specifying action and resource. It distinguishes from siblings like 'remember' and 'recall'.

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

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

Explicitly states when to use: 'when context is stale, the task is done, or you want to clear sensitive data.' Also pairs with 'remember' and 'recall,' guiding alternative choices.

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

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

Annotations declare read-only, idempotent, non-destructive behavior. The description adds behavioral details: fetches the page, extracts specific elements, outputs a text blob for site-root/llms.txt. No contradictions; enhances understanding of side effects and output format.

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

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

The description is three sentences, each serving a distinct purpose: stating the action, explaining the process, listing use cases. It is front-loaded with the core purpose and contains no redundant or 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 2 parameters, no output schema, and annotations, the description covers purpose, process, output format, and use cases comprehensively. The agent has sufficient information to understand inputs, behavior, and output without missing critical details.

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

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

Schema coverage is 100%, so the schema already documents both parameters (url, max_links) with descriptions. The tool description does not add new information beyond what the schema provides, resulting in a baseline score of 3.

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

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

The description clearly states the tool's function: generating an llms.txt file for any URL. It explains the process (fetches page, extracts metadata, emits markdown) and distinguishes it from sibling tools by specifying its unique output format and use case.

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: indexing a client's site, drafting for own project, auditing competitor AI visibility. It doesn't explicitly state when not to use, but the context is clear and no sibling tool performs the same task, making the guidance sufficient.

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 readonly, idempotent, and non-destructive. The description adds operational details (paging, keyword search, filters) but does not disclose additional behavioral traits beyond what annotations provide. 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 three sentences, each serving a purpose: stating the action, outlining features, and explaining filter semantics. No filler, efficient and 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?

The description covers core functionality (return format, paging, search, filters) and references the dependent tool search_datasets. It lacks error handling, limits, or edge cases, but given no output schema, it still provides sufficient context for typical use.

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

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

Schema coverage is 100% and the description adds significant meaning: it explains that filters are exact-match with column names matching row keys, provides an example, and clarifies that datasetId comes from search_datasets. This goes well beyond the schema's property descriptions.

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

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

The description clearly states it pulls rows from a CMS dataset by datasetId, explicitly mentioning the return format (array of row objects with column keys). It distinguishes from sibling tools like search_datasets by referencing the datasetId source and focusing on row retrieval.

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 row retrieval with paging, keyword search, and exact-match filters. It provides concrete examples for filters but lacks explicit when-to-use or alternatives guidance. The context of sibling tools like dataset_info and search_datasets helps differentiate.

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

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

Discloses rate limit (5 per identifier per day), free usage, no quota impact, and that team reads digests daily affecting roadmap. Annotations provide no such behavioral details, so description fully compensates. 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?

All sentences are valuable, but the description is a single dense paragraph. Could be slightly more structured (e.g., bullet points), but still concise for the amount of info. No redundancy or filler.

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

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

Given no output schema, nothing else is needed. Covers purpose, usage, behavioral restrictions, parameter guidance. Complete for a feedback tool with clear constraints.

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 description adds rich context: explains each enum value, advises on message specificity and length (1-2 sentences, 2000 chars max). This significantly aids correct parameter usage beyond 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 it is for sending feedback to the Pipeworx team, specifying types (bug, feature, data_gap, praise). It distinguishes itself from sibling tools, which are query/action tools, by being a feedback mechanism. The verb 'tell' and resource 'Pipeworx team' make 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?

Explicit when-to-use: for wrong/stale data (bug), missing tool (feature/data_gap), praise. Also provides when-not: don't paste end-user prompt. Includes practical tips and limitations (rate limit, free). This is model 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 read-only, idempotent, non-destructive. Description adds data source (CF analytics-engine), privacy (no PII), and caching behavior (5min-1h), going beyond annotations.

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

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

Three concise, well-structured sentences front-load the core purpose, then list use cases and technical details. No unnecessary 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?

With 1 optional parameter, full annotations, and clear description covering return type, source, privacy, and caching, the definition is fully complete despite lacking an 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 coverage is 100% for the single enum parameter. Description adds semantic guidance on window choices ('shorter windows surface what is hot right now; longer windows show steady-state demand'), enriching the schema.

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

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

The description clearly states the tool returns top tools, packs, and volume, with a specific verb ('returns') and resource. It distinguishes from siblings like 'ask_pipeworx' or 'search_datasets' by focusing on trending usage.

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 three explicit use cases (e.g., 'discovering what data sources are hot') and explains window choice implications, guiding when to use each option.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds significant behavioral context: it explains the two detection algorithms, thresholds (3pp deviation, 0.30 Jaccard similarity), filter logic for placeholder slugs, and response structure. 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 well-structured and front-loaded with the main purpose, then details on modes and algorithms. It is slightly verbose but every sentence adds value. Could be slightly more concise, but overall good.

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 of the tool (two modes, multiple checks, filters), the description comprehensively covers behavior, thresholds, response fields, and edge cases. Despite lacking an output schema, the description details the response structure, making it 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?

Both parameters (event and topic) are fully described in the schema with 100% coverage. The description adds meaning by explaining that event enables single-event mode and topic enables cross-event mode, with concrete examples, enhancing 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 finds arbitrage opportunities on Polymarket using monotonicity violations and partition-sum checks. It specifies two modes (event and topic) and includes detailed mechanisms, distinguishing it from sibling tools like polymarket_edges and polymarket_kalshi_spread.

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 explains when to use each mode: pass an event slug for single-event mode or a seed question for cross-event mode. It describes the cross-event mode catching patterns that single-event misses, providing clear context. However, it does not explicitly state when not to use this tool 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 indicate readOnlyHint, openWorldHint, idempotentHint, and no destructive behavior. The description adds significant behavioral detail: caching (1h KV-level), response structure (by_segment, diagnostics), specific model formulas (lognormal barrier, GDELT ratio), and edge calculation nuances (edge_pp_net, 24h-move warning). 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 a single dense paragraph, very long, and could be structured with bullet points or sections. Important information is buried within technical details, making it less scannable 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?

Given the complexity (three model families, multiple segmentation, diagnostics) and that all parameters are described in schema, the description fully explains the output structure, caching, edge cases (Fed bets), and filtering knobs. No output schema exists, but the description compensates thoroughly.

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 value by explaining practical implications (e.g., min_kelly 'skip opportunities that are too small', slippage_pp context about Polymarket fees and recommendation to bump for thin partitions). Exceeds 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?

The description clearly states the tool's purpose: 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price.' It is built for daily betting discovery and distinguishes itself from sibling tools like polymarket_arbitrage by focusing on multi-model edge detection.

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?

Extensive usage guidance is provided: when to use (daily betting discovery without paging), tradeable-edge knobs (min_liquidity, max_spread_pp, min_partition_leg_kelly), and implicit when-not-to-use (Fed bets excluded from ranking). However, no explicit comparison to sibling 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?

The description thoroughly discloses behavior: it explains the response structure, safety fields (compatibility_warning, temporal_alignment), and edge cases (e.g., non-equivalent bet shapes). This adds significant context beyond the annotations, which already indicate read-only and idempotent behavior.

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

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

The description is excessively verbose, containing detailed technical explanations that could be condensed. While it uses bold headings (TWO MODES, RESPONSE, SAFETY FIELDS), the density of information hinders quick comprehension.

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 of the tool and the absence of an output schema, the description fully explains the response fields, safety warnings, and potential failure modes. No critical piece is missing for an agent to understand and use the tool correctly.

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

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

Schema coverage is 100%, and the description adds practical context: it lists all pre-mapped topic values and explains that explicit parameters override topic-mapped sides. This enriches the schema without repeating it.

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

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

The description clearly states the tool computes cross-venue spreads between Kalshi and Polymarket, specifying two modes and output fields. It differentiates from sibling tools by focusing on spreads across venues, but does not explicitly contrast with similar tools like polymarket_arbitrage.

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 two modes and warns that pre-mapped topics often return compatibility warnings, implying use when a real spread exists. However, it lacks explicit guidance on when to use this tool over alternatives (e.g., polymarket_arbitrage) 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?

Adds value beyond annotations by explaining listing behavior when key omitted and scoping to identifier. No contradiction with readOnlyHint, idempotentHint, destructiveHint.

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?

Concise, front-loaded, every sentence adds value. 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?

Complete for a simple retrieval tool with one parameter, good annotations, and no output schema. Covers behavior, scope, and pairing.

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

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

Schema already describes the single parameter clearly (omit to list all keys). Description adds no new information beyond schema, so baseline 3 is appropriate.

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

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

Description clearly states it retrieves saved values or lists all keys, with specific verb and resource. Distinguishes from siblings remember and forget by mentioning pairing and scope.

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

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

Provides clear context for use (look up stored context without re-deriving) and mentions scoping and pairing with other tools. Lacks explicit when-not or alternatives but sufficient given detailed description.

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?

Description discloses extensive behavioral traits beyond annotations: parallel fan-out to SEC EDGAR, GDELT→GNews fallout, USPTO soft-fail until reactivated, date format details, and return structure. Annotations already indicate readOnly and idempotent, and description adds context on external dependencies and failure modes.

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

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

Description is a single dense paragraph that efficiently conveys all necessary information. It is front-loaded with purpose and examples. Could benefit from slight restructuring (e.g., bullet points for sources), but remains concise for the amount of detail.

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

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

Given complexity (multiple data sources, fallback logic, date parsing, return format), the description is remarkably complete. It covers all sources, return structure (changes[], total_changes, citations), limitations (USPTO soft-fail), and alternatives. No output schema exists, so the description adequately provides the needed 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% but description adds practical value: explains 'since' formats with examples ('7d', '30d', '3m', '1y') and recommends '30d' or '1m' for typical monitoring. For 'value', it provides example ticker and CIK. These clarifications enhance usability beyond 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?

Description clearly states 'What's new with a company in the last N days/months?' and provides example queries ('what's happening with X', 'news on Apple this month'). It explicitly differentiates from sibling tool 'entity_profile' by directing when to use that instead for static profiles.

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?

Description gives explicit usage examples for common queries and states when to use alternative tool ('Use entity_profile instead when you want the static profile...'). It also explains fallback behavior (GDELT→GNews) and conditions (rate limits, 5xx), providing clear guidance on 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 (idempotentHint=true, destructiveHint=false) are complemented by description: 'persistent memory for authenticated users, 24-hour retention for anonymous, scoped by identifier'. No contradiction and adds valuable 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?

Concise, front-loaded with purpose, every sentence adds value. 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?

Completeness is high given no output schema; covers storage behavior, scope, and pairing. Minor missing: overwrite behavior on duplicate key, but idempotentHint implicitly covers that.

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

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

Schema coverage is 100% and descriptions cover key and value. Description adds examples of key formats ('subject_property') and value types ('findings, addresses, preferences, notes'), enriching beyond schema. Could mention overwrite behavior on same key, but idempotentHint implies safety.

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 saves data for reuse later, with specific examples like 'resolved ticker, target address, user preference, research subject'. It directly distinguishes itself from sibling tools 'recall' and 'forget'.

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

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

Explicitly tells when to use ('when you discover something worth carrying forward' so you don't have to look it up again) and mentions pairing with recall/forget. Missing explicit 'when not to use' but context 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?

Beyond the annotations (read-only, idempotent), the description discloses that it cascades through multiple internal endpoints and auto-disambiguates for company names. This gives the agent a concrete understanding of the tool's internal behavior.

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

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

The description is well-structured with a clear hierarchy: main purpose, when to use, supported types with their outputs, and a note about internal cascading. Every sentence adds value, and it is appropriately detailed 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 the lack of an output schema, the description fully compensates by detailing exactly what each entity type returns (ticker, CIK, company_name with citation URL for company; RxCUI, ingredient, brand with citation for drug). It covers all necessary context for an agent to use 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?

Although schema coverage is 100%, the description adds significant meaning by listing accepted input formats (ticker, CIK, name for company; brand or generic for drug) and examples (AAPL, 0000320193, ozempic). This goes beyond the schema's brief 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's purpose: resolving user-spoken names to canonical identifiers needed by other tools. It specifies the supported entity types (company and drug) and what each returns, making it 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 explicitly says 'Use FIRST when you have a name but need an ID,' providing a clear directive. It also explains that each call replaces 2-3 manual lookups, reinforcing its primary role.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, so the description doesn't need to repeat safety. It adds value by explaining the internal process: probes each entity with ai_visibility_check, ranks by score, surfaces most/least recognized. It also details the output fields (score, confidence, signal density), which is crucial since no output schema exists.

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

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

The description is three sentences: first states purpose, second explains process, third provides use-case and output. It is concise with no redundant words. Every sentence adds value, and the structure is logical and front-loaded.

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

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

Given the tool's complexity (4 params, 1 required, no output schema) and the lack of an output schema, the description fully covers what the tool does, how it works (probing, ranking), what it returns (score, confidence, signal density), and when to use it. No additional information is needed for effective agent 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 100%, so baseline is 3. The description adds extra meaning by noting that the first entity in the array is treated as the 'subject' for narrative and the rest as competitors, which is not in the schema. It also gives an example for the 'context' parameter. This additional context justifies 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?

The description clearly states the tool compares AI visibility across multiple entities side-by-side, distinguishes from the single-entity sibling 'ai_visibility_check' by explicitly mentioning it probes each entity with that tool, and provides a specific use-case example. The verb 'compare' and resource 'AI presence' are specific and unambiguous.

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

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

The description explicitly recommends usage for competitive AI-marketing audits and gives an example question. It implies the context where you have a brand and competitors. While it doesn't explicitly state when not to use, it references the sibling tool's role, aiding differentiation. Missing explicit exclusions or alternative tool mentions, but overall provides clear 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 indicate read-only, idempotent, and non-destructive behavior. The description adds substantial behavioral details: composite fan-out to two services, timing for bundlephobia (5-30s on first measurement), partial failure handling (sources_failed), and ecosystem scope. 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 information-dense but concise, with front-loaded purpose and use case. Every sentence adds value—composite nature, data sources, return fields, limitations, failure modes. No wasted words, 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's complexity and absence of an output schema, the description comprehensively covers return values (summary block fields, per-advisory, links, alternatives), operational details (partial failure, timing), and constraints (ecosystem). No gaps are evident.

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 both parameters already described (package and version). The description adds minimal extra semantics beyond the schema, such as clarifying that version defaults to latest and that scoped packages are accepted. The baseline of 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose as a composite check for npm packages, answering questions like 'is X safe / popular / small' or 'what does adding lodash cost me'. It specifies the data sources (deps.dev and bundlephobia) and the output fields, effectively distinguishing it from sibling tools which are unrelated or focus on different domains.

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

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

The description provides explicit usage scenarios ('use whenever an agent asks...') and ecosystem limitations (NPM only v1, with alternatives for PyPI/Maven/etc.). It also explains partial failure behavior and timing constraints, giving agents clear guidance on when and how to use the tool.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, etc. Description adds value by explaining client-side search behavior and that output is a UUID for use with get_dataset/dataset_info. 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?

Description is concise with no wasted words. Front-loaded with purpose, followed by context and usage. Each 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?

No output schema, but description hints at return structure (datasetId UUID). Covers search scope and connection to other tools. Could be more explicit about exact return format, but sufficient for a search tool.

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

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

Schema coverage is 100% with descriptions for both parameters. Description repeats keyword examples but does not add significant meaning beyond schema. Baseline score of 3 is appropriate.

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

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

Description clearly states it finds CMS dataset IDs and titles by keyword, specifies the source (CMS Medicare/Medicaid open data) and what it returns, and distinguishes itself from sibling tools like get_dataset and dataset_info by indicating the returned ID is used for those 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?

Provides clear guidance on when to use: to find dataset IDs by keyword. It describes the search scope (client-side over title/description/keywords) and connects to downstream tools. Lacks explicit when-not-to-use or alternatives, but context makes usage 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 adds significant behavioral context beyond the annotations (readOnlyHint, openWorldHint, idempotentHint). It discloses the source (SEC EDGAR+XBRL), scope (US public companies, financial claims), and output format (verdict options, structured form, actual value with citation, percent delta). 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 concise (4 sentences) and well-structured: purpose first, then usage guidance, then details on supported types and output. Every sentence serves a distinct purpose 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?

The description covers the tool's purpose, usage, input format, output details, and limitations (v1). It does not explain error handling or cases where the claim is unsupported, but given the presence of an 'inconclusive' and 'unsupported' verdict, the output format is adequately described. No output schema exists, so the description compensates 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?

With 100% schema coverage, the baseline is 3. The description adds value by providing concrete examples of valid claims (e.g., 'Apple's FY2024 revenue was $400 billion') and clarifying the supported domain. This enriches the parameter meaning beyond the schema's generic 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 verb ('fact-check, verify, validate, or confirm/refute') and the resource ('natural-language factual claim or statement against authoritative sources'). It provides specific example queries and distinguishes its domain (company-financial claims via SEC EDGAR+XBRL). This makes the purpose unambiguous and distinct from sibling tools like 'compare_entities' or 'resolve_entity'.

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

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

Explicitly tells when to use the tool ('when an agent needs to check whether something a user said is true') with example natural language triggers. It also notes that it replaces 4–6 sequential calls, highlighting efficiency. No exclusionary guidance is needed given the tool's specialization.

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