Fda Regulations

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

Description aligns with annotations (readOnlyHint, idempotentHint, destructiveHint=false). It adds behavioral details: return structure (score, confidence, signals, raw_response), model probing behavior, and API key handling. 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 4 sentences, front-loaded with the core purpose. Every sentence adds value without redundancy. Efficient and structured.

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

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

Despite no output schema, the description details return fields. Parameter behavior and use cases are fully covered. For a probing tool, this is complete and informative.

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%. Description adds meaning beyond schema: explains default model, the role of _apiKey for Anthropic, and context parameter's disambiguation purpose. This significantly aids understanding.

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

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

Description clearly states the tool probes LLMs for knowledge about an entity and scores visibility (0-100). It specifies the verb 'Probe', resource 'LLMs', and the output format. It distinguishes from siblings like 'scan_competitor_ai_presence' by focusing on any entity and providing visibility scoring.

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 lists use cases: 'AI-marketing audits, pre-launch brand checks, competitive monitoring.' It also gives model selection guidance, including default model and BYO key for Anthropic. This provides clear context for when to use the tool.

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

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

Annotations already indicate a safe read-only, idempotent operation. The description adds value by disclosing that the tool routes to many sub-tools, returns structured answers with stable citations, and handles live news. It does not contradict annotations and provides enough extra behavioral context for an agent to set expectations.

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

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

The description is long but each sentence is informative: preference, routing, examples, hierarchy, and alternatives. It is front-loaded with the key directive 'PREFER OVER WEB SEARCH' and ends with sibling differentiation. Minor redundancy (e.g., re-listing domains) keeps it from a perfect 5.

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

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

For a complex routing tool with no output schema, the description is complete: it covers purpose, usage triggers, examples, source categories, citation behavior, and when to use alternatives. It includes enough context for an agent to decide to invoke it for most factual queries.

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

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

Schema description coverage is 100%, with all aliases documented. The description adds example questions and context about acceptable queries, but it does not explain parameter syntax or formatting beyond what the schema provides. Baseline 3 is appropriate because the schema carries the semantic load.

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

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

The description explicitly states the tool routes questions to one of 5,566 tools across 1,462 verified sources and returns structured answers with citation URIs. It clearly distinguishes itself from siblings like ask_pipeworx_grounded and deep_research, and includes a specific verb ('routes') plus resource scope.

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

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

The description gives explicit when-to-use guidance ('PREFER OVER WEB SEARCH', 'START HERE for most questions') and names alternatives ('ask_pipeworx_grounded', 'deep_research') with conditions for stepping up. It also lists example queries and triggers like 'what is', 'look up', 'current'.

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 well beyond the annotations by explaining that this is an experimental edge with live candidate routing improvements, that results are compared against the stable router, and that there is currently no active candidate. It also corrects the potential misconception that beta means fallback by explicitly stating it is a full working router.

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 identity and current beta status, and it includes several useful caveats in a compact paragraph. It is slightly longer than necessary because details like the exact retirement date and the count of tools may go stale and do not help the agent invoke the tool; the core point could be tightened.

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

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

Given the high schema coverage and the use of ask_pipeworx as a stable reference, the description covers purpose, experimental status, current behavior, and non-fallback semantics. It does not describe the response shape in detail, but the 'same response shape' reference to ask_pipeworx is probably sufficient since no output schema is available.

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

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

The input schema already documents all parameters at 100% coverage, including question and its five aliases, so the schema carries the semantic burden. The description only says the arguments match ask_pipeworx, which adds no material detail beyond the schema. Baseline 3 applies.

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

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

The description clearly identifies this as a beta variant of ask_pipeworx and explains that it is an identical universal router with the same tools, arguments, and response shape. It distinguishes itself from the stable ask_pipeworx tool, but it does not directly state the core action (e.g., routing/answering a natural language question) without relying on the ask_pipeworx 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?

It explicitly tells the agent to use this tool exactly like ask_pipeworx when the newest routing behavior is desired, and it names ask_pipeworx as the relevant comparison. It also clarifies the current state: no candidate is active, so it currently matches ask_pipeworx exactly, which gives the agent clear situational guidance.

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

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

Annotations already mark it readOnly, openWorld, idempotent, and non-destructive. The description adds crucial behavioral context beyond annotations: it returns evidence as a verbatim quote, includes a confidence score, and provides a structured refusal with specific refusal_reason enums like 'not_in_source' and 'data_truncated.' It also discloses the extra LLM call cost.

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

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

The description is dense but every sentence earns its place: it states the mode, explains the internal routing behavior, details the return/refusal contract, gives concrete use cases, and provides a cost-based recommendation. It is front-loaded with the core purpose and avoids redundancy with the schema or annotations.

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 the return shape on success ({answer, evidence, confidence, source, fetched_at, refusal_reason:null}) and all refusal scenarios. It also covers routing, cost, and usage context, making the tool fully self-contained for an agent to invoke correctly.

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

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

Schema coverage is 100%, with the question parameter and all aliases already documented in the input schema. The description does not add parameter-specific semantics beyond framing the question as natural language, but the schema fully handles parameter meaning, 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 identifies the tool as a 'hallucination-resistant answer mode for high-stakes reads,' with a specific verb (ask/extract) and resource (tool results across 5,566 tools/sources). It distinguishes itself from the sibling ask_pipeworx by emphasizing extraction using ONLY the tool result and explicit refusal behavior.

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

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

Provides explicit when-to-use guidance: 'Use whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts (financial verdicts, legal claims, medical lookups, public statements).' It also states when not to use it: 'prefer ask_pipeworx for casual lookups,' and discloses the cost tradeoff of one extra LLM call.

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?

Extensively discloses behavior: market resolution, classifier fan-out, response shapes, resolver contract with confidence levels, parent event extraction, news field fallbacks, safety short-circuits for low-confidence matches, closed markets, wide spreads, and cancellation rule parsing. Annotations confirm readOnly, idempotent, openWorld; description adds critical context without 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?

Very long description with multiple paragraphs and technical details. While well-structured with section headers, it could be more concise. The first sentence effectively conveys the core purpose, but subsequent detail is 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?

Thoroughly covers all aspects of the tool: input formats, classifiers, fan-out examples, response shapes, resolver contract, parent event extraction, news fallbacks, safety mechanisms, wide-spread handling, and cancellation rule risk. Despite no output schema, the description provides sufficient detail 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%, so baseline is 3. Description adds value by explaining the 'market' parameter accepts slug, URL, or question text; clarifies 'depth' enum values (quick vs thorough) with context; and explains 'include_raw' when to use. This goes beyond 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?

Clearly states the tool researches a Polymarket bet by pulling Pipeworx data in one call. Provides specific use cases ('should I bet on X') and differentiates from sibling tools like polymarket_arbitrage and polymarket_edges through its comprehensive data gathering and analysis.

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

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

Explicitly states when to use ('should I bet on X', 'what does the data say about Y', 'is there edge in Z'). Provides guidance on interpreting results (e.g., inspect market_match_confidence before trusting analysis, check cancellation rules). Does not name specific alternatives but context implies this is the go-to for single-bet research.

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, idempotent, non-destructive), the description adds valuable behavioral details: pulling latest 10-K data for companies, FAERS data for drugs, sorting by primary metric, and providing citation URIs. It fully discloses what data is retrieved and how results are structured.

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 every sentence adds value. It front-loads with trigger phrases and key usage guidance, then provides detailed behavioral info. Could be slightly shortened without losing essential information, but overall well-structured.

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

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

Despite no output schema, the description explains return format: paired data with sorted results and pipeworx:// citation URIs per entity. It fully covers both entity types and provides sufficient context for the agent to understand what the tool will return.

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 essential context: for 'type' it explains what data each enum value retrieves (SEC EDGAR/XBRL vs FAERS), and for 'values' it provides example formats (tickers/CIKs for company, drug names) and explicitly mentions maxItems=5 and minItems=2.

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

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

The description clearly states the tool performs side-by-side comparison of 2–5 companies or drugs. It uses specific verbs (compare, rank, head-to-head) and distinguishes itself from sibling tools like entity_profile by explicitly favoring over sequential lookups.

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 'ALWAYS PREFER over sequential single-pack lookups when comparing entities,' providing clear when-to-use guidance. It also implies when not to use (single entity lookups) and lists specific trigger phrases to help the agent decide.

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 far beyond the annotations, disclosing the findings packet format, explicit gaps[] for unanswered facets, 'never invented', semantic excerpting behavior, latency expectations, hop fields, resolvable citation_uris, and contradictions[] for standard/thorough. No contradiction with the readOnly/openWorld/idempotent annotations; 'not open-web search' clarifies scope rather than conflicting with openWorldHint.

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

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

The description is long but front-loaded with the most critical operational detail (account requirement) and then alternative guidance. It is dense and every section contributes useful decision-making information, though some redundancy exists around citation_uri and pipeworx:// citations.

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, no output schema, and two nuanced parameters, the description covers account requirements, when to use alternatives, return packet contents, failure/gap behavior, latency, depth variants, and citation resolvability. It leaves no major selection or invocation question unanswered.

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 value by explaining that 'Broad/multi-part is fine — decomposition is the point' and elaborating on depth semantics (gap recovery, contradictions scan, latency). This meaningfully supplements the raw 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's function: 'Grounded multi-source research across Pipeworx's 1462 STRUCTURED data sources... in ONE call'. It also distinguishes itself from siblings by explicitly saying 'this is NOT open-web search' and contrasting with ask_pipeworx for single lookups and current-news topics.

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 usage guidance with alternatives: 'Best for broad/multi-part questions over structured data', 'For a single lookup use ask_pipeworx', and 'For BREAKING or colloquial CURRENT-NEWS... prefer ask_pipeworx'. It also gives account-tier guidance: 'If you are not signed in, use ask_pipeworx instead — it works on every tier.'

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 behavior. The description adds value by specifying that results include 'full input schemas (with curated examples)' and 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?

Two sentences with no filler. The first sentence states the core function and scope, the second provides return format and usage guidance. 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 lack of output schema, the description explains what is returned (names, descriptions, schemas, examples) and how to use the results. It covers the tool's purpose, usage guidance, return format, and scope completely.

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 all 6 parameters. The description supplements by explaining query aliases and providing natural language examples, adding meaning beyond the schema's basic parameter 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: 'Find tools by describing the data or task.' It lists specific domains (SEC filings, FDA drugs, etc.) and distinguishes itself from siblings by calling itself the first tool to use for discovery, unlike more targeted tools.

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

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

The description explicitly advises 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' This provides clear when-to-use guidance, but it does not explicitly contrast with sibling tools like direct search or entity lookup 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive. The description adds valuable context: it fans out across multiple sources (SEC, XBRL, USPTO, news, GLEIF), details returned fields, notes the USPTO API sunset (soft-fail), and states names are not supported. 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 one dense paragraph but effectively front-loads example queries. Every sentence provides useful information, though a more structured format could improve readability slightly.

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, no output schema, and multiple data sources, the description covers all essential aspects: purpose, sources, return fields, limitations (patents sunset, name requirement), and when to use alternatives. No gaps.

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

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

Schema coverage is 100% and its descriptions are already detailed (e.g., value explanation includes ticker/CIK and name limitation). The description reinforces these but does not add significant new meaning 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 explicitly states the tool provides a full cross-source profile of a US public company, with specific examples like 'company profile for Microsoft'. It distinguishes itself from chaining single-pack lookups and from siblings like 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?

The description clearly advises to prefer this tool over chaining single-pack lookups for holistic views, and explicitly says to use resolve_entity first if only a name is available. No 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 already declare readOnlyHint, idempotentHint, destructiveHint. The description adds behavioral context: returns exact wording, forgiving input, covers specific parts. 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 relatively long but every sentence adds value: examples, scope, sibling differentiation. It's front-loaded with purpose and examples, though slightly 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?

With one parameter and no output schema, the description covers input flexibility, legal scope, and use cases completely. Combined with annotations, it leaves no ambiguity.

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

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

Schema covers 100% with description. The tool description adds extensive examples, input formats (citations, whole parts), and usage patterns, going well beyond the schema's brief 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 explicitly states it retrieves the full text of FDA regulations by citation, using specific verbs ('Get'). It distinguishes from sibling tools by mentioning openfda tools for data, making the purpose clear.

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

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

It provides explicit when-to-use ('to get regulatory text') and when-not-to-use ('for FDA DATA use openfda tools'), with concrete examples of queries and citations.

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, destructiveHint false. Description adds behavioral details: returns matching regulations with citation, heading, excerpt, URL, and notes 'Keyless' for no API key required. 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?

Description is moderately concise, with a few extra sentences about topics and examples. All information is valuable, but could be trimmed slightly. Front-loaded with purpose and usage.

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 explains return fields (citation, heading, excerpt, source URL). Given two simple parameters and clear intent, the description is complete and self-sufficient.

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

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

Schema coverage is 100%, and description enhances understanding with examples (e.g., 'good manufacturing practice'), default for limit, and explanation of query purpose. Adds concrete usage context 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?

Description clearly states it searches FDA regulations (21 CFR) with specific verb 'keyword search across FDA regulations'. It distinguishes from sibling tools by contrasting with openfda tools for FDA data, and lists example topics and use cases.

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 (for FDA regulations) and when not (for FDA data, use openfda tools). Provides example queries and topics, guiding the agent on appropriate inputs.

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 and idempotentHint. Description adds context about clearing sensitive data, which is behavioral. 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, front-loaded with action, no wasted words. Very concise.

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 delete tool with one parameter and no output schema, description covers purpose, usage, and sibling context. Could mention return value or confirmation, but adequate.

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

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

Schema coverage is 100%; parameter 'key' is described in schema as 'Memory key to delete'. Description does not add further parameter details beyond that.

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 tool deletes a memory by key, uses specific verb 'Delete', and distinguishes from siblings like 'remember' and 'recall' by mentioning pairing.

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 context stale, task done, or to clear sensitive data. Also suggests pairing with remember and recall.

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?

Describes the process (fetch page, extract title/description/key links, emit markdown). Annotations already declare readOnlyHint, idempotentHint, destructiveHint false. The description adds useful behavioral 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?

Three concise, front-loaded sentences plus a bullet list of use cases. Every sentence adds value: purpose, process, output format, and usage scenarios. 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 no output schema, description explains output is a text blob in standard llms.txt markdown format. Covers the main workflow and use cases. Lacks error handling or validation details, but adequate 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% (both parameters described in schema). Description mentions 'fetches the page' for url and 'maximum of link entries' for max_links, but adds no significant extra 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?

Clearly states the tool generates a production-ready llms.txt file for a URL. Verb 'generate', resource 'llms.txt', and explains the purpose for AI crawlers. Differentiates from siblings by specifying a unique output format and use cases.

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?

Lists three concrete use cases (client indexing, personal project, competitor audit), implying when to use. Does not explicitly mention when not to use or alternatives, but the 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?

Annotations already indicate read-only, idempotent, non-destructive. Description adds scoping (caller's subscriptions) and field list, but no extra behavioral details beyond that.

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 cover purpose, return fields, and usage guidance 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?

Simple tool with one optional parameter and no output schema; description adequately covers all necessary 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%, so baseline 3. Description does not elaborate on the include_inactive parameter beyond what 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?

Clearly states it lists the caller's active subscriptions and enumerates return fields. Distinct from sibling tools like subscribe/unsubscribe.

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 suggests using it to review monitoring before adding more subscriptions or to find an id for cancellation.

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 are all false, so the description fully informs behavior: it discloses that filing returns a `claim_token`, explains the later poll-back flow, states rate limits ('Rate-limited to 5 per identifier per day'), notes the tool is free and 'doesn't count against your tool-call quota,' and reveals that the team reads digests daily. No contradiction with annotations 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 dense but every sentence earns its place: primary action, triggers, exclusions, file-appropriate content, token flow, team responsiveness, rate limit, and quota impact. It is front-loaded with the purpose and directly addresses likely agent confusion. 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 moderate complexity (4 params, nested object, no output schema), the description is complete. It covers return value via claim_token and its later use, eligibility boundaries (only Pipeworx tools), rate limiting, and performance implications. An agent can confidently decide whether and how to invoke this tool without further clarification.

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

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

Schema descriptions cover all 4 parameters 100%, so baseline is 3. The description adds meaningful semantics beyond schema by explaining the claim_token lifecycle ('Filing without an account returns a `claim_token`; pass it back later...'), and gives message-content guidance ('don't paste the end-user's prompt'). This elevates the parameter understanding.

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

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

Description opens with specific action and resource: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It clearly enumerates feedback types (bug, feature/data_gap, praise) and distinguishes itself from sibling tools (research, ask, etc.) by its unique purpose.

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

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

Provides explicit when-to-use guidance: 'Use when a tool returns wrong/stale data (bug), when a tool you wish existed isn't in the catalog (feature/data_gap), or when something worked surprisingly well (praise).' Also states exclusions—MCP servers from other vendors should be reported there instead—and instructs users to describe issues in terms of Pipeworx tools/packs, not paste end-user prompts.

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. The description adds valuable context beyond these: data source (CF analytics-engine), privacy (no PII, just counts), and caching behavior (5min-1h). 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 well-structured sentences: purpose, use cases, and technical details. Every sentence adds value. Front-loaded with the core action and result.

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

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

No output schema exists, but the description lists return fields (top tools, top packs, total call volume) and explains caching and data source. For a simple read-only tool with one optional parameter, this is sufficient. An explicit output schema would improve completeness.

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

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

Schema coverage is 100% and the parameter description in the schema already explains the window meaning (shorter vs longer windows). The tool description repeats that same insight but does not add anything new; 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 trending data from other AI agents, specifying 'top tools, top packs, and total call volume' over configurable windows. This distinct purpose is well separated from siblings like 'discover_tools' or 'ask_pipeworx'.

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?

Three explicit use cases are provided (discovering hot data sources, confirming canonical choice, aligning use case). While it doesn't state when not to use, the context clearly suggests trend discovery. Alternatives are not explicitly named but the use cases implicitly differentiate from other 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?

Annotations indicate read-only, idempotent, non-destructive behavior. The description adds extensive behavioral details: monotonicity checks, partition-sum logic, semantic anchor with Jaccard similarity, placeholder filtering, fill check using live CLOB depth, and trade signals. 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 detailed and well-structured with clear sections (trending_scan, event mode, topic mode, fill check). Every sentence adds value, but it is somewhat verbose. However, for the tool's complexity, the length is justified and front-loaded with 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?

Despite having no output schema, the description thoroughly details the response structure (opportunities[], partition_check, fill_check results) and key fields. It covers all aspects of tool behavior, making it complete 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?

Both event and topic parameters have schema descriptions (100% coverage). The description adds significant meaning: explains event slug usage, acceptance of full URLs, topic as seed question for cross-event scanning, and internal processing details. This goes well 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's purpose: 'Find arbitrage opportunities on Polymarket via monotonicity violations + partition-sum checks.' It distinguishes from siblings like polymarket_edges and polymarket_fill_risk by focusing on arbitrage detection and referencing unique features like fill checks and partition filters.

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

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

The description provides explicit when-to-use guidance: call with no args for trending scan, event for specific market, topic for cross-event scanning. It also explains when not to trade (realizable_edge_pp ≤ 0) and mentions alternative tool polymarket_fill_risk for custom sizing.

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, openWorldHint, and destructiveHint. Description adds significant context: caching behavior (1h at KV level keyed on all knobs), detailed explanation of segments and edge computation, and diagnostics so callers understand empty segments. Exceeds annotation cues.

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: front-loaded with core purpose, then detailed segment explanations, opportunity fields, knobs, and response structure. Though lengthy, each section serves a purpose and the organization aids comprehension. Could be trimmed slightly but earns its length.

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 thoroughly documents the response structure: by_segment with three categories, fed_candidates/fed_note, and diagnostics. It explains every field in an opportunity (edge_pp_net, kelly_fraction, etc.) and why some data is excluded. Caching and filter logic are also covered.

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. Description adds value by explaining how tradeable-edge knobs (min_liquidity, max_spread_pp, min_partition_leg_kelly) interact and why min_kelly doesn't filter partition arbs. This contextualizes the parameters beyond their individual 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?

Description clearly states the tool scans Polymarket markets and returns opportunities where Pipeworx data disagrees with market price, specifically for 'what should I bet on today'. It distinguishes from siblings like polymarket_arbitrage and polymarket_edge_tracker by focusing on Pipeworx-driven 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?

Description explicitly states the tool is built for discovering betting opportunities without paging hundreds of markets. It mentions caching and tradeable-edge knobs for filtering, and notes that Fed bets are excluded. However, it does not directly compare to sibling tools, leaving some ambiguity about when to use this vs 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?

The description adds significant behavioral context not present in annotations: reads from daily snapshots, bounded by 60-day TTL, decay from daily closes not intraday, and explains the meaning of trend and decay values. Does not contradict any annotations.

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

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

The description is fairly long but well-structured: starts with a clear one-liner, then breaks down the response structure, and ends with limits. Every sentence adds value, though could be slightly trimmed.

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

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

No output schema exists, so the description fully explains the return values (tracked, expired, snapshot_dates) with field details. Also covers limitations. For a tool with only 2 optional parameters, this is 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%, so baseline is 3. The description adds minor clarifications (defaults, clamp ranges) but mostly restates schema info. 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 clearly states the tool's purpose: 'Edge persistence and decay telemetry' and answers a specific question. It distinguishes itself from the sibling tool 'polymarket_edges' by focusing on persistence and decay rather than just current 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 context on when to use this tool (to understand edge persistence and decay) and includes limitations (TTL, decay calculation). However, it does not explicitly state when not to use it 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 readOnly, openWorld, idempotent, non-destructive. The description adds essential behavioral details: walks the order-book ladder, returns specific fields like slippage_pp and forced_directional_risk, and warns about thin_legs and directional risk. This goes beyond annotations without contradicting them.

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 informative but lengthy (~250 words). It is well-structured with sections for single-market and basket modes, but some sentences are dense. A bit more conciseness would improve clarity, though 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 4 parameters, no output schema, and high complexity, the description covers expected outputs for both modes, edge cases (thin legs, forced directional risk), and provides examples of return fields. It is sufficiently complete for an agent to understand behavior and results.

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 crucial clarifications: size_usd default (1000), clamp range (10-1,000,000), side default logic for basket (auto), and interpretation of size_usd for buys vs sells. This 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's purpose: 'Realizable-vs-theoretical edge check against live CLOB order-book depth.' It distinguishes two modes (single-market and basket) and specifies the outputs (e.g., top_of_book, vwap_fill_price, slippage_pp). This differentiates it from sibling tools like polymarket_arbitrage and 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 explicitly tells when to use the tool: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500.' It also explains when not to rely on theoretical edge ('theoretical overround on thin books is not capturable') and warns about partial fills converting arb to directional position.

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, idempotentHint, openWorldHint), the description explains response structure (leg-by-leg prices, matched spreads, top_spreads_pp) and safety fields (compatibility_warning, temporal_alignment, skipped_cross counters). It fully discloses potential caveats like non-equivalent bet shapes.

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 clear sections (TWO MODES, RESPONSE, SAFETY FIELDS) and front-loads the core purpose. It is informative but slightly dense; a minor reduction in detail could improve conciseness without losing meaning.

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 thoroughly covers return values (leg prices, spreads, top_spreads_pp) and edge cases (compatibility warnings, temporal alignment, skipped pairs). All three parameters are described in both schema and description, making the tool well-documented.

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 semantic value: it defines the two modes, explains the overriding behavior, and provides examples. This goes beyond the basic 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's function: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' It names the resource (spread) and action (compare across venues), and contrasts with sibling tools like polymarket_arbitrage which focus on single-venue arb.

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 details two modes (topic vs explicit tickers) with usage guidance, and warns that pre-mapped topics often return compatibility warnings, implying when not to rely on them. It also explains conditions for valid spreads (temporal alignment, compatible bet shapes).

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, destructiveHint=false. Description adds scoping by identifier and key-omission behavior, 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?

Three sentences with no wasted words. Front-loaded with main action, then usage context, then pairing. 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?

Given simple tool with one optional parameter, annotations cover safety, and description explains scoping, listing, and pairing. No output schema needed.

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 one parameter described. Description adds meaning by explaining the key's origin (saved via remember) and listing behavior when omitted, enhancing clarity.

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

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

Description clearly states the tool retrieves a saved value or lists all keys, with specific verb+resource. It distinguishes from sibling tools remember 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?

Provides clear when-to-use context: lookup stored information. Shows pairing with remember and forget. No explicit when-not-to-use, but implicit from purpose.

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

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

Annotations already indicate safe read-only behavior. The description goes beyond by detailing the return fields (source, citation_uri, raw payload), the effect of mark_read (flagging returned events as read), and the filtering behavior. This adds significant behavioral context 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 compact (four sentences), front-loads the main purpose, and each sentence serves a distinct role: purpose, return format, filtering details, mark_read behavior, and alternative access. There is no redundant or extraneous 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?

With no output schema, the description adequately explains return values (source, citation_uri, raw payload). It covers most parameters (type, since, mark_read) but omits explicit mention of 'limit' and 'unread_only', which are covered only in the schema. This minor gap prevents a 5.

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 value by providing concrete examples (e.g., 'sec_8k' for type, ISO timestamp for since) and explaining the mark_read flag's purpose. This enriches the parameter meanings beyond the schema definitions.

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

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

The description starts with 'Pull fired events from your subscription feed,' which clearly states the action and resource. It further distinguishes by mentioning filtering options and linking to an alternative REST endpoint, setting it apart from sibling tools.

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

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

The description provides clear context on when to use the tool, stating 'Polls work fine' and noting the same feed is available via a direct URL for scripts/dashboards. It does not explicitly list alternatives among the many siblings, which prevents a 5.

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

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

Annotations already convey safe, read-only, idempotent behavior. The description adds critical details: fan-out to multiple sources with fallback (GDELT→GNews), soft-fail for patents, and parallelism ('ONE parallel call'), all consistent 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 relatable examples, then covers sources, parameters, and an alternative tool. It is moderately concise; every sentence adds value, though slightly long. 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?

Given 3 required parameters and no output schema, the description adequately explains the return structure ('changes[] grouped by source + total_changes count + citation URIs'). The fan-out and fallback behavior are fully described, leaving minimal ambiguity.

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

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

Schema coverage is 100%, baseline 3. The description adds meaningful context: explains `since` format (ISO date or relative shorthand like '7d'), provides a usage recommendation ('Use '30d' or '1m' for typical monitoring'), and clarifies `value` accepts ticker or CIK.

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 'change feed for a company in the last N days/weeks/months' and lists specific sources (SEC EDGAR, GDELT→GNews, USPTO). It explicitly distinguishes from the sibling tool 'entity_profile' by noting the static profile alternative.

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

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

The description offers explicit when-to-use guidance with example queries like 'What's new with X' and 'latest on Y'. It provides a clear exclusion: 'Use entity_profile instead when you want the static profile... regardless of window.'

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

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

The description discloses behavioral traits beyond annotations, such as session-specific memory duration ('authenticated users get persistent memory; anonymous sessions retain memory for 24 hours'). It aligns with annotations (idempotentHint: true, destructiveHint: false) and adds contextual value about storage limits.

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

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

The description is a single, well-structured paragraph of about 100 words. It front-loads the primary purpose, then flows logically into usage guidance, scoping, and pairing with other tools. Every sentence serves a purpose without extraneous 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 the tool's simplicity and the lack of an output schema, the description covers all essential aspects: purpose, when to use, storage mechanics, persistence, and relationship with sibling tools. No critical gaps are present.

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

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

With 100% schema description coverage, the baseline is 3. The description adds value by providing example keys ('subject_property', 'target_ticker', 'user_preference') and clarifying that the value can be 'any text,' which reinforces the schema details without redundancy.

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

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

The description clearly identifies the tool as a persistent data storage mechanism, using phrases like 'save data the agent will need to reuse later' and 'across this conversation or across sessions.' It distinguishes itself from sibling tools by name (recall, forget), making the 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?

The description provides explicit guidance on when to use the tool: 'when you discover something worth carrying forward... so you don't have to look it up again.' It also details scoping ('scoped by your identifier') and persistence behavior for authenticated vs. anonymous sessions, leaving no 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?

Beyond the readOnly/idempotent hints, the description reveals critical behavior: identifiers are source-labelled, unresolved identifiers are explicitly listed under `unresolved`, LEI/FIGI enrichment degrades gracefully, and internal cascading replaces 2-3 manual lookups. This gives the agent a clear picture of fallback behavior and output trustworthiness.

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

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

The description is long but well-structured, opening with user-style queries and then organizing details under SUPPORTED TYPES. Some redundancy exists (e.g., repeated notes about source labelling and graceful degradation), but the complexity of the tool justifies the length and the structure aids readability.

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 fully explains return values: source-labelled identifiers, explicit `unresolved` entries, ownership data when available, and drug-specific RxCUI/ingredient/brand/citation. It also covers dependency failures and the internal multi-step behavior, making the tool's behavior predictable.

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?

Though schema coverage is 100%, the description adds substantial semantics: it explains what each `type` returns (company vs drug), what `value` accepts for each type (ticker, CIK, ISIN, name; brand/generic), and provides a concrete ISIN example. This goes far beyond the schema's basic field 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 resolves user-spoken names to canonical/official identifiers needed by other tools, with concrete examples like 'What's the ticker for…' and 'find the CIK for…'. It distinguishes this from sibling tools by positioning it as the identity-resolution entry point, not profiling or 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?

Explicitly instructs 'Use FIRST whenever you have a name but need an ID' and provides a long list of trigger phrases. It does not explicitly name alternatives or state when not to use it, but the use-case framing is strong enough to guide selection.

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

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

Annotations already indicate readOnly, idempotent, non-destructive behavior. The description adds valuable context: the tool probes each entity with ai_visibility_check, returns a ranked list with score/confidence/signal density, and treats the first entity specially. 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 two sentences long, front-loaded with the core purpose, and every sentence adds value. It is efficiently structured and avoids redundancy.

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

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

Given the tool's complexity (4 parameters, no output schema), the description fully explains the process, return structure (ranked list with score, confidence, signal density), and special first-entity treatment. It sufficiently equips the 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?

Schema coverage is 100% and the description repeats the schema descriptions verbatim, adding no new information beyond what the schema already provides. Baseline 3 is appropriate as the description does not enhance parameter understanding.

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

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

The description clearly states the tool's function: comparing AI visibility across multiple entities side-by-side, using specific verbs like 'probe', 'rank', and 'surface'. It distinguishes from sibling tools like ai_visibility_check (single entity) by emphasizing multi-entity comparison and competitive audits.

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 clear use case ('competitive AI-marketing audits') and implies when to use it (comparing multiple entities) vs. alternatives (single entity check via ai_visibility_check). It lacks explicit 'when not to use' but gives sufficient 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?

The description goes beyond annotations by detailing graceful degradation on partial failures, bundlephobia's first measurement latency (5-30s), and that sources_failed will list timeouts. Annotations already indicate readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, but the description adds valuable operational context.

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

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

The description is tightly written with every sentence adding value. It front-loads the main purpose, then covers data sources, use cases, limitations, and behavior in a logical flow. 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 tool's complexity (multiple external sources, partial failures), the description covers all essential aspects: what it does, when to use, edge cases (timeouts), return format, and ecosystem scope. Despite no output schema, the description provides sufficient completeness.

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

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

Schema coverage is 100% and the description adds meaning by explaining the package parameter (npm package name, scoped packages accepted) and version default behavior. It also describes the return structure (summary block, per-advisory detail, links, alternative versions), compensating for the lack of an output schema.

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

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

The description explicitly states it is a composite check for deciding whether to add an npm package, covering deps.dev (license, advisories, version history) and bundlephobia (bundle size, dependency count, ESM/tree-shake support). It clearly distinguishes itself from sibling tools like deps.dev:version by qualifying it as a one-call package evaluation.

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 use cases: 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me"'. It also explicitly states limitations: 'NPM ecosystem only in v1; PyPI / Maven / Cargo / Go fall under deps.dev:version directly', guiding when to use this tool versus 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, idempotentHint, etc. The description adds beyond: uses BGE-base-en embeddings with cosine over 500-char windows, 200K char cap with truncation flag, and passage offsets for verification. This provides useful behavioral context.

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

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

The description is front-loaded with the main purpose and uses clear structure. Each sentence adds value, though it could be slightly tighter (e.g., combining some technical 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 explains the return format (passages with offsets and scores). It also covers constraints (truncation, embedding model). Provides sufficient context for 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% with good descriptions. The description adds example queries for 'query' and reiterates the text and limit parameters, but does not add significant new 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 does semantic search inside a fetched record. It specifies the use case (record too large for prompt) and pairs with a sibling tool (ask_pipeworx_grounded), distinguishing it from other 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 the record is too big to cram into the prompt') and mentions a complementary tool (ask_pipeworx_grounded). No explicit when-not-to-use, but 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?

The description states 'Create' and 'Returns the new subscription id', implying each call creates a distinct subscription. This contradicts the idempotentHint=true annotation, which suggests idempotent behavior. Thus the description contradicts the annotation.

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 clear sections, bullet points, and front-loaded purpose. Every sentence adds value, covering types, delivery, and constraints without unnecessary fluff.

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

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

The description fully covers all relevant aspects: authentication requirements, supported types, parameter details, delivery channels, constraints, and return value. No output schema exists, but the description suffices.

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, but the description adds significant value by explaining type-specific params, delivery options, phone verification, and caps. It clarifies the meaning and usage of all parameters beyond the schema descriptions.

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

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

The description clearly states the verb 'Create' and the resource 'proactive monitoring subscription', and specifies it deals with live-data event streams. It distinguishes from sibling tools like list_subscriptions and unsubscribe by describing the creation act.

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

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

The description provides explicit when-to-use conditions: requires Pipeworx OAuth account, lists supported types with examples, details delivery channels and their constraints (e.g., phone must be verified, 10 SMS/day cap). It indirectly suggests alternatives for one-time queries.

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 characteristics (readOnly, openWorld, idempotent, non-destructive). The description adds that it returns example questions with tool+argument shapes, which is critical behavioral 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?

The description is front-loaded with common phrasings and includes all necessary information. While slightly verbose with the list of categories, every sentence adds value, and it remains clear and structured.

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

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

Given the tool's simplicity (1 optional parameter, no output schema), the description is fully complete. It covers purpose, usage, parameter semantics, and when to use, leaving no gaps for an agent to misinterpret.

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 optional parameter. The description enriches it by listing possible topic values and their effect (focus area vs. full spread), which adds 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 that the tool returns category-bucketed example questions and serves as the onboarding entry point. It distinguishes from siblings like ask_pipeworx by positioning itself as the exploratory first step, using specific verbs like 'suggest' and 'show examples'.

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

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

Explicitly says 'Use this FIRST when you do not yet know what Pipeworx can do for you' and directs to learn meta-tools. It also explains when to omit vs. provide a topic, giving clear usage boundaries.

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 that the row is deactivated not deleted, preserving historical events via recent_alerts. This behavioral nuance is not conveyed by annotations alone.

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 precise sentences: first for purpose, second for ownership and behavioral detail. No wasted words, front-loaded with key action.

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

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

For a simple single-parameter tool without output schema, the description fully covers purpose, ownership rule, and behavioral effect. No gaps given 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% with id described as 'Subscription id (uuid) returned by subscribe.' The description adds no additional parameter meaning beyond what schema already provides; baseline 3 applies.

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

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

Clearly states 'Cancel a subscription by id' - specific verb (cancel/unsubscribe) and resource (subscription). Distinguishes from sibling tools like subscribe and list_subscriptions by being the only cancellation tool.

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 notes ownership enforcement ('you can only cancel your own subscriptions'), guiding when to use. Lacks explicit when-not or alternatives, but context is sufficient given no sibling cancellation 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 adds critical behavioral context beyond the annotations: it explains the two routing paths (structured SEC EDGAR for financial claims, grounded pipeline for others), describes return verdicts, and importantly defines the semantics of could_not_verify (carries verification_error{stage,detail}, not evidence) and unsupported (no source found). This is valuable nuance that annotations alone do not provide, and there is no contradiction with the readOnly/openWorld/idempotent hints.

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

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

The description is long but well-structured: leading examples, clear use-case statement, pipeline breakdown, return value summary, and error semantics. Every sentence adds necessary information, and the use of dashes and parentheses packs detail efficiently. It is not overly terse (which would lose nuance) nor rambling (it stays focused), earning a high but not perfect score because some sentences could be tightened.

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

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

Despite having no output schema, the description thoroughly covers return values (verdict, value, citation, reasoning), error states, and routing behavior. It gives enough context for an agent to invoke the tool correctly and interpret results, including guidance on how to handle ambiguous verdicts. The description is complete for a tool of this complexity, even without structured output documentation.

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

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

The input schema already describes both parameters with 100% coverage. The description adds extra meaning by giving a concrete example for the claim parameter and by explaining that tolerance_pct overrides the wording implied tolerance and is useful for hallucination detection when set to 1–2. This goes beyond the schema's basic parameter descriptions, though the schema already carries much of the load.

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

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

The description opens with concrete natural-language examples ('Is it true that…', 'fact check') and states the tool performs 'natural-language claim verification against authoritative sources.' It clearly distinguishes itself from sibling tools like ask_pipeworx_grounded and deep_research by specifying the SEC EDGAR fast path for financial claims and the grounded pipeline for all other factual claims, and by noting it replaces multiple sequential calls.

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 whenever the agent needs to check whether something a user said is factually correct.' It also gives guidance on when to set tolerance_pct (1–2 for hallucination detection) and clarifies that could_not_verify means the check did not happen and must not be shown as evidence. This provides clear when-to-use context and identifies what makes this tool different from general research tools.

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