Healthdata

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

Annotations already indicate readOnlyHint, openWorldHint, idempotentHint true, and destructiveHint false. The description adds transparency by detailing the return format (per-model scores combined view), default model, and the need for a separate API key for Anthropic calls. No contradictions with annotations.

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

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

The description is concise (two sentences) and front-loaded with the core purpose. Every sentence adds value: first sentence explains action and default, second covers optional probing with BYO key and return format.

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

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

Given the complexity (4 parameters, no output schema), the description adequately explains the return structure (per-model fields + combined view) and typical use cases. It does not cover edge cases or error behavior, but it is sufficient for effective 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 description coverage is 100%, but the description adds value by explaining the default model behavior, optionality of 'models' array, and the purpose of '_apiKey' (only needed for Anthropic) and 'context' (disambiguation). These are not present in 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 tool's action ('Probe one or more LLMs') and resource (knowledge about a business/brand/product/topic) with a specific output (visibility score 0-100). It distinguishes itself from sibling tools like 'compare_entities' by focusing on AI 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?

The description explicitly lists use cases ('AI-marketing audits, pre-launch brand checks, competitive monitoring') and provides context on default model and optional API key. It does not explicitly state when not to use or compare with alternatives, but the usage context is clear.

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

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

Annotations already establish read-only/idempotent/open-world behavior, so the description focuses on additional behavioral context: it routes to 5,706 tools, fills arguments, returns structured answers with stable pipeworx:// citation URIs, works on every tier, and is described as one fast call. This goes beyond the 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 dense but front-loaded, beginning with the most important instruction ('PREFER OVER WEB SEARCH') followed by supported domains, examples, and routing guidance. Every section earns its place, though the examples partly duplicate the input schema's examples and the wording could be slightly tightened.

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

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

For a one-required-parameter read-only tool with full schema coverage and no output schema, the description is nearly complete: it explains scope, usage signals, alternatives, output shape, and citation behavior. Minor omissions such as failure handling or unsupported question behavior prevent a perfect score.

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%, and the schema already documents the 'question' parameter and its aliases. The description provides examples, but they overlap with the schema's own examples and add no additional format, constraint, or syntax semantics. 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 routes a natural-language question to the appropriate source from 5,706 tools across 1,493 verified sources, fills arguments, and returns structured answers with citation URIs. It also differentiates itself from siblings like ask_pipeworx_grounded and deep_research. This is a specific verb+resource statement with explicit sibling distinction.

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

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

The description explicitly says to PREFER this over web search for factual questions, lists trigger phrases like 'what is' and 'look up', and provides examples. It names alternatives and tells when to step up: ask_pipeworx_grounded for hallucination-resistant single answers, deep_research for broad multi-part questions, and notes that breaking-news is already covered.

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

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

With annotations already declaring readOnlyHint, idempotentHint, and non-destructive behavior, the description adds valuable operational context: it is a live experimental edge, currently has no active candidate, matches ask_pipeworx exactly, and 'falls back to nothing' meaning it is fully functional. This goes beyond the annotations and explains the beta state honestly.

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

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

The description is front-loaded with the key fact ('Beta version of ask_pipeworx') and each sentence earns its place: relationship, current state, usage guidance, and reassurance. The date-specific detail (2026-07-26) is useful but could become stale; still, the overall structure is efficient.

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

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

The description covers purpose, current state, usage, and the fact that it is a full working router. It does not describe the return format, but it states 'same response shape' as ask_pipeworx, which is sufficient if the agent knows that sibling. Given the lack of an output schema, this is reasonably complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning beyond saying 'same arguments' as ask_pipeworx, which is not necessary given the schema already documents all aliases and the 'question' field. It neither helps nor hurts.

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

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

The description identifies the tool as a 'universal router' with a specific verb ('routes') and resource (5,706 tools). It explicitly distinguishes itself from ask_pipeworx by being the beta version with candidate routing improvements, and from other siblings by stating it is identical to ask_pipeworx but experimental. This gives an agent a clear, specific purpose.

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

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

The description gives explicit usage guidance: 'Use it exactly like ask_pipeworx when you want the newest routing' and explains that results are compared to the stable router to decide merges. It implies the alternative (stable ask_pipeworx) but does not explicitly state a when-not-to-use condition, so it falls just short of a 5.

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

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

The description goes well beyond annotations by disclosing the exact success return shape, the refusal contract with all possible refusal_reason values, and the core behavior of using only what the tool result contains. This is rich behavioral transparency for an LLM agent.

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 contributes: purpose, routing behavior, extraction policy, return contract, refusal reasons, use cases, and cost trade-off. It is well-structured and front-loads the core differentiator before diving into 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?

The description is complete for a complex tool: it covers behavior, output format, refusal modes, appropriate use cases, and the alternative sibling. Combined with annotations and schema, nothing needed for correct invocation is missing.

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

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

The input schema is fully covered with descriptions for the main 'question' parameter and all aliases. The description itself adds no additional parameter semantics, but the schema carries full weight, so the baseline of 3 applies.

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

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

The description clearly states this is a hallucination-resistant answer mode that routes like ask_pipeworx but extracts answers only from tool results. It also distinguishes itself from ask_pipeworx by naming the sibling and the key difference: grounded extraction with evidence and explicit refusal on insufficient data.

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

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

Explicitly states when to use: 'Use whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts.' It also gives a clear exclusion: 'prefer ask_pipeworx for casual lookups' and explains the cost difference. This is ideal guidance for tool selection.

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

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

The description extensively details behavioral aspects beyond annotations: resolver contract with confidence levels, parent event extraction, news fallback fields, low-confidence short-circuit, closed market handling, wide-spread market warnings, and cancellation rules. This far exceeds the basic readOnly/idempotent hints provided in annotations.

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

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

The description is long but well-structured with labeled sections (RESOLVER CONTRACT, PARENT_EVENT EXTRACTOR, etc.). It front-loads the core purpose in the first sentence. For a complex tool, the length is justified, though some redundancy exists (e.g., repeating classification examples).

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 classifiers, response shapes, safety checks, cancellation rules), the description is remarkably complete. Since there is no output schema, the description fully covers return fields and edge cases, making it self-sufficient for an agent to understand the tool's behavior comprehensively.

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%. The description adds context to parameters: it explains the 'depth' parameter (quick vs thorough) and 'include_raw' parameter (full vs summarized payloads). However, the schema already describes these clearly, so the description's additional value is moderate but useful.

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 researches a Polymarket bet by pulling Pipeworx data. It specifies the input formats (slug, URL, question text) and outputs (evidence packet, market-vs-model comparison). This distinguishes it from sibling tools like polymarket_arbitrage or polymarket_edges, which focus on specific strategies.

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

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

The description provides explicit usage scenarios: 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z"'. It also includes classifier examples and fan-out examples. However, it does not directly state when not to use this tool or mention specific alternatives among siblings.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds that results are sorted by primary metric, returns paired data with citation URIs, and clarifies data sources (SEC EDGAR/XBRL for companies handling off-calendar fiscal years, FAERS for drugs). 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 packed with useful information and front-loaded with example queries. While comprehensive, it is slightly long but every sentence earns its place with no redundancy.

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

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

Covers purpose, usage, data sources, sorting behavior, and output format (paired data + URIs). No output schema exists, but description provides sufficient context for an agent to invoke correctly. Minor gap: exact output structure not detailed, 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% with both parameters described. Description adds value by giving concrete examples (tickers for companies, drug names) and explaining what data each type pulls, going beyond the schema's enum and array 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 'side-by-side comparison of 2–5 companies or drugs' and provides example queries like 'compare X and Y' or 'X vs Y'. It distinguishes from sequential lookups, establishing a specific verb+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?

Explicitly advises 'ALWAYS PREFER over sequential single-pack lookups when comparing entities', indicating when to use. It also notes that it replaces 8–15 sequential lookups, offering strong usage context.

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

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

Annotations already mark the tool read-only, open-world, idempotent, and non-destructive, and the description adds substantial behavioral context beyond them: parallel decomposition into facets, findings packet structure, gaps[] vs invented answers, contradictions[] scans, hop fields, citation_uri fetchability, semantic excerpting, latency expectations, and plan-tier requirements. No annotation contradiction is present.

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 dense, and most sentences earn their place given the tool's complexity and lack of an output schema. It is front-loaded with the most critical caveats (account requirement, not open-web search) and then flows from use cases to hop behavior to latency.

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

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

For a complex tool with no output schema, the description is remarkably complete: it explains the return packet, evidence fields, gaps, contradictions, hop field, resolvable citations, authentication requirements, when not to use it, and expected latency. An agent has enough information to decide whether to call it and what to expect back.

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

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

The schema already documents both parameters at 100% coverage, including detailed depth enum semantics. The description still adds value by explaining when each depth mode is appropriate, that thorough requires a paid plan, and the expected runtime per mode, which helps an agent choose parameters confidently.

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

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

The description states a specific verb and resource ('Grounded multi-source research across Pipeworx's 1493 STRUCTURED data sources') and explicitly contrasts itself with ask_pipeworx and open-web search. It names sibling tools and clarifies it is not a general search tool, so an agent can distinguish it from its siblings.

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

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

Usage context is explicit: use for broad/multi-part questions over structured data, use ask_pipeworx for single lookups, and prefer ask_pipeworx for breaking current-news topics. It also gives an authentication caveat and tells agents what to do when not signed in, leaving little to inference.

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

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

Annotations already declare readOnlyHint, idempotentHint, and no destructiveness. The description adds that it returns 'top-N most relevant tools with names, descriptions, and full input schemas (with curated examples)' and that results are 'ready to call directly, no second schema lookup needed.' This enriches behavioral understanding beyond annotations.

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

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

Description is front-loaded with purpose and includes a usage tip and example domains. It is somewhat long but each sentence adds value. Could be slightly more concise but well-organized.

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 6 parameters, no output schema, the description explains what the tool returns (top-N tools with schemas), when to use, and what domains it covers. It is fully adequate for an AI agent to understand and invoke correctly.

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

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

Schema coverage is 100% and description explains that 'query' accepts multiple aliases (task, q, search, description) and 'limit' is a number with defaults. It adds context that aliases are accepted, which schema lacks, but no extra parameter meaning beyond schema.

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

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

The description clearly states it 'Find tools by describing the data or task', uses a specific verb+resource (discover tools), and differentiates from siblings by positioning itself as a discovery/browsing tool among many specific tools like search_datasets or entity_profile.

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

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

Explicitly says 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' This gives clear when-to-use and context, and implies not to use if you already know 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 mark readOnlyHint=true, idempotentHint=true. Description adds valuable behavioral context: it makes a 'parallel call' across multiple sources, returns specific fields with URIs, and notes the patents limitation. 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?

Reasonably concise given complexity. Front-loaded with example queries. The detailed list of return fields is informative but slightly verbose. Could be tightened without losing clarity.

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

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

Given the tool's complexity (multi-source aggregation) and no output schema, the description fully covers what the tool does, its limitations, and expected return structure. Leaves no critical 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 description adds substantial meaning: provides examples (ticker 'AAPL', zero-padded CIK), clarifies that names are not supported, and explains the 'type' parameter only supports 'company'. 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 uses specific verbs ('Tell me about', 'research', 'brief me on') and clearly states it provides a 'full cross-source profile of a US public company'. It lists specific outputs (SEC, XBRL, patents, news, LEI) and distinguishes itself from sibling tools by stating it should be preferred over chaining single-pack lookups for holistic views.

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 ('ALWAYS PREFER...when the user asks for a holistic view') and when not ('names not supported – use resolve_entity first'). Also clarifies that patents soft-fail due to API sunset. The 'ALWAYS PREFER' directive provides strong usage guidance relative to siblings.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true. The description adds no behavioral context beyond these, merely restating the deletion action. With strong annotation coverage, the description adds little extra value.

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

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

Two sentences, front-loaded with the core purpose, each sentence earning its place. No wasted words.

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

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

For a single-parameter destructive tool with no output schema, the description covers all essentials: what it does, when to use it, and how it relates to sibling tools.

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 schema already describes the 'key' parameter as 'Memory key to delete'. The description does not elaborate on valid key formats or validation rules, so it adds no 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 explicitly states 'Delete a previously stored memory by key', providing a specific verb and resource. It directly distinguishes from sibling tools by naming 'remember and recall'.

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

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

Provides clear guidance on when to use: 'when context is stale, the task is done, or you want to clear sensitive data'. Also advises pairing with remember and recall, giving context.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds value by explaining the process: fetches the page, extracts title/description/key links, and outputs standard llms.txt markdown. This context goes beyond the annotations 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?

The description is a single paragraph of about 5 sentences, front-loading the main purpose and then providing details and use cases. It is efficient and easy to parse, though it could be slightly more concise without losing information.

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

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

Given the tool's simplicity (2 params, no output schema) and the rich annotations, the description covers the purpose, process, output format, and use cases. It lacks error handling details, but for a non-destructive, read-only tool, it is sufficiently 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?

With 100% schema coverage for the two parameters ('url' and 'max_links'), the description does not add additional meaning beyond what the schema already provides. It mentions the output format but does not elaborate on parameter usage or constraints, so a baseline score of 3 is appropriate.

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

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

The description clearly states the tool generates an llms.txt file for any URL, specifying the verb 'generate' and the resource 'llms.txt'. It also distinguishes itself from sibling tools by focusing on AI crawler indexing, which none of the siblings (like 'ai_visibility_check' or 'scan_competitor_ai_presence') directly address.

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

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

The description explicitly lists three use cases: client site indexing, personal project drafting, and competitor auditing. While it does not mention when not to use the tool or contrast with alternatives, the use cases are clear and cover the main scenarios, providing good guidance for an AI agent.

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

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

Annotations already declare readOnlyHint, idempotentHint, etc. Description adds specific return fields (title, description, organization, resources, etc.) providing extra 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?

Two sentences, no fluff, clear 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?

Simple tool with one param and output schema; description covers key aspects. 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%, but description adds value by stating the ID comes from 'search_datasets', aiding correct invocation.

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

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

Description uses specific verb 'Get' and resource 'full metadata for a HealthData.gov dataset by its package ID.' It lists return fields, differentiating it from sibling 'search_datasets' which presumably returns a list.

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

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

Implies when to use: when you have a specific package ID and want full metadata. Not explicitly exclusive but clear usage context given siblings.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, etc. Description adds return field specifics and clarifies 'active subscriptions' default behavior, but safety profile is already covered.

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

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

Two concise sentences, front-loaded with purpose, 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?

Complete for a read-only list tool. Annotations cover safety, description covers purpose, return fields, and usage guidance. No output schema needed since fields are listed.

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% (single parameter with description). Description adds minimal extra context ('active subscriptions' default), but schema already does heavy lifting.

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

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

Description clearly states 'List the caller's active subscriptions' and lists return fields (id, type, params, etc.). It distinguishes from siblings 'subscribe' and '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 guides when to use: 'Use this to review what you're monitoring before adding more or to find an id to cancel.' Provides clear context and excluded reasons.

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?

Although annotations are all false (no strong safety hints), the description adds rich behavioral context: rate-limiting ('5 per identifier per day'), cost ('Free; doesn't count against your tool-call quota'), asynchronous processing ('The team reads digests daily'), and the claim_token mechanism for later retrieval. This goes well beyond the annotations and sets clear expectations for side effects and limitations.

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 lengthy but well-structured: purpose first, then scope/exclusions, then workflow, then constraints. Every sentence contributes necessary guidance for this deceptively simple feedback tool. While it could be tightened slightly, the density is justified by the need to prevent misuse and explain the token-based follow-up.

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

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

With no output schema, the description must explain return values, which it does via the claim_token explanation. It covers all critical dimensions: what to report, what not to report, how to follow up, rate limits, and the fact that feedback is read by humans daily. The tool is fully specified for an agent to invoke it correctly in all intended scenarios.

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%, giving each parameter a description. The tool description goes further by adding usage semantics: it explains the claim_token round-trip pattern ('pass it back later as pipeworx_feedback({claim_token:"pwfb_…"})'), instructs users to describe issues 'in terms of Pipeworx tools/packs' rather than pasting end-user prompts, and gives length guidance ('1-2 sentences typical, 2000 chars max'). This adds value 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: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It distinguishes this from sibling tools by explicitly limiting scope to 'tools served by this Pipeworx connection' and contrasting with 'a different MCP server.' The verb 'tell/send' and resource 'Pipeworx team' are specific and unambiguous.

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

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

The description provides explicit when-to-use guidance: bug, feature, data_gap, or praise. It also states when NOT to use it ('if the tool came from a different MCP server') and names the alternative ('file it with that server instead'). It additionally covers the claim_token workflow for follow-up, making the intended usage pattern fully clear.

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

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

Annotations already indicate read-only, idempotent, non-destructive. The description adds valuable context: data is self-aggregating from CF analytics-engine, no PII, cached 5min to 1h. This goes beyond annotations and sets proper 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 front-loaded with the core functionality, followed by bullet-point use cases and additional details. Each sentence contributes meaning, though it could be slightly tighter.

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 clearly explains what is returned (top tools, packs, volume) and covers the data source, caching, and parameter behavior. It is complete for the tool's complexity.

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

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

Schema coverage is 100% with a well-described enum parameter. The description adds minimal extra value beyond what the schema already provides, so a baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: returns top tools, top packs, and total call volume over a recent window. It uses specific verbs and nouns, and distinguishes itself from siblings by focusing on trending data aggregated from other AI agents.

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, explaining when to use the tool. It also differentiates between shorter and longer windows for different needs. However, it does not explicitly state when not to use this tool 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 indicate readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false, and the description adds significant behavioral details: scanning top ~200 markets, partition checks, semantic anchor for similarity, placeholder filtering, fill check against CLOB depth, and output structure. 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 sections (SEMANTIC ANCHOR, PARTITION FILTER, FILL CHECK), but is somewhat long and dense. Every sentence adds value, but could be slightly more concise for an AI agent.

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

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

Despite no output schema, the description explains the response format (opportunities[], partition_check) and trade signals. It covers modes, edge cases (placeholders, low similarity), and ties into fill risk. Annotations provide safety context. The description is comprehensive for the tool's complexity.

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

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

Schema description coverage is 100%, and the description adds depth: explains what event slugs and topic strings look like, gives examples, and describes how each parameter affects behavior (single-event vs cross-event). This goes 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: finding arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It distinguishes between three modes (no args, event, topic) and provides specific 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?

The description explicitly guides when to use each mode: no args for trending scan, event for specific market, topic for cross-event scanning. It recommends the event mode for a specific market. However, it does not explicitly contrast with sibling tools like polymarket_edges or polymarket_fill_risk, leaving some 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 set readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description goes far beyond these by detailing caching (1h at KV level), the five model families and three response segments, edge calculation details (slippage, Kelly fractions, spread filters), and diagnostic fields. It also explains the 'Fed note' exclusion and tradeable-edge knobs.

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 quite long (over 600 characters) and includes extensive technical details about model families, edge calculation, and diagnostics. While it is front-loaded with the main purpose, the verbosity could be trimmed. It uses inline formatting with parentheses and dashes but lacks clear section breaks.

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 (9 parameters, no output schema, rich annotations), the description covers all necessary information: the output structure (by_segment segments, diagnostics), the edge calculation methodology, caching behavior, and the purpose of each knob. It compensates well for the lack of an output schema by describing the response top-level fields.

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 meaningful context beyond the schema for parameters like category_filter (explaining how to combine segments) and min_partition_leg_kelly (explaining why min_kelly doesn't filter partition arbs and what this knob does instead). Some parameter descriptions in the description are redundant with the schema, but overall it adds value.

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

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

The description clearly states that the tool scans top Polymarket markets to find opportunities where Pipeworx data disagrees with market price, specifically built for 'what should I bet on today'. It distinguishes itself from sibling tools like polymarket_arbitrage and polymarket_edge_tracker by focusing on edge discovery across multiple model families and providing a ranked output.

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 the primary use case (discovering betting opportunities) and provides guidance on how it works (scanning top markets without paging). It also notes that Fed bets are excluded from ranking due to unreliable signal. However, it does not explicitly mention when not to use this tool or suggest alternatives among the sibling tools.

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

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

The description adds significant behavioral context beyond annotations: it details the three response arrays (tracked, expired, snapshot_dates) with field semantics, explains that decay is computed on absolute edge value with signed direction, and notes limitations (60-day TTL, daily closes, not intraday). Annotations already indicate readOnly and idempotent, and description does not contradict any 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 front-loaded with the core purpose and then details the response structure. It is somewhat lengthy but every sentence provides value, explaining edge cases (gaps in snapshots, median lifespan). It could be slightly more concise without losing information.

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

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

Given no output schema, the description fully describes the response structure with field names and meanings (tracked, expired, snapshot_dates, first_seen, trend, decay_pp_per_day, lifespan_days, etc.). It also covers limitations (snapshot TTL, decay basis). For a tool with two optional parameters, the description is very complete.

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

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

The input schema has 100% coverage with descriptions for both parameters (days, window). The tool description reaffirms defaults and clamping but does not add new semantics beyond the schema. Per rubric, high schema coverage yields a baseline of 3; the description does not warrant a higher score as it adds minimal extra meaning.

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

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

The description clearly states the tool answers 'how long has this edge existed and is it shrinking?' and explains the distinction between a fresh wide edge and an old one. It uses specific verbs (edge persistence and decay telemetry) and distinguishes from sibling tools like polymarket_edges by focusing on time-series and decay.

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 guidance on when to use the tool: to assess edge persistence and decay, with concrete examples. It does not explicitly state when not to use it, but context from sibling tools (e.g., polymarket_edges for raw edges) provides indirect guidance. A clear 'when to use' is present, but 'when not to use' is implied rather than stated.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false. The description adds behavioral context beyond annotations: walking the order-book ladder, returning specific metrics (vwap_fill_price, slippage_pp, verdict), and highlighting that partial basket fills convert arb into unhedged directional positions – a key risk. 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 well-structured with clear sections (SINGLE-MARKET, BASKET) and uses bold for key terms. While somewhat long, every sentence adds value. Minor deduction for length; could be slightly tighter but remains highly functional.

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 comprehensively lists all return values for both modes (e.g., top_of_book, vwap_fill_price, capture_ratio, profit_usd, forced_directional_risk). It covers edge cases (thin books, partial fills) and states the dominant loss mode. Complete for a complex tool.

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

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

Schema coverage is 100% with descriptions, but the tool description adds significant meaning: explains modes (single-market vs basket), default values, interpretation of size_usd (max spend vs target proceeds vs settlement notional), and details per-mode parameter usage. This compensates for any schema brevity.

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

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

The description clearly states the tool checks realizable-vs-theoretical edge against live order-book depth. It distinguishes between single-market and basket modes with specific verbs (check edge, compute fill details) and resources (market, event). It differentiates from sibling tools like polymarket_arbitrage by recommending use before acting on their signals.

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

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

Explicitly states when to use: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500'. Also implies when not needed (small trades) and warns about risks of partial fills, providing clear decision criteria.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description goes well beyond this by disclosing matching methodology (legs matched by 'keyword and word overlap, not a shared resolution source' via premapped_pairing_unverified), exclusion behavior (unknown metric_type/match_subtype legs are NEVER paired and land in skipped_unclassified/low_confidence_pairs), the full compatibility_warning code list, temporal_alignment reporting, and the skipped_cross_type/subtype counters. This is exactly the behavioral context an agent needs that structured fields cannot convey.

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

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

The description front-loads well: purpose, then modes, then response. But the body is a dense, rambling single paragraph where the compatibility warning codes and flag definitions are packed into run-on parentheticals, and there is visibly garbled/repetitive text ('returns BOTH leg sets where BOTH sides show a match...'). Several definitions (metric_type vs match_subtype, temporal alignment) could be structured more cleanly. The length is partly justified by the absence of an output schema, but the organization hurts 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?

Despite having no output schema, the description documents the response shape thoroughly: leg-by-leg prices in raw probability 0-1, matched spread[].top_spreads_pp, per-entry flags[], compatibility_warning[] with six named codes, temporal_alignment{polymarket_month,kalshi_month,aligned}, and skipped counters. It also covers edge cases (unclassified legs excluded, most topics returning warnings today). The only notable gap is a concrete worked example of a response, which would make it fully complete for a tool this complex.

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% — each of the three parameters already has a description with an example. The description adds genuine value beyond the schema by explaining the mode semantics: topic is a 'pre-mapped macro shortcut' that auto-fetches the matching event on each venue, while kalshi_event_ticker and polymarket_event_slug are for custom pairings and override the topic-mapped side. This param-relationship information is not present in the schema and materially helps an agent pick the right combination.

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 opening sentence — 'Cross-venue spread between Kalshi and Polymarket for the same resolving question' — names a specific verb (compute/compare), two specific resources (Kalshi and Polymarket venues), and the object (spread for the same resolving question). The response section even pins down the delta direction (Kalshi − Polymarket). This clearly differentiates it from siblings like polymarket_arbitrage and polymarket_edges, which concern within-venue pricing rather than cross-venue comparison of the same question.

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 in-tool usage guidance: TWO MODES, with topic for 10 pre-mapped macro shortcuts and explicit kalshi_event_ticker + polymarket_event_slug for custom pairings, plus the relationship between them (explicit params override the topic-mapped side). It also cautions 'pre-mapped ≠ tradeable' and warns 'most pre-mapped topics return compatibility_warning today', which helps an agent decide whether a topic-mode call will be productive. It does not, however, name sibling alternatives (e.g., when to use polymarket_arbitrage instead), so cross-tool routing is left implicit.

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

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

Description adds scoping details (identifier-based) and the behavior when key is omitted, beyond annotations that already state readOnly and idempotent.

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

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

Three concise sentences, front-loaded with the main action, 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?

No output schema, but description adequately implies return values. Sufficient for a simple retrieval tool with good annotations.

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

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

Schema has 100% coverage with a clear description. Description repeats and clarifies the omission behavior, adding slight extra value.

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

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

The description clearly states the tool retrieves a value saved via remember or lists all keys, using a specific verb and 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?

Explicitly says 'Use to look up context the agent stored earlier' and mentions scoping. Does not explicitly state when not to use, but context makes it 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 that setting mark_read:true will flag events as read, implying a write operation. However, annotations declare readOnlyHint=true, contradicting this behavior. This significantly harms transparency.

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

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

The description is concise, with every sentence adding meaningful information. It is well-structured, front-loading purpose, then payload details, filtering, side effects, and alternatives.

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

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

The description covers purpose, return payload, filtering, side effects, and alternative access methods. It lacks information on error handling or pagination, but given the tool's simplicity and annotations, it is mostly complete.

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

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

Schema coverage is 100%, and the description adds value by providing concrete examples (e.g., type 'sec_8k') and explaining the effect of mark_read on future calls, which the schema alone does not convey.

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 'Pull fired events from your subscription feed' with clear verb+resource. It specifies the return payload and filtering options, making it distinct from sibling tools like 'list_subscriptions' or 'recent_changes'.

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

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

The description provides context for usage, mentioning polling and an alternative REST endpoint for scripts/dashboards. It does not explicitly exclude sibling tools, but the tool's purpose is well-defined for reading recent alerts.

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

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

Discloses fan-out to multiple sources, fallback behavior, soft-fail for USPTO, and return structure. Annotations already indicate read-only, idempotent, non-destructive; description adds significant 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?

Single paragraph with logical flow, but slightly lengthy. Every sentence adds value, but could be trimmed 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?

Completely explains tool behavior, inputs, outputs, and alternatives, compensating for lack of output schema.

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

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

Adds meaning beyond schema: explains since format with examples, recommends default, clarifies value types, and confirms type enum restriction.

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 returns a change feed for a company across multiple sources, provides example queries, and distinguishes from entity_profile.

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

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

Explicit when-to-use guidance with example queries, and when-not-to-use by recommending entity_profile for static profiles.

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 it's a write operation with idempotentHint=true. The description adds scope (key-value by identifier), persistence details (authenticated vs anonymous), and mentions pairing with recall/forget. No contradictions with annotations.

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

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

The description is concise, well-structured, and every sentence adds value. It front-loads the core purpose and efficiently covers usage, behavior, and pairing.

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 purpose, usage, parameters, behavioral traits, and context. It is complete for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100% with clear descriptions. The description adds example values like 'subject_property' and 'target_ticker', providing extra guidance 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 verb 'save', resource 'data', and context 'across this conversation or across sessions'. It distinguishes from siblings by mentioning 'recall' and 'forget' later.

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 when to use: 'when you discover something worth carrying forward'. It also suggests pairing with recall/forget. However, it does not explicitly state when not to use or provide alternatives beyond the mentioned siblings.

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

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

Despite no contradiction with annotations, the description adds substantial behavioral context beyond readOnly/idempotent hints. It explains source labelling, explicit handling of unresolved identifiers, graceful degradation of LEI/FIGI enrichment, internal cascading through endpoints, and the ISIN-to-LEI mapping for non-US issuers. This is rich, valuable transparency.

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

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

The description is long but densely packed with essential information. It is well-structured with a purpose statement, supported types, and fallback notes. Some redundancy exists ('resolve a user-spoken NAME...' and 'Use FIRST whenever you have a name but need an ID' convey similar ideas), but overall each sentence contributes 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?

With no output schema, the description must explain return values, and it does: identifiers with source labels, unresolved fields, and enrichment behavior. It covers input formats, automation of multiple lookups, and error resilience. Given the tool's complexity, the description is exceptionally thorough and leaves little 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%, but the description adds meaning by explaining what each type returns: for 'company' it lists CIK, ticker, LEI, FIGI, and ownership data from specific sources; for 'drug' it specifies RxCUI, ingredient, brand, and citation. It also introduces ISIN as a valid company input not mentioned in the schema. 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 explicitly states the tool's purpose: 'resolve a user-spoken NAME to the canonical/official identifiers other tools require as input.' It provides concrete example queries and distinguishes itself from siblings by positioning it as the first step for obtaining IDs. The verb 'resolve' plus resource (name to identifier) is specific and unambiguous.

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

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

The description gives clear when-to-use instructions: 'Use FIRST whenever you have a name but need an ID.' It also notes the tool 'replaces 2-3 manual lookups,' implying efficiency. However, it does not explicitly name alternative tools or state when NOT to use it, so it falls short of a 5.

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

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

Annotations already indicate read-only, idempotent, non-destructive. The description adds behavioral details: it probes each entity with ai_visibility_check, uses first entity as subject, returns ranked list with score/confidence/signal density. No contradiction with annotations.

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

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

Three sentences: first states core function, second explains mechanism, third gives use case and output. Concise, front-loaded, no fluff.

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

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

Despite no output schema, the description clearly states return format (ranked list with score/confidence/signal density). It covers all required aspects and optional parameters. Sufficient for a read-only comparison tool.

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

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

Schema coverage is 100%, so baseline 3. The description adds value: explains 'entities' are brand names with first as subject, clarifies 'models' probe options, describes '_apiKey' condition, and 'context' disambiguation. This goes beyond schema.

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

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

The description clearly states the tool compares AI visibility across multiple entities side-by-side, ranks them, and identifies most/least recognized. It distinguishes from sibling tool ai_visibility_check by specifying multi-entity comparison and ranking.

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 concrete usage context ('competitive AI-marketing audits') and implies when to use (comparing multiple brands). It does not explicitly exclude alternatives, but the purpose 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?

Adds substantial behavioral details beyond annotations: fans out across two sources, returns specific fields, partial failures degrade gracefully, and bundlephobia's first measurement can take 5-30s. 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?

Front-loaded with purpose, but somewhat verbose with detailed return field listing and timing caveats. Every sentence adds value, but could be slightly more compact.

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 data sources, partial failures), no output schema, and rich annotations, the description fully covers when to use, what it returns, edge cases (timeouts, ecosystem scope), and behavior. An agent has sufficient context.

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

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

Schema coverage is 100%, so baseline is 3. The description adds minor context about scoped packages and version defaulting, but does not significantly enhance understanding beyond the schema's 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: a composite check for adding an npm package, combining data from deps.dev and bundlephobia. It uses a specific verb (scan) and resource (dependency), and distinguishes from sibling tools by its unique 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?

Explicit usage guidance: 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me"'. Also mentions NPM-only scope and partial failure behavior. Lacks explicit when-not-to-use, but context is clear.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, providing a strong baseline. The description adds beyond by specifying the return fields (titles, descriptions, organizations, resource links), which clarifies the output structure 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 a single, well-structured sentence with relevant examples. It conveys the purpose and output in a compact form with no wasted words.

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

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

Given that an output schema exists, the description does not need to detail return values. It mentions the key return fields and the source. For a simple search tool, this is sufficient, though it could hint at pagination or result limits.

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

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

Schema coverage is 100%, so the baseline is 3. The description provides keyword examples that align with the query parameter but does not add meaning beyond the schema's description. It is adequate but not exceptional.

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 searches HealthData.gov for public health datasets by keyword, which distinguishes it from sibling tools like search_within or deep_research that target different sources or types of data. The specific verb 'Search' and resource 'HealthData.gov' make 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 implies usage for searching public health datasets by keyword, but it does not provide explicit guidance on when to use this tool versus alternatives (e.g., search_within or bet_research). There is no mention of exclusions or conditions, leaving the agent to infer from context.

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

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

Annotations already indicate readOnlyHint, idempotentHint, openWorldHint, and non-destructive. The description adds technical details: 'BGE-base-en embeddings + cosine over 500-char overlapping windows; cap is 200K chars' and mentions truncation and verification via offsets. No contradiction with annotations.

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

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

The description is a single well-structured paragraph: purpose, when to use, pairing with alternative, then technical details. It is concise and front-loaded, though some redundancy could be trimmed (e.g., 'returns only the passages that matter' is implied by previous sentence).

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

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

Given the tool has 3 parameters, no output schema, and annotations covering safety, the description covers purpose, usage, technical details (embedding model, chunking, character limit), and pairing with another tool. The agent has sufficient information to decide and invoke the tool correctly.

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

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

The input schema already has 100% description coverage for all three parameters. The description adds concrete examples for text ('e.g. a SEC 10-K body') and query (examples like 'supply-chain risk'), and specifies default and range for limit, enhancing 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 'Semantic search INSIDE a fetched record,' specifying the verb (search) and resource (a fetched record, e.g., SEC filing or article). It distinguishes from siblings by explicitly mentioning pairing with ask_pipeworx_grounded and noting that it's used when the record is too large for the prompt.

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: 'Use when the record is too big to cram into the prompt' and 'Pairs with ask_pipeworx_grounded.' It gives an alternative tool for grounding, but does not explicitly state when not to use this tool, though it is implied.

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

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

Disclosures beyond annotations: subscription creation is a write operation (consistent with readOnlyHint=false), returns ID, requires specific account type, mentions rate limits (10/day SMS), and webhook signing secret returned once. 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?

Dense but well-structured with clear topic sentences. Could be slightly more concise or organized into bulleted sub-sections, but front-loads the main action and progresses logically.

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

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

Covers almost all aspects: creation, types, delivery, requirements. Lacks explicit return format for non-webhook deliveries, but consistent with no output schema. Persistent feed mention helpful. Highly complete for a complex tool.

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

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

Schema coverage is 100%, and the description adds significant value: explains type-specific params with examples, delivery constraints (verified phone, email pattern, webhook restrictions), and default feed. Enhances schema significantly.

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 creates a proactive monitoring subscription to a live-data event stream and returns a subscription ID. It distinguishes from sibling tools like list_subscriptions and unsubscribe by specifying creation. Examples of supported types and delivery channels reinforce 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 clear context: requires Pipeworx OAuth account, lists supported types with examples, and delivery options. Implicitly distinguishes from alternatives like list_subscriptions. Could be more explicit about when not to use or prior setup like phone verification, but overall adequate.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false. The description adds value by detailing output structure (category-bucketed questions with tool+argument shapes) and behavior differences between no arguments and topic parameter. No contradictions.

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

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

The description is somewhat verbose but front-loaded with natural language questions that help match user intent. Every sentence is informative, and the structure is logical: intent, behavior, parameter guidance.

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

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

For a simple tool with one optional param and no output schema, the description covers all needed context: what it returns, when to use it, how to parameterize, and its role in the tool ecosystem. 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% with one param described. The description adds meaning beyond the schema: explains the purpose of the topic param ('focus area'), provides example values, and clarifies that omitting it gives a cross-category spread.

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 category-bucketed example questions for Pipeworx. It uses specific verbs ('returns') and resources ('example questions') and distinguishes from siblings by positioning it as the onboarding entry point, unlike ask_pipeworx or discover_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 says 'Use this FIRST when you do not yet know what Pipeworx can do' and explains how to call with or without topic. While it doesn't list explicit alternatives, the context and sibling list provide sufficient 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?

Explains deactivation instead of deletion and references 'recent_alerts' for historical events. Complements annotations (destructiveHint=false) 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?

Two sentences with no waste. First sentence states purpose and constraint, second adds behavioral 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?

Low-complexity tool with full schema and annotation coverage. Description covers ownership and deactivation, sufficient for operation.

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

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

Schema covers 100% of parameters; description adds that id comes from 'subscribe' function, providing source context.

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

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

Specific verb 'cancel' with resource 'subscription' by id, clearly distinguishing from 'subscribe' and 'list_subscriptions'.

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?

States to cancel your own subscriptions with ownership enforcement; implicit when-not by exclusion, but no explicit alternatives given.

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

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

Annotations already declare readOnly/openWorld/idempotent, but the description adds vital behavioral context: the two-path routing (SEC EDGAR fast path vs. grounded pipeline), the exact meaning of verdicts, and critical caller guidance that could_not_verify means the check didn't happen and must not be treated as evidence. This goes well beyond the annotations.

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

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

Despite being long, every sentence adds operational value: trigger phrases, pipeline routing, verdict definitions, error semantics, and efficiency claim. The content is dense and front-loaded with the most actionable usage cue.

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, two-path verification tool, the description covers the full lifecycle: input forms, processing routes, output verdicts, citation format, error distinctions (could_not_verify vs. unsupported), and tolerance behavior. No output schema exists, but the description adequately enumerates return value semantics.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by giving concrete claim examples and explaining how tolerance_pct overrides wording-implied tolerance with a default cap at 5. This clarifies semantics beyond the schema's 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's verb and resource: 'natural-language claim verification against authoritative sources' with explicit trigger phrases ('fact check', 'verify the claim that…'). It distinguishes itself from generic question-answering tools by specifying a verdict-based output (confirmed, refuted, etc.) and a split pipeline for company-financial vs. other claims.

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

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

Explicitly states when to use: 'Use whenever the agent needs to check whether something a user said is factually correct.' It gives detailed sub-guidance for financial vs. non-financial claims. It doesn't name alternative tools (e.g., ask_pipeworx_grounded) but notes it replaces 4–6 sequential calls, implying a composite convenience role.

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