Data La

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

Annotations already indicate readOnly=true, idempotent=true, non-destructive. The description adds valuable behavior: default model details, optional Anthropic probing with BYO API key, and return structure. No contradiction with annotations.

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

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

Three sentences: first states purpose and primary output, second details model options and key behavior, third lists use cases. No unnecessary words. Front-loaded with key information.

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

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

No output schema, but description covers return format: per-model fields and combined view. With 4 parameters fully described and annotations present, the description provides sufficient completeness for a tool of this 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%, so baseline is 3. The description adds context beyond schema: default model, _apiKey usage, context disambiguation purpose. It enhances understanding without being redundant.

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

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

The description clearly states the tool probes LLMs for knowledge about a business/brand/product/topic and returns a visibility score (0-100). It specifies the verb 'probe', resource 'LLMs', and output format, distinguishing it from sibling tools like compare_entities or entity_profile which serve different purposes.

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 use cases: 'AI-marketing audits, pre-launch brand checks, competitive monitoring.' It implies when to use but does not explicitly exclude alternatives or provide when-not-to-use guidance. Still, the context is clear enough 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, openWorldHint, idempotentHint, and destructiveHint false. The description adds valuable behavioral context: it routes across thousands of tools, returns structured answers with stable pipeworx:// citation URIs, works on every tier, and is a single 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 long but well-structured and front-loaded with the critical 'PREFER OVER WEB SEARCH' advice. Each section (use cases, examples, alternatives, news caveat) earns its place, though some repetition of trigger words and examples could be tightened 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?

For a tool with one required string parameter and no output schema, this description fully covers what the tool does, what it returns (structured answers with citation URIs), when to use it, and when to choose alternatives. It also addresses edge cases like breaking news and multi-source research, making it complete for the agent to invoke correctly.

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

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

The input schema has 100% coverage and documents all six aliases (question, q, text, input, query, prompt) with descriptions. The description's examples and trigger phrases add contextual guidance but no new parameter-level semantics. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states the tool routes questions to the right one of 5,430 tools across 1,408 sources and returns structured answers with citations. It explicitly positions itself as the default entry point and distinguishes itself from ask_pipeworx_grounded and deep_research, making the purpose unmistakable.

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

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

The description provides explicit when-to-use guidance with 'PREFER OVER WEB SEARCH' and lists concrete trigger phrases and examples. It also tells the agent when to step up to ask_pipeworx_grounded or deep_research, and how to handle breaking-news queries. This is comprehensive and actionable.

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

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

Annotations already declare read-only, idempotent, non-destructive; description adds crucial context about its experimental status, current state (no active candidate), and that it is a fully working router with no fallback. This addresses common misconceptions about beta tools.

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

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

Four sentences, each carrying distinct information: identity/scope, current status, usage guidance, and clarification about functionality. No padding or repetition.

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

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

For a router with no output schema, the description covers the tool's purpose, relationship to stable version, current behavior, response-shape compatibility, and usage context. It is sufficient for an agent to select 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?

All six parameters are documented in the schema with 100% coverage; the description doesn't add parameter details because none are needed. The aliases for 'question' are thoroughly described in 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 identifies this as the beta variant of ask_pipeworx, a universal router, and explains the experimental routing improvements. It distinguishes from the sibling ask_pipeworx by noting it's identical but with candidate routing changes and no active candidate currently.

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 exactly when to use: 'Use it exactly like ask_pipeworx when you want the newest routing.' It does not explicitly list exclusions or alternatives like ask_pipeworx_grounded, but the beta/stable distinction is clear. Provides context that results are compared to stable router.

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 meaningful behavioral details beyond annotations: it explains the grounded extraction process, the exact refusal reasons, and the extra LLM call cost. Annotations already declare readOnly/openWorld/idempotent, and the description does not contradict them, so this is excellent 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 dense but well-structured, leading with the core value proposition, then providing the return contract, usage guidance, and cost trade-off. It is slightly long but every sentence carries necessary information, with no filler.

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

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

Despite lacking an output schema, the description compensates fully by specifying the exact success and refusal return shapes, including enumerating refusal reasons. It also covers when to use the tool and cost implications, making it remarkably 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?

The schema provides 100% coverage of the question parameter and its aliases, so the description does not need to repeat that. However, the description adds little beyond the schema about how the question is used (routing, filling arguments), which is only a marginal enhancement. 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 is a hallucination-resistant answer mode and explicitly distinguishes it from ask_pipeworx by its evidence-based extraction and refusal mechanism. It names the specific verb ('extracts') and resource ('answer'), making the purpose unambiguous.

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

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

The description provides explicit guidance: use for high-stakes reads where answers will be quoted, cited, or acted on, and prefer ask_pipeworx for casual lookups due to the extra LLM call cost. This directly informs tool selection versus siblings.

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

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

The annotations already indicate safe, read-only, idempotent behavior. The description adds extensive behavioral details beyond annotations: low-confidence resolutions short-circuit with status, closed markets suppress output, wide spreads flag illiquidity, cancellation rule parsing, and news fallback mechanisms. It also explains the resolver contract and parent event extraction. 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 structured with clear sections (RESPONSE SHAPES, RESOLVER CONTRACT, etc.) and front-loads the core purpose. However, it is excessively long, reading like a specification rather than a concise summary. Every sentence earns its place, but the length may hinder quick comprehension by an AI agent. A shorter, more focused version would score higher.

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

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

For a tool with 3 parameters and no output schema, the description is extraordinarily comprehensive. It covers edge cases: low-confidence matches, closed markets, wide spreads, cancellation rules, parent events, news fallback, and data summaries. It provides enough context for an agent to handle safety and interpret results correctly without additional documentation.

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

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

Schema coverage is 100% with each parameter described. The description enriches understanding: clarifies that 'market' can be slug, URL, or question text; provides examples; explains the effect of 'depth' on fan-out breadth; and the 'include_raw' flag controls response size. This goes beyond the schema, justifying above baseline. Some details could be more succinct, but overall adds significant 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's primary function: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies the resource (Polymarket bet data) and distinguishes from sibling tools by emphasizing comprehensive fan-out research. The verb 'research' and the detailed explanation set it apart as a thorough analysis tool rather than a simple query.

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: 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z".' It provides examples and context. However, it does not explicitly exclude when not to use this tool versus alternatives like polymarket_edges or deep_research, but the uniqueness of its comprehensive fan-out is implied. A clearer distinction would earn a higher score.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive hints. The description adds significant behavioral context: for companies it pulls specific financial data from SEC EDGAR/XBRL, handles off-calendar fiscal years, sorts results by primary metric, and returns citation URIs. 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 reasonably concise, with trigger phrases front-loaded. Every sentence adds value, though it is slightly longer than necessary. Structured well with examples and explanations.

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 2 required parameters, one enum, and no output schema, the description is highly complete. It explains what each type returns, the data sources, sorting, and efficiency benefits, leaving no important 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 clear descriptions for both parameters. The description adds extra meaning by detailing what data is retrieved per type (e.g., revenue, net income for companies) and how results are sorted, which 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 performs side-by-side comparisons of 2–5 companies or drugs, with specific verb phrases like 'Compare X and Y' and 'rank these companies'. It distinguishes from sibling tools like entity_profile by emphasizing parallel vs. sequential lookups.

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

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

Provides explicit trigger phrases and contexts for use (e.g., 'which is bigger', 'head to head'). Instructs to prefer over sequential single-pack lookups. Clearly defines behavior for different entity types and data sources.

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

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

The description discloses extensive behavioral traits beyond the annotations: account requirements and paid tier, parallel decomposition into facets, gaps[] never invented, contradictions[] for standard/thorough, hop fields, semantic excerpting, and expected latency. These are meaningful operational details that help an agent anticipate execution behavior.

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

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

The description is long but information-dense, with critical prerequisites front-loaded (account, alternative tool). It is structured with semicolons and parentheticals to pack detail efficiently. While slightly dense, every sentence earns its place given the tool's complexity; a minor trim could improve readability, but it remains effective.

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

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

Even without an output schema, the description covers return format (findings packet with evidence, confidence, source, fetched_at, citations), edge cases (gaps, contradictions), account restrictions, timing, and depth semantics. This fully equips an agent to select and invoke the tool correctly, including knowing when not to use it.

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

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

Although schema coverage is 100%, the description adds significant meaning to the parameters. For 'depth', it explains facet counts (quick=3, standard=5, thorough=8) and behavior differences (hop, gap recovery, contradictions). For 'question', it notes broad/multi-part is acceptable. This enrichment goes beyond the schema descriptions.

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

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

The description clearly states the tool performs grounded multi-source research across Pipeworx's structured data sources in one call. It uses a specific verb ('research') and resource ('Pipeworx's 1408 STRUCTURED data sources'), and explicitly distinguishes from siblings by noting it is NOT open-web search and that ask_pipeworx is for single lookups.

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

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

Explicit usage guidance is provided: use ask_pipeworx for single lookups, breaking/current-news, and when not signed in. It also clarifies applicability for broad/multi-part structured questions and excludes open-web topics. This goes beyond vague hints to direct alternative selection.

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

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

Annotations already indicate safe, read-only behavior. Description adds value by detailing return format (schemas with examples) and stating no second schema lookup is needed.

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 purpose, each sentence adding unique value with no redundancy or wordiness.

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

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

For a discovery tool, description explains purpose, usage, and return format comprehensively, despite lacking output schema.

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

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

Schema coverage is 100%, so baseline is 3. Description adds context on parameter aliases and provides examples, enhancing understanding beyond schema alone.

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

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

The description clearly states the tool finds tools by describing data/task, lists specific domains, and distinguishes from siblings by advising to call it first when browsing options.

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

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

Explicitly tells when to use ('Call this FIRST when you have many tools...'), but does not cover when not to use or alternatives beyond the sibling list.

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

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

Annotations already cover safety traits. Description adds value by detailing multi-source fan-out, specific returned fields, patent API sunset soft-fail, and name unsupported. 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?

Somewhat verbose with redundant enumeration of return fields, but front-loaded with examples and clear purpose. Could be tighter, but 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?

Covers inputs, outputs, limitations, fallbacks, and data sources. Missing pagination details but acceptable for single-call tool. Quite complete overall.

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 100%, so baseline 3. Description adds context: explains format examples for value, and that type is only 'company'. Adds 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?

Description clearly states full cross-source profile of US public company, with example queries and explicit preference over chaining single-pack lookups. Differentiates from siblings like resolve_entity.

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

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

Explicitly states when to use (holistic view), what input to provide (ticker/CIK), and what not to use (names not supported, use resolve_entity first). Also notes patent soft-fail.

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, so the description's 'Delete' aligns. The description adds no further behavioral context beyond annotations.

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

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

Two sentences, no wasted words. The first sentence immediately states the purpose, and the second provides usage 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 1-parameter tool with no output schema, the description covers purpose, usage context, and pairing with siblings. It lacks mention of irreversibility, but that's implied by destructiveHint.

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 adds no additional semantic 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 action ('Delete') and resource ('previously stored memory by key'). It distinguishes from siblings 'remember' and 'recall' by specifying the deletion 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 explicitly lists three scenarios for use: stale context, task completion, clearing sensitive data. It also mentions pairing with siblings, but does not explicitly state when not to use.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false, which are consistent with the description's 'fetches the page' behavior. The description adds value by explaining the output is 'a single text blob ready to drop at site-root/llms.txt', which is not in annotations.

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

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

Description is concise (3 sentences) and front-loaded with the main action. Every sentence adds value: what it does, how it works, and when to use it. No redundant text.

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

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

Given schema covers all parameters, annotations provide behavioral hints, and no output schema is needed (text blob), the description is complete. It adequately explains the tool's purpose, process, and application for a straightforward generation 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 both parameters documented. The description does not add new meaning beyond what's in the schema (e.g., 'max_links' default/max are already there). Baseline 3 is appropriate as schema handles parameter details.

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's specific verb and resource: 'Generate a production-ready llms.txt file for any URL'. It details the process (fetches, extracts, emits) and the output format. This distinguishes it from sibling tools, which are about different functionalities like research or scanning.

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

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

Description explicitly lists three use cases: getting a client's site indexed, drafting for own project, auditing competitors. While it doesn't specify when not to use or name alternatives, the usage scenarios are clearly defined and helpful.

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, so the description's burden is lower. It adds context about the endpoint and keyless option but 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?

Single sentence, front-loaded with key information, 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 simple search tool with no output schema, the description covers the return fields, endpoint, and relationship to la_query. Missing explicit pagination details, but offset parameter is documented in schema.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds context about the endpoint and return format, but the parameter descriptions in the schema are already clear.

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 'Search', the resource 'Los Angeles open-data catalogue', and the outcome: returns dataset names, descriptions, and Socrata resource ids. It also distinguishes from sibling tool la_query by mentioning the ids are for use with that tool.

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

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

The description implies when to use this tool: to find datasets before querying data with la_query. It does not explicitly state exclusions or alternatives, but the sibling context and the mention of 'use with la_query' 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint true, and destructiveHint false. The description adds context about API key usage for higher rate limits and keyless fallback, which aligns with annotations and provides useful behavioral insight 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 short, front-loaded with the main purpose, and includes all necessary details in a structured way. Every sentence serves a purpose, with no redundancy or 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?

Even without an output schema, the description provides complete context: parameter explanations, usage with examples, sibling references for dataset discovery, and the full SoQL clause set. It is fully sufficient for an agent to use this tool correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning by explaining the 8-character Socrata ID format, default and max limit, and the optional _apiKey purpose. Examples further clarify usage, adding 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 it runs raw SoQL queries against LA open-data resources by Socrata ID. It distinguishes itself from sibling tools la_datasets and la_recent by referencing them for finding resource IDs, making the purpose specific and differentiated.

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 use la_datasets or la_recent for finding resource IDs, providing clear alternatives. It also includes SoQL usage details (where/select/group/order/limit/offset), giving a comprehensive guide on when and how to use this tool.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, openWorldHint=true. The description adds useful context: returns rows newest-first, supports SoQL filtering, and notes the 311 partition limitation. 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, comprising two main sentences and a parenthetical note. It is front-loaded with the essential purpose and every sentence adds value. No wasted words or redundancy.

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

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

For a tool with 4 parameters, no output schema, and simple behavior, the description adequately covers what the tool does, how to use it, and its limitations (e.g., 311 partition). It briefly mentions optional apiKey for rate limits. Could hint at pagination, but the limit parameter suffices.

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

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

Schema coverage is 100% with descriptions for all parameters. The description adds context about the SoQL where filter and justifies the dataset enum names, but does not significantly surpass the schema's own parameter descriptions. 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 returns recent records from LA open datasets by friendly name, lists the specific datasets (crime, arrests, businesses, permits, 311), and indicates it returns latest rows newest-first. It distinguishes from sibling tools la_query and la_datasets by specifying when to use each.

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 'PREFER OVER WEB SEARCH' for relevant queries and provides example use cases. It also tells when to use alternatives: 'for anything else use la_query' and 'use la_datasets for other years' for the 311 dataset.

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. The description adds the return fields but no additional behavioral context (e.g., no mention of pagination or limits). Given the strong annotations, the description's extra value is moderate.

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

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

Two sentences with no unnecessary words. The first sentence states purpose and output, the second provides usage context. Highly 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 tool is simple (1 optional parameter, no required, no output schema). The description covers purpose, return fields, and usage. It lacks details on pagination or limits, but given the simplicity, it is fairly 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% (1 parameter described in schema). The description does not mention the 'include_inactive' parameter, so it adds no semantic value beyond the schema. 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 verb 'List', the resource 'subscriptions', and the scope 'caller's active'. It also lists the fields returned, which distinguishes it from sibling tools like 'subscribe' or '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?

The description provides explicit usage guidance: 'Use this to review what you're monitoring before adding more or to find an id to cancel.' This clarifies when to use the tool, though it doesn't explicitly state when not to use it.

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

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

Annotations declare readOnlyHint=false, which the description aligns with (sending feedback is a write operation). The description adds behavioral context: rate-limited to 5 per identifier per day, free, doesn't count against tool-call quota, and intake process (team reads digests daily, signal affects roadmap). It also specifies content guidance (don't paste end-user prompt). This goes beyond annotations.

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

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

The description is longer than average but every sentence earns its place: purpose, use cases, exclusions, guidance, operational notes, and rate limits. It is front-loaded with the main purpose and use cases. Slightly verbose in the middle section but overall well-organized and not redundant.

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 highly complete for a feedback tool with no output schema. It covers all operational aspects: what to report, when to use, exclusions, rate limits, quota impact, and examples of format. The nested context object (pack/tool/vertical) is explained in schema, and the description's guidance on framing feedback makes it contextually 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 parameters are fully documented in the schema. The description additionally provides semantic guidance on how to frame the message ('Describe the issue in terms of Pipeworx tools/packs — don't paste the end-user's prompt') and the meaning of the type enum categories, which 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 specifies the action (tell/send feedback) and the resource (Pipeworx team), and distinguishes it from siblings by emphasizing it's only for Pipeworx connection tools, not other MCP servers.

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: 'Use when a tool returns wrong/stale data (bug), when a tool you wish existed isn't in the catalog (feature/data_gap), or when something worked surprisingly well (praise).' It also gives exclusions ('ONLY for tools served by this Pipeworx connection... file it with that server instead') and suggests alternatives for non-Pipeworx tools.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint. Description adds non-obvious details: source (CF analytics), no PII, caching behavior (5min-1h), and output shape (pack, tool, count). No contradiction.

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

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

Three concise sentences plus bullet list, front-loaded with core purpose. Every sentence earns its place with no waste.

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 low complexity (1 param, no output schema), the description fully covers purpose, usage, behavior, and parameters. Nothing 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?

Schema coverage is 100% with enum. Description adds practical guidance on window selection (short vs long windows surface different signals) and notes default. Very helpful.

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?

Clear verb ('returns') and specific resource ('top tools, top packs, total call volume'). It distinguishes from siblings by focusing solely on trending data, 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 lists three use cases (e.g., discovering hot data sources, confirming canonical choices) and explains window choices. Could mention 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 declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. Description adds significant behavioral details: monotonicity checks, partition sum validation, fill check (realizable vs theoretical edge), Jaccard similarity for cross-event, placeholder filtering. 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?

Front-loaded with main purpose, but description is dense and includes detailed algorithmic explanations (Jaccard threshold, placeholders, fill check). While informative, slightly verbose for a tool description. Structured with clear sections per mode.

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 fully documents response format: opportunities[] with fields (gap_pp, suggested_trade, reasoning, monotonicity context) and partition_check for event mode. Covers edge cases (placeholder filtering, fill check, low similarity). Annotations provide safety context, making the description 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 covers both parameters with descriptions (100% coverage). Description adds richer semantics: explains event mode walks child markets and checks date-axis/threshold-axis ordering; topic mode searches related events and runs comparator on union. Goes beyond schema by explaining algorithmic behavior.

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

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

Clearly states tool finds arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. Distinguishes three modes (no args, event, topic) with specific use cases, differentiating from sibling tools like polymarket_edges or polymarket_fill_risk.

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

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

Explicitly tells when to use each argument: no args for trending scan, event for specific market, topic for cross-event scanning. Gives recommendations (event recommended for specific market) and explains why cross-event catches missed patterns. Does not directly compare to sibling tools but provides strong context for selection.

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

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

Annotations already declare readOnlyHint true, but the description adds extensive behavioral details: caching (1h KV keyed on knobs), edge calculation (after slippage, Kelly fractions, 24h-move warning), segment-specific logic (placeholder filter, longshot gates), and diagnostics for empty segments. 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 extremely verbose with dense technical details in a single paragraph. While front-loaded with purpose, it contains excessive detail (e.g., exact α values, statistical formulas) that could be omitted or structured better.

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 fully explains the response structure (by_segment, diagnostics, fed_candidates), caching behavior, and all model families. For a complex tool with 9 parameters and multiple segments, it is remarkably 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 schema already documents all 9 parameters with descriptions. The description adds no additional per-parameter meaning beyond summarizing the role of knobs generally. 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 states 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price.' The verb 'scan' and resource 'Polymarket markets' are specific. It distinguishes from siblings like polymarket_arbitrage by detailing three unique model families: MODEL_DRIVEN, STRUCTURAL_ARBITRAGE, CONCENTRATED_LONGSHOT.

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 built for 'what should I bet on today' and mentions 'agents discover opportunities without paging hundreds of markets.' It provides filter knobs (min_liquidity, max_spread_pp) and notes Fed bets are excluded. However, it does not explicitly compare to sibling tools like polymarket_edge_tracker or polymarket_fill_risk.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds critical context: data comes from daily snapshots with a 60-day TTL, decay is computed from daily closes not intraday, and gaps in snapshots are explained. This provides full transparency beyond annotations.

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

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

Description is detailed but well-structured, with response format clearly delineated into tracked, expired, and snapshot_dates sections. While not extremely concise, every sentence adds value. Could be slightly shorter but retains all necessary 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 lack of output schema, the description thoroughly explains the return format including fields, trends, decay calculations, and lifespan. It also covers limits (TTL, data start) and edge cases (snapshot gaps). No additional context needed.

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

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

Input schema has 100% coverage with descriptions. The description adds valuable default values and constraints (days: default 14, clamp 2-30; window: default '1wk', valid values listed) that are not fully expressed in the schema. This enhances semantic understanding.

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

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

Description clearly states the tool provides 'edge persistence and decay telemetry' and answers a specific question about edge duration and trend. It distinguishes itself from sibling polymarket_edges by focusing on historical persistence rather than current edges.

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

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

The description explicitly frames the tool around answering a particular question ('how long has this edge existed and is it shrinking?'), giving clear context for when to use it. It does not explicitly state when not to use it or name alternatives, but the purpose is sufficiently specific.

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

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

Annotations indicate readOnlyHint, openWorldHint, idempotentHint true, destructiveHint false. Description adds behavioral details: walks the ladder, returns verdict and risk info (forced_directional_risk), explains single-market vs basket behavior. No contradiction with annotations. The additional context about unhedged directional risk goes beyond what annotations provide.

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

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

Description is lengthy but well-structured with sections for requirements, single-market mode, basket mode, and usage guidance. Every sentence adds value; uses capitalization for emphasis. Slightly verbose but not wasteful, 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?

Given complexity (two modes, no output schema), description enumerates all return fields for both modes and provides usage context. Covers conditions, risks, and practical implications (e.g., partial basket fills). Fully complete for agent decision-making.

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 parameter descriptions. Description adds meaning beyond schema: explains size_usd as 'max spend on buys, target proceeds on sells', and clarifies side default for basket (auto from partition sum). Adds useful nuance without being redundant.

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 checks 'realizable-vs-theoretical edge against live CLOB order-book depth' and distinguishes two modes (single-market and basket), with specific verbs and resources. It differentiates from siblings like polymarket_arbitrage and polymarket_edges by stating when to use it before those 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?

Explicit guidance: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500'. Also explains why (theoretical overround not capturable, partial fills cause unhedged directional positions), providing clear when-to-use and when-not-to-use 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?

Describes safety fields, compatibility conditions, temporal alignment, and skipped cross-type/subtype counters. Annotations already indicate read-only, idempotent, non-destructive, and open-world; the description adds extensive behavioral detail 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?

Lengthy but well-structured with clear sections for modes, response, and safety. Every sentence adds value; minor verbosity in safety field explanations.

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 describes parameters, response structure, edge cases, and safety mechanics. No output schema exists, so description carries full burden.

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 value beyond schema: enumerates topic values, explains override behavior, and clarifies how modes affect behavior. Schema already covers parameters with descriptions.

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

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

The description clearly states it computes cross-venue spread between Kalshi and Polymarket, distinguishing it from sibling tools like polymarket_arbitrage which focus on a single venue.

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 describes two modes (topic shortcuts vs explicit tickers) and warns that pre-mapped topics often return compatibility warnings, guiding when not to use.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds valuable context: scoping to an identifier (anonymous IP, BYO key hash, or account ID) and the dual behavior (retrieve vs list). No contradictions.

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

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

Two concise sentences: the first gives action and dual behavior, the second provides usage context and pairing. No extraneous words, every sentence earns its place.

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

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

Given one optional parameter, no output schema, and good annotations, the description fully covers usage, scoping, and pairing. An agent has all information needed 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%, but the description adds semantic context beyond the schema: it clarifies that omitting the key argument lists all keys, and it explains the purpose of the key parameter (memory key to look up context). This adds value over the schema alone.

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

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

The description clearly states the verb 'Retrieve' and the resource 'value previously saved via remember' or 'list all saved keys'. It explicitly distinguishes from sibling tools remember and forget by mentioning them.

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

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

The description explains when to use (look up context stored earlier) and what not to do (omit key argument to list). It also provides explicit pairing guidance with remember and forget, giving clear alternatives.

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

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

The description discloses the effect of mark_read (flagging as read so next call shows only newer events) and the nature of returned data (source, citation_uri, raw payload). Annotations already mark readOnlyHint, openWorldHint, idempotentHint, and destructiveHint as true/false, and the description adds context beyond annotations—e.g., the feed persistence and alternative access.

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?

A single, dense paragraph with no wasted words. The primary action is stated first, followed by return details, filter options, a behavioral note, and finally an alternative access path. Every sentence earns its place.

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

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

Despite no output schema, the description explains the return format (source, citation_uri, raw event payload). Annotations cover safety and idempotency. The tool is a simple read operation with clear parameters, and the description provides all necessary context for an agent to use it correctly.

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

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

All 5 parameters have schema descriptions (100% coverage), but the description adds extra meaning: explains 'type' filters with an example ('sec_8k'), that 'since' is an ISO timestamp, that limit max is 200 with default 50, and clarifies that mark_read and unread_only are boolean flags. The description enriches the parameters 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 starts with a clear verb ('Pull') and specific resource ('fired events from your subscription feed'), and details the return fields (source, citation_uri, raw event payload). It distinguishes itself by explaining how it works with the subscription feed, which is unique among sibling tools like 'list_subscriptions' or 'la_recent'.

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

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

Provides explicit filter options (type, since) and a behavioral setting (mark_read). Mentions that polling works fine and even gives an alternative access method ('the same feed is also at GET registry.pipeworx.io/alerts.json'), but does not explicitly state when not to use this tool versus alternatives like 'la_recent' or search 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?

Description adds behavioral context beyond annotations: fans out to multiple sources, fallback from GDELT to GNews on rate limits, USPTO soft-fail. Annotations already declare readOnlyHint and idempotentHint, and description complements with operational details.

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

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

Description is a single dense paragraph but front-loaded with examples. Could be slightly more structured (e.g., bullet points for sources), but every sentence adds value 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?

Despite no output schema, description explains return format: 'structured changes[] grouped by source + total_changes count + pipeworx:// citation URIs.' Also references alternative tool entity_profile for static data, covering completeness.

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

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

Schema coverage is 100% with parameter descriptions. Description adds practical meaning: 'since' accepts ISO dates or relative shorthands ('7d', '30d'), 'value' can be ticker or CIK. Provides typical usage hints like 'Use 30d or 1m for typical monitoring.'

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

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

The description clearly states the tool provides a change feed for a company, with examples like 'What's new with X' and 'latest on Y'. It lists the data sources (SEC EDGAR, GDELT/GNews, USPTO) and differentiates from the sibling entity_profile tool, ensuring no ambiguity.

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

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

Explicitly states when to use this tool vs alternatives: 'Use entity_profile instead when you want the static profile.' Provides query examples and context for typical monitoring windows like '30d' or '1m'.

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 scoping and persistence duration details (24h for anonymous, persistent for authenticated) beyond annotations. Annotations already provide idempotentHint=true and destructiveHint=false; description aligns with these and adds context about lifetime and identity scoping.

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 well-structured sentences: core function, use cases, and technical details. No extraneous words, front-loaded with verb.

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 all necessary information: action, when to use, storage mechanism, persistence characteristics, and related tools. Given simple schema and no output schema, description is fully sufficient for agent decision and invocation.

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

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

Schema coverage is 100% with clear parameter descriptions and examples. The description adds no additional parameter-level details beyond what the schema already provides, so baseline 3 applies.

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

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

The description clearly states the tool saves data for later reuse, provides specific examples (ticker, address, preference), mentions key-value storage scoped by identifier, and references sibling tools (recall, forget) for differentiation.

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

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

Explicitly says 'Use when you discover something worth carrying forward' and provides example scenarios. It also pairs with recall/forget but does not explicitly exclude cases; sibling tools provide alternative guidance.

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

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

Annotations already indicate readOnly, openWorld, idempotent, non-destructive. Description adds that each call cascades through lookup endpoints internally, replacing 2-3 manual lookups. 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?

Front-loaded with example queries and purpose. Somewhat lengthy but well-structured with clear sections for each type. Could trim redundant phrasing but overall effective.

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

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

Despite no output schema, description fully explains return values for both types and internal cascading behavior. Complete enough for an agent to understand inputs, outputs, and behavior without 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 description adds rich context: for each type, what identifiers are returned (ticker, CIK, RxCUI) and accepted input formats. This compensates for lack of output schema.

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

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

Starts with example queries and clearly states tool resolves names to canonical IDs. Explicitly says 'Use FIRST whenever you have a name but need an ID', distinguishing it from siblings that may require IDs.

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

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

Provides clear when-to-use guidance ('Use FIRST whenever you have a name but need an ID') and gives examples. Does not explicitly list alternatives or when-not-to-use, but context is sufficient.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, establishing safety and idempotency. The description adds behavioral detail: probes each entity with ai_visibility_check, ranks by score, and surfaces most/least recognized. It also clarifies the use of _apiKey for Anthropic models. No contradictions.

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

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

The description is three sentences, front-loaded with the primary purpose, and every sentence adds value. No redundant or verbose language.

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 rich annotations and 100% parameter schema coverage, the description fully covers usage, behavior, and return format ('ranked list with score, confidence, signal density per entity'). No gaps remain for this moderate-complexity 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 meaningful descriptions. The description adds value by explaining that the first entity is treated as the subject for narrative purposes and that each entity is probed using ai_visibility_check, which aids understanding beyond the schema alone.

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

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

The description clearly states 'Compare AI visibility across multiple entities side-by-side,' specifying the verb (compare/scan) and resource (AI visibility). It distinguishes from sibling tools like ai_visibility_check (single entity) and compare_entities (generic comparison) by focusing on AI presence across competitors.

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 includes an example question and positions the tool for competitive AI-marketing audits. While it implies appropriate usage, it does not explicitly state when not to use (e.g., single entity analysis), but the sibling tool list provides that context.

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

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

Annotations already declare readOnly, idempotent, and non-destructive. The description adds significant context: it fans out across deps.dev and bundlephobia, notes that bundlephobia's first measurement can take 5-30 seconds, and explains that partial failures list sources_failed. This greatly exceeds annotation-only information.

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

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

The description is informative but somewhat verbose. It front-loads the composite nature and usage scenario, then lists return fields and behaviors. Could be tighter, but every sentence adds value. A solid 4.

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

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

Despite lacking an output schema, the description fully enumerates the return fields (is_latest, license, published_at, advisory_count, bundle_kb_min, etc.) and explains partial failure handling. It gives the agent a complete picture of what to expect.

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 for both parameters, so the description only adds minor value: it mentions scoped packages are accepted and that version defaults to latest. The schema already describes the parameters sufficiently, so the description adds marginal benefit.

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 as a composite check for npm packages, combining license, advisories, version history, bundle size, and tree-shake support. It distinguishes itself from siblings by being NPM-specific and aggregating multiple data sources in one call.

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: for questions like 'is X safe/popular/small' or 'what does adding lodash cost me'. It also notes the NPM-only scope and graceful degradation on partial failures, providing clear guidance on limitations.

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

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

Annotations already indicate safe read-only, open-world, idempotent behavior. The description adds technical details: embeddings (BGE-base-en), similarity method (cosine), chunking (500-char overlapping windows), and a clear cap (200K chars with truncation flag). It also notes that results include character offsets for verification.

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 (about 6 lines) and front-loaded with the key action. Every sentence adds value: examples, use case, pairing, technical details, and limitations. No redundancy.

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

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

Given the moderate complexity (3 parameters, no output schema), the description fully covers inputs, behavior, return format, and limitations (truncation). It answers what the tool does, when to use it, what the result looks like, and how it works internally.

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

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

Schema coverage is 100% with descriptions for all three parameters. The description enhances these by providing concrete examples (SEC 10-K, article, tool result) and explaining the return format (top-N passages with offsets and scores), which is not in 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 starts with "Semantic search INSIDE a fetched record," clearly stating the tool's function: searching within a given text. It distinguishes itself from siblings by mentioning its companion tool ask_pipeworx_grounded, showing a specific use case.

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

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

The description explicitly says "Use when the record is too big to cram into the prompt" and explains the benefit: saving context and returning only relevant passages. It also pairs with ask_pipeworx_grounded, providing guidance on when to use this tool versus alternatives.

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

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

Adds significant behavioral details beyond annotations: account requirement, delivery channel limitations (SMS cap, webhook auto-disable), webhook signing, and always-on feed. 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?

Long but necessary detail; front-loaded purpose, no fluff. Each sentence adds specific 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?

Explains return value and all delivery channels. Lacks mention of how subscriptions interact with listing/management tools, but still complete for creation 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 has 100% coverage, but description enriches with concrete examples per type, delivery channel constraints, and webhook signing details, adding value beyond schema.

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

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

Clearly states it creates a proactive monitoring subscription and returns an ID. Distinguishes from sibling tools like list_subscriptions 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?

Describes use case well but lacks explicit when-not-to-use or alternative tools. Does include requirement for Pipeworx OAuth account, which is helpful 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, open-world, and non-destructive behavior. The description adds context about the return value structure (category-bucketed examples drawn from a live catalog) and focus via topic parameter. However, it does not reveal any behavioral surprises beyond what annotations imply.

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

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

The description is front-loaded with common user intents and structured logically. It is somewhat lengthy but packs essential information for an onboarding tool. Could be slightly more concise but remains efficient.

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

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

Given the tool's simplicity (1 optional parameter, no output schema), the description provides a complete picture: purpose, return value format, parameter guidance, and usage context. It sufficiently covers all needed information for an AI agent.

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

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

Schema coverage is 100% with the `topic` parameter already described in detail. The description merely echoes the schema without adding new meaning. Baseline of 3 is appropriate as description adds no extra semantic 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 defines the tool as an onboarding entry point that returns category-bucketed example questions with exact tool+argument shapes. It lists multiple user intents and explicitly distinguishes it from sibling meta-tools by advising to use it first.

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

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

The description explicitly states when to use the tool: 'Use this FIRST when you do not yet know what Pipeworx can do for you, or to learn how to call the meta-tools'. It provides clear context and references alternatives like ask_pipeworx, entity_profile, compare_entities.

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 write (readOnlyHint=false) and non-destructive (destructiveHint=false). Description adds ownership enforcement and deactivation behavior, providing valuable 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 wasted words, front-loaded with core action and key constraints.

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

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

For a simple one-param tool with no output schema, description covers purpose, ownership, side effects, and relationship to another tool, fully satisfying the agent's needs.

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

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

Schema coverage is 100%, so baseline is 3. Description merely says 'by id' and does not add extra semantic detail beyond the schema's parameter description.

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

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

Description clearly states verb 'cancel' and resource 'subscription', distinguishes from siblings like subscribe and list_subscriptions by focusing on cancellation and ownership.

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 to cancel a subscription by id, mentions ownership enforcement, and hints at when to use recent_alerts for history. Lacks explicit comparison to other tools.

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

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

Annotations already convey read-only, open-world, and idempotent behavior. The description adds value by detailing the two verification pathways, the return format (verdict, actual value with citation, reasoning), and noting it replaces multiple sequential 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 detailed and front-loaded with trigger phrases. While slightly lengthy (4-5 sentences), every line serves a purpose—explaining trigger phrases, use cases, pipeline logic, and output. Minimal redundancy.

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

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

Given the tool's complexity (two separate pipelines), no output schema, and rich annotations, the description fully explains what the tool does, when to use it, how it handles different claim types, and what it returns. No gaps for an AI agent.

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

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

Schema coverage is 100% (both parameters have descriptions). The description adds context: 'claim' is natural-language, 'tolerance_pct' overrides implied tolerance with default capped at 5. This adds meaning beyond the schema's own descriptions.

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

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

The description clearly states the tool's purpose: natural-language claim verification against authoritative sources. It lists trigger phrases and distinguishes between financial claims (SEC EDGAR+XBRL) and other claims (grounded pipeline), differentiating it from sibling search/research tools.

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

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

Explicitly states 'Use whenever the agent needs to check whether something a user said is factually correct.' It also explains the two distinct pipelines, providing clear context for when to invoke the tool.

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