Faa Regulations

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 behavioral context: it returns a per-model result with score, confidence, signals, and raw_response plus a combined view, and explains that Anthropic calls require a BYO key with direct payment to Anthropic. This adds meaningful transparency beyond the annotations.

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

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

The description is a single focused paragraph covering purpose, default behavior, optional extensions, output format, and use cases. Every sentence is informative and necessary, with no wasted words.

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

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

Given the tool's complexity (4 parameters, 1 required, no output schema), the description adequately covers the return format (structured per-model data and combined view) and use cases. It lacks details on pagination or error handling, but for a probe tool this is sufficient. The absence of an output schema is partly mitigated by describing the output structure in the description.

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 each parameter has a description. The tool description adds further meaning: it explains the default model behavior for the 'models' parameter, clarifies that '_apiKey' is optional and passes through to Anthropic, and that 'context' helps disambiguate common names. This enriches the schema descriptions without redundancy.

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

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

The description clearly states the verb 'probe' and the resource 'LLMs for visibility', giving a specific purpose: scoring visibility (0-100) per model. It distinguishes from siblings by focusing on brand/product/topic awareness, explicitly mentioning use cases like AI-marketing audits and competitive monitoring, which is unique among the sibling tools.

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

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

The description provides explicit guidance on when to use this tool: for brand visibility checks, pre-launch audits, and competitive monitoring. It also details the default model and how to use an optional API key for Anthropic, but does not explicitly contrast with similar siblings like 'scan_competitor_ai_presence' or 'ask_pipeworx', so it lacks full differentiation.

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

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

Beyond the readOnlyHint and other annotations, the description discloses routing behavior, automatic argument filling, structured output with citation URIs, and performance characteristics ('one fast call'). It also notes it 'works on every tier' and handles live news, adding substantial context not present in the annotations.

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

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

Although lengthy, every sentence earns its place: it front-loads the key directive, lists covered domains, gives examples, and clearly explains when to escalate. The structure with 'START HERE' and 'Step up only when needed' makes it easy to parse despite the detail.

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

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

For a tool with a simple one-parameter schema but complex routing behavior, the description is remarkably complete. It explains return format (structured answer with citations), scope, examples, alternatives, and even notes limitations for breaking news, leaving no major 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?

The input schema already documents all aliases for the single 'question' parameter with 100% coverage, so the description adds little beyond examples. The statement that it accepts natural language is already in the schema. Thus the description provides no new semantic meaning for parameters.

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

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

The description clearly states the tool's function: it routes questions to one of 5,529 tools across 1,455 verified sources, fills arguments, and returns structured answers with stable citation URIs. It provides concrete examples and explicitly distinguishes itself from siblings like ask_pipeworx_grounded and deep_research.

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

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

The description gives explicit guidance on when to use this tool ('PREFER OVER WEB SEARCH', 'START HERE for most questions') and when to use alternatives ('for a hallucination-resistant single answer... use ask_pipeworx_grounded; for a broad/multi-part question... use deep_research'). It also covers breaking news and clarifies that even if web search could answer, this is the default.

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

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

Beyond the annotations (readOnlyHint, idempotentHint), the description discloses the beta status, live candidate routing enablement, current inactive state, and comparison against stable routing. It also clarifies there is no fallback, making the experimental nature fully transparent.

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 four sentences and contains highly relevant information, but slightly verbose with parenthetical counts and a specific date. It is well-front-loaded and structured logically.

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

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

It provides sufficient context about the beta relationship to ask_pipeworx, current equivalence, and usage intent. It mentions 'same response shape' to cover return format, though it does not detail response specifics, which is acceptable given the strong similarity to the stable 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?

The input schema has 100% coverage with all parameters being aliases for 'question'. The description adds no parameter-specific meaning beyond the redundant phrase 'same arguments', so it relies on the schema's already clear documentation.

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

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

The description clearly states it is a beta version of ask_pipeworx, an identical universal router with candidate routing improvements. This distinguishes it from the sibling ask_pipeworx by emphasizing the experimental edge and live candidate testing.

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

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

It explicitly instructs 'Use it exactly like ask_pipeworx when you want the newest routing' and mentions results are compared against the stable router. This provides a clear when-to-use scenario and implicitly contrasts with the stable alternative.

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

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

Beyond annotations (readOnlyHint, idempotentHint, openWorldHint), the description discloses refusal behavior with specific reason codes, the exact return shape, and the guarantee that extraction is limited to tool results. This adds meaningful context beyond the structured hints and contradicts none of them.

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

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

The description is dense and purposeful: mechanism, return contract, use cases, and tradeoff are all covered without redundancy. Each sentence earns its place, and critical details are front-loaded.

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

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

The description covers intent, routing mechanism, return value shape, refusal failure modes, and cost tradeoff, which is especially important given the lack of an output schema. It gives an agent everything needed to decide when to use this tool and what to expect as output.

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 all six parameters are documented as aliases for the natural-language question. The description adds no additional parameter semantics beyond what the schema already states, so the baseline 3 is appropriate.

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

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

The description clearly identifies the tool as a grounded/hallucination-resistant answer mode that routes to underlying tools and extracts answers only from fetched data. It distinguishes itself from sibling ask_pipeworx by the extraction guarantee and refusal behavior, satisfying the 'specific verb+resource' requirement.

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 ('whenever an answer will be quoted, cited, or acted on...') and when not to ('prefer ask_pipeworx for casual lookups'), naming the alternative tool. The one-extra-LLM-call cost tradeoff also provides clear decision support.

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

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

The description extensively covers behavioral aspects such as resolution handling, match confidence levels, parent event extraction, news fallback mechanisms, safety checks for low-confidence/closed markets, and resolution-rule risk. Annotations (readOnly, idempotent) are consistent and enhanced by this detail.

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?

While well-structured with section headers, the description is lengthy and dense, potentially overwhelming for quick scanning. It could be more concise while preserving key information.

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

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

Given the complexity of the tool (multiple classifiers, fan-outs, response shapes) and the absence of an output schema, the description thoroughly explains return values, special cases, and edge conditions, ensuring the agent can 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?

Schema coverage is 100% with adequate parameter descriptions. The description provides examples and context but does not significantly add new meaning beyond the schema. Baseline score of 3 is appropriate.

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

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

The description clearly states the tool 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies input types and output, and distinguishes itself from sibling tools by focusing on comprehensive bet research in a single 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?

The description explicitly recommends use cases ('Use for should I bet on X...') and provides examples of classifiers and fan-outs. However, it does not explicitly mention when not to use this tool or compare it to alternatives, leaving some room for misinterpretation.

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, open-world, idempotent, and non-destructive behavior. The description adds concrete details: for company it pulls latest 10-K financials with correct fiscal year handling; for drug it pulls FAERS and trial data. These details extend beyond annotation hints.

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

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

The description is front-loaded with example queries and usage guidance. While longer than average, every sentence adds value. Minor redundancy ('side-by-side comparison' vs. 'parallel call') but overall efficient.

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

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

Given the complexity (two entity types, multiple data sources, citations, sorting logic), the description is remarkably complete. It explains return format (paired data + citation URIs) even without an output schema. It addresses edge cases like off-calendar fiscal years.

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 substantial meaning: explains what each enum value does, specifies input formats (tickers/CIKs vs. drug names), enforces count range 2–5, and describes output sorting. This goes well beyond the minimal 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 uses specific verbs and phrases ('compare', 'rank', 'head to head') and clearly states it handles 2–5 companies or drugs in one parallel call. It distinguishes itself from sequential single-pack lookups mentioned as an alternative.

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

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

The description explicitly instructs to 'ALWAYS PREFER over sequential single-pack lookups when comparing entities,' providing clear when-to-use guidance. It does not explicitly state when not to use, but the preference is strong and context is clear.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false, but the description adds substantial behavioral context: account requirements and paid plan for 'thorough', parallel decomposition, return packet structure (verbatim evidence, gaps[], contradictions[]), guarantee that gaps are never invented, fetchable citations, semantic excerpting, and latency expectations. 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 long but densely packed with critical information, front-loaded with the account requirement and the most important alternative. Every sentence serves a purpose, though some redundancy (e.g., repeating 'this is NOT open-web search' and 'structured data') slightly adds length. It remains efficient for a tool of this complexity.

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

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

With no output schema, the description thoroughly explains what the tool returns: findings packet with verbatim evidence, confidence, source, fetched_at, citation_uri, hop field, gaps[], and contradictions[]. It also covers auth, latency, depth differences, and edge cases like breaking news leading to empty gaps. This is fully complete for an agent to invoke and understand results.

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

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

Schema description coverage is 100% for both parameters, so baseline is 3. The description adds meaning beyond schema: it explains that 'question' can be broad/multi-part, and expounds on depth values with second-hop iteration behavior ('standard' re-angles gaps, 'thorough' chases leads), and notes contradictions[] appears only for standard/thorough. This enriches the schema definitions, warranting a 4.

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

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

The description states a specific verb and resource: 'Grounded multi-source research across Pipeworx's 1455 STRUCTURED data sources ... in ONE call'. It explicitly contrasts with 'NOT open-web search' and distinguishes from siblings by noting it decomposes questions and routes to thousands of tools in parallel, making it clearly different from ask_pipeworx and other tools.

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

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

Explicit when-to-use guidance is provided: 'Best for broad/multi-part questions over structured data', with named alternatives ('For a single lookup use ask_pipeworx', prefer ask_pipeworx for breaking news). It also gives a condition for fallback: 'If you are not signed in, use ask_pipeworx instead'. This fully covers when/when-not with alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so safety is clear. The description adds valuable behavioral context: results include full schemas and are ready to call directly, which goes beyond annotations. No contradiction.

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

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

The description is concise, front-loaded with purpose, then usage, then benefit. Every sentence earns its place with no redundancy. Efficient and well-structured.

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

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

Given the tool's simplicity (no output schema, few required parameters), the description is complete. It explains the return format (top-N tools with schemas) and usage context. Slight improvement could be explicit pagination details, but overall sufficient.

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

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

Schema coverage is 100%, so the description doesn't need to re-document parameters. However, it adds semantic value by explaining the purpose of the 'query' parameter with examples and noting that aliases are accepted, going beyond the schema's minimal 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 finds tools by describing the data or task, listing numerous domains. It distinguishes itself from sibling tools by positioning itself as a meta-tool for discovery, with explicit instruction to call it first when many tools are available.

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

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

The description explicitly says when to use this tool ('Use when you need to browse, search, look up, or discover what tools exist for...') and advises calling it first. It lacks explicit when-not scenarios but the context is clear enough for the agent to infer.

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

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

The description goes beyond annotations by detailing the data sources (SEC EDGAR, XBRL, USPTO, news, GLEIF) and specific behavioral traits like 'patents via USPTO PatentsView API sunset May 2025 — soft-fails until reactivated'. 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 dense and informative, with examples and explicit guidance. It is slightly long but every sentence adds value. Could be more structured with bullet points, but still concise.

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

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

Without an output schema, the description sufficiently lists return fields: cik, company_name, recent_filings with URIs, fundamentals, patents, news, LEI. This compensates for the missing 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?

With 100% schema coverage, the description adds meaning by clarifying that type must be 'company', value must be ticker or zero-padded CIK, and names are not supported. This provides context beyond the schema's enum and description.

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

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

The description clearly states the tool provides a 'full cross-source profile of a US public company in ONE parallel call' with examples like 'tell me about X' and 'research Acme'. It specifies the data sources and returned fields, and distinguishes from sibling resolve_entity by noting that names are not supported.

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

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

The description advises 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups' for holistic views. It also explicitly states when not to use this tool: 'names not supported (use resolve_entity first if you only have a name)'.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds value by explaining input forgiveness, paragraph stripping, and that whole parts return section lists. The openWorldHint is not elaborated, but the behavior aligns.

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

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

The description is well-structured, starting with purpose, then examples, then coverage. It is slightly verbose but each sentence contributes. Could trim redundancy (e.g., repeating 'FAR' and '14 CFR' multiple times).

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

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

For a simple tool with one required param and no output schema, the description thoroughly covers input format, return value (full text), available parts, and edge cases (whole part vs section). Agent can confidently 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?

With 100% schema coverage and only one parameter, the description dramatically enriches the meaning with allowed formats, examples (91.113, FAR 107.29), and coverage of parts. The schema's brief description is fully supplemented.

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

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

The description uses a specific verb ('Get'), identifies the exact resource (Federal Aviation Regulation, 14 CFR), and provides clear examples and coverage scope. It distinguishes from sibling faa_search by narrowing to a single regulation retrieval vs searching.

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

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

The description gives clear context for use (e.g., 'answers what does FAR 91.113 say'), and implicitly steers away from faa_search for broader queries. However, it lacks explicit 'when not to use' language.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds useful context: the terminology difference ('unmanned aircraft' vs 'drone') and the 'Keyless' note, which go 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?

Every sentence adds value—purpose, typical queries, topic list, terminology note, and example invocations. Well-structured and front-loaded.

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

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

Given no output schema, the description appropriately states the return fields (citation, heading, excerpt, source URL). Covers all needed context for a simple two-parameter tool.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value with example queries and a terminology tip, improving clarity beyond the schema.

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

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

The description clearly states the verb 'search' and the resource 'Federal Aviation Regulations', distinguishing it from the sibling 'faa_regulation' tool (which likely retrieves by citation).

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

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

The description gives explicit use cases like 'what FAA regulations cover X' and lists example topics, guiding when to use. It does not explicitly state when not to use, but the guidance is clear.

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

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

Annotations already mark destructiveHint=true and idempotentHint=true. Description adds that deletion is for clearing sensitive data, which is consistent and provides additional behavioral context. No contradictions.

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

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

Two sentences: first states purpose, second provides usage guidance and sibling pairing. No filler, each sentence adds value. 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?

Tool is simple with one param, no output schema, and annotations present. Description covers purpose, when to use, and alternatives (siblings). All necessary information is provided concisely.

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 the single parameter 'key' with description 'Memory key to delete'. Tool description does not add additional parameter semantics beyond stating 'by key'. Baseline 3 is appropriate as schema carries the burden.

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 'Delete a previously stored memory by key', specifying the action (delete), resource (memory), and identifier (key). It distinguishes from siblings by mentioning 'pair with remember and recall', implying different operations.

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: 'context is stale, task done, or clear sensitive data'. It also advises pairing with 'remember and recall', providing context for tool selection. Lacks explicit when-not scenarios but is sufficiently clear.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. Description adds transparency by detailing the fetch-and-extract process and specifying the output format (standard llms.txt markdown). It does not contradict 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 two sentences plus a short list, all front-loaded with the core purpose. Every sentence adds distinct value without redundancy. Ideal length for a simple tool.

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

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

Given the tool's simplicity (2 parameters, no output schema, strong annotations), the description fully covers what it does, how it works, output format, and use cases. No gaps for effective agent usage.

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 both parameters thoroughly. The description restates max_links default/max values but adds no new semantic meaning beyond what the schema provides. Baseline score of 3 is appropriate.

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

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

Description clearly states the tool generates a production-ready llms.txt file for any URL to help AI crawlers index a site. It specifies the concrete actions (fetch page, extract title/description/key links, emit markdown). This distinct purpose differentiates it from sibling tools like scan_competitor_ai_presence.

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 lists three explicit use cases (client site indexing, own project drafting, competitor auditing), providing clear context for when to use. It does not state when not to use or mention alternatives, but the use cases are specific enough to guide appropriate invocation.

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

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

Discloses return format (id, type, params, created_at, last_fired_at, fire_count) and default behavior (active only). Annotations already indicate safe read, but description adds specifics.

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 purpose, no wasted words. Efficient and clear.

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?

Fully complete for a simple list tool with one optional parameter and no output schema. Covers purpose, usage, and return values.

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

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

Schema covers the single parameter with description. Description hints at its use ('cancel'), but doesn't add substantial 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?

Describes exactly what the tool does: 'List the caller's active subscriptions' with specific returned fields. Clearly distinguishes from siblings like subscribe/unsubscribe.

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

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

Explicitly states when to use: 'to review what you're monitoring before adding more or to find an id to cancel.' Provides clear context.

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

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

Annotations are all neutral false values, so the description carries the burden and excels: it discloses the asynchronous token round-trip ('Filing without an account returns a claim_token'), rate limiting ('5 per identifier per day'), cost ('Free; doesn't count against your tool-call quota'), and human review cadence ('team reads digests daily'). No contradiction with annotations exists.

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

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

A single dense paragraph that front-loads the core purpose and categories, then flows through exclusions, token mechanics, rate limits, and cost. Every sentence contributes operational value—no filler, no redundancy. The logical sequence makes it easy to scan despite its length.

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

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

With no output schema and a non-trivial feedback workflow, the description covers the full lifecycle: what to file, exclusions, how to claim and later retrieve resolution status, frequency of human review, rate limiting, and quota impact. It leaves no critical operational question unanswered, making it fully self-contained for an 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%, so the schema already defines each parameter thoroughly. The description adds value by demonstrating the claim_token usage with a concrete call example ('pipeworx_feedback({claim_token:"pwfb_…"})') and reinforcing that the message must reference Pipeworx tools/packs. It does not add much beyond the schema for `type` and `context`, hence 4 rather than 5.

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

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

The description opens with a specific action: 'Tell the Pipeworx team something is broken, missing, or needs to exist,' and immediately enumerates concrete categories (bug, feature/data_gap, praise). It clearly distinguishes this tool from siblings by scoping it exclusively to Pipeworx-served tools, even advising to file elsewhere for 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 explicitly states when to use the tool ('Use when a tool returns wrong/stale data...', 'when a tool you wish existed isn't in the catalog', 'praise') and when NOT to use it (other MCP servers → file with that server). It also provides guidance on message phrasing and the claim_token flow, making alternatives and exclusions unmistakable.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, destructiveHint false. Description adds valuable behavioral context: self-aggregating signal from CF analytics-engine, no PII, cached 5min-1h. No contradictions.

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

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

Two sentences with bullet-like enumerated use cases. Efficient and front-loaded. Could be slightly more structured but 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 tool with 1 optional param and no output schema, description fully covers purpose, return values, caching, data source, and use cases. No gaps.

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

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

Schema covers window param with enum and description (100% coverage). Description enhances by explaining shorter vs longer windows surface different demand patterns, adding semantic 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?

Description clearly states it returns top tools, top packs, and total call volume over a window. Specific verb 'returns' and resource 'trending data on Pipeworx'. Unambiguous and distinct from siblings like 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 (discovering hot data sources, confirming canonical tools, aligning use cases). Provides clear context for when to use but lacks explicit when-not-to-use or alternatives among siblings.

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

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

Annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint) indicate safe, read-only behavior. Description adds detailed behavioral context: scanning top ~200 markets, walk child markets, partition fill check with live CLOB depth, semantic anchors, and skipped pair reporting. No contradictions.

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

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

Description is somewhat lengthy but well-structured with clear sections for modes, semantic anchor, partition filter, fill check, and response format. No redundancy; each sentence adds value. Slightly dense but appropriate for the complexity.

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

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

No output schema, but description fully explains response structure (opportunities[], partition_check, fill check details). Covers inputs, edge cases (placeholder slugs, similarity threshold), and behavioral constraints. Complete for an arbitrage tool.

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

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

Schema coverage is 100% with descriptions. Description adds significant value: explains event slug format, topic meaning, examples, and behavior without args. Far exceeds schema alone.

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

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

The description clearly states it finds arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It distinguishes from sibling tools like polymarket_edges, polymarket_edge_tracker, and polymarket_fill_risk by specifying its unique functionality and modes.

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 when to use each mode: no args for trending scan, event for specific market, topic for cross-event scan. Provides recommendations (e.g., 'event is recommended for a specific market'). Does not explicitly contrast with sibling tools but gives clear context.

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

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

The description extensively details caching (1h), response structure (by_segment, diagnostics), and edge calculation (edge_pp_net after slippage, kelly_fraction). Annotations already cover read-only and idempotency, and the description adds rich behavioral context without contradiction.

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

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

The description is long but front-loaded with purpose and logically structured by segment. Every sentence provides value, though minor trimming could improve conciseness.

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

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

Despite no output schema, the description fully explains response structure, segments, diagnostics, caching, fed_candidates, and filter_skips. It addresses edge cases like Fed bets, making it highly 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% with parameter descriptions. The tool description adds value by explaining behavior for complex knobs like min_partition_leg_kelly, going beyond the schema. Baseline 3 is exceeded due to this extra context.

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

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

The description starts with a clear verb 'scan' and resource 'Polymarket markets', specifying the output as opportunities where data disagrees with market price. It distinguishes from siblings like polymarket_arbitrage and polymarket_edge_tracker by focusing on broader edge discovery.

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 phrase 'Built for what should I bet on today' explicitly states when to use, and the tradeable-edge knobs indicate when not to. However, it could explicitly mention sibling alternatives to further guide selection.

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

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

The description goes far beyond annotations (readOnlyHint, idempotentHint) by detailing output structure (tracked, expired, snapshot_dates), sign conventions (edge_pp_net signed), and limitations (60-day TTL, gaps from cache misses). 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 verbose and packs many details into a long paragraph. It front-loads the purpose but the output structure section could be more concise. Some redundancy exists (e.g., 'days' explanation repeated).

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 details the response format (tracked, expired, snapshot_dates) and explains edge behavior. It covers complexity, limits, and data sources, making it fairly complete for a telemetry tool.

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

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

Schema coverage is 100%, so the description adds minimal value beyond defaults and clamping. It mentions default values and constraints (max 30, clamp 2-30) but does not explain nuances beyond schema.

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

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

The description clearly states the tool's purpose: 'Edge persistence and decay telemetry built from daily polymarket_edges snapshots.' It answers a specific question ('how long has this edge existed and is it shrinking?') and distinguishes itself from sibling tools like polymarket_edges by focusing on time-series tracking rather than current state.

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

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

The description provides clear context for when to use this tool, explaining that a fresh wide edge differs from an old one. It does not explicitly list alternatives or conditions to avoid, but the context sufficiently helps an agent decide.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false. Description adds significant behavioral context: walks the order book ladder, returns fill quality metrics (top_of_book, VWAP, slippage, shares filled, verdict), and for baskets explains forced directional risk and thin legs. 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?

Description is two paragraphs but well-structured: first sentence gives core purpose, then modal breakdown, then usage advice. All sentences contribute necessary information. Could be slightly more concise but not excessive.

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 enumerates return fields for both modes (single-market: top_of_book, vwap, slippage, etc.; basket: theoretical_sum, realizable_sum, capture_ratio, profit, per-leg detail, thin_legs, etc.). Also covers edge cases like partial fills and directional risk. Complete for a risk-check tool.

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

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

Schema coverage is 100% so baseline is 3. Description adds value by explaining the parameters in modal context (single-market vs basket), clarifies size_usd interpretation for buys vs sells, and describes default behavior (side auto-detection for basket). Provides more nuance than schema alone.

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

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

Description clearly states it performs a realizable-vs-theoretical edge check against live CLOB order-book depth, covering both single-market and basket modes. It explicitly distinguishes from sibling tools like polymarket_arbitrage and polymarket_edges by advising when to use this 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?

Provides explicit when-to-use guidance: before acting on polymarket_arbitrage signals or polymarket_edges trades above ~$500. Explains why (theoretical overround may not be capturable, partial fills create directional risk), and warns against using for large trades without this check.

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

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

Annotations already provide readOnlyHint and idempotentHint. The description adds significant behavioral context: two modes, response structure (leg prices, spread array), safety fields (compatibility_warning, temporal_alignment), and specific conditions under which spreads are invalid (non-equivalent bet shapes, temporal misalignment). 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 lengthy but well-structured with sections for purpose, modes, response, and safety fields. Each sentence adds value, though some could be condensed (e.g., repetitive warnings about temporal alignment). Generally front-loaded with the core purpose.

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

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

Despite having no output schema, the description fully explains the return values (leg-by-leg prices, spread array, compatibility_warning, temporal_alignment, skipped counters). It covers all safety considerations and parameter interactions. Complete for a complex tool.

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

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

All three parameters are described in the schema (100% coverage). The description adds value by listing the 10 topic shortcuts, explaining override behavior for explicit tickers, and providing examples. It clarifies semantics beyond the schema, but the schema already provides sufficient 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 defines the tool as computing cross-venue spread between Kalshi and Polymarket for the same resolving question (verb+resource). It distinguishes from siblings like polymarket_arbitrage by specifying cross-venue focus and details two modes (topic and explicit), making purpose unambiguous.

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

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

The description provides explicit guidance on when to use the tool, detailing two modes and warning that most pre-mapped topics return compatibility warnings ('pre-mapped ≠ tradeable'). It implicitly advises against using when compatibility_warning fires, though it could benefit from direct comparison to siblings.

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

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

Descriptions add scoping and listing behavior beyond annotations. Annotations already cover readOnly and idempotent, so description adds value 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?

Four efficient sentences, front-loaded with action. Every sentence adds unique value, no redundancy or fluff.

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

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

Fully describes behavior for a simple key-value retrieval tool—listing, scoping, pairing—with no missing aspects given the 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 is 100% covered, but description adds real-world examples (ticker, address, notes) and clarifies omission behavior, enhancing parameter understanding.

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

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

Clearly states the tool retrieves a saved value or lists all keys. Distinguishes from siblings like remember and forget by explaining pairing.

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

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

Explicitly states when to use (look up stored context) and what it's scoped to. Could add more explicit alternatives or when-not-to-use, but the context is clear.

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

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

The description transparently explains the mark_read behavior: 'Set mark_read:true to flag returned events read so the next call only shows newer ones.' This adds context about state modification that is not captured by the annotations (readOnlyHint, openWorldHint, etc.). However, this disclosure contradicts the readOnlyHint annotation (which implies no state changes), so a contradiction flag is triggered.

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

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

The description is concise (four sentences) and front-loaded with the main purpose. Every sentence provides unique information (fields, filtering, mark_read, poll advice). Minor casual phrasing ('Polls work fine') could be tightened, but overall efficient.

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

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

Given the 100% schema coverage, no output schema, and read-only+idempotent annotations, the description adequately covers output semantics (source, citation_uri, raw payload), filtering parameters, and the mark_read/unread_only behavior. It also mentions an alternative HTTP endpoint. It could more explicitly describe default behavior for 'limit' (schema says 50), but that is minor.

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 covers 100% of parameters with descriptions, but the tool description adds meaningful usage context: for 'type' it gives an example ('sec_8k'), for 'since' clarifies format (ISO timestamp), and for 'mark_read' explains the side effect. This goes beyond the schema, though the schema already does a good job.

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

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

The description opens with 'Pull fired events from your subscription feed,' clearly stating the verb ('Pull') and the resource ('fired events from subscription feed'). It also specifies returned fields (source, citation_uri, raw payload) and filtering options, making the purpose distinct from sibling tools like 'list_subscriptions' which would list subscriptions rather than their events.

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

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

The description mentions that 'Polls work fine' and points to an HTTP endpoint for scripts/dashboards, implying lightweight polling use. However, it lacks explicit guidance on when not to use this tool (e.g., for complex queries or historical search) and does not compare it to siblings like 'search_within' or 'subscribe'.

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

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

Discloses fan-out to multiple sources (SEC, GDELT/GNews, USPTO), fallback behavior (GDELT preferred, GNews on rate limit/5xx), soft-fail for patents (PatentsView API sunset), and return structure (changes[] grouped, total_changes, citation URIs). Adds significant value beyond annotations.

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

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

Single paragraph but well-organized: purpose, internal logic, parameter hints, sibling distinction. Every sentence adds value, though slightly dense.

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

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

Given complexity (multiple sources, fallback, return format), the description covers key aspects including a temporary API issue. Mention of return structure compensates for missing output schema. No obvious 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 detailed descriptions. Description adds examples for 'since' (ISO date, relative shorthand, suggests '30d' or '1m') and mentions ticker or CIK for 'value'. Minor added value.

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

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

The description clearly states it is a change feed for a company within a time window, listing example queries and explicitly contrasting with entity_profile. The verb 'change feed' and resource 'company' are specific and distinguishable.

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

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

Provides explicit guidance: 'Use entity_profile instead when you want the static profile... regardless of window.' Also suggests typical monitoring duration '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?

Description discloses behavioral traits beyond annotations: persistence based on authentication, 24-hour retention for anonymous sessions, and key-value scoping. Annotations already indicate idempotent and non-destructive, which the description does not contradict.

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?

Five sentences covering purpose, usage, scope, persistence, and pairing. Front-loaded with the primary action. Could be slightly more concise but no superfluous information.

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

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

Given the tool's simplicity (2 parameters, no output schema), the description provides sufficient context for selection and correct invocation. It explains data scope, persistence, and relationships with sibling tools.

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

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

Both 'key' and 'value' parameters are described in the schema with examples. The description adds contextual examples (e.g., 'resolved ticker, target address') and emphasizes that value is 'any text,' enriching understanding 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 the tool's purpose: 'Save data the agent will need to reuse later.' It distinguishes from sibling tools like 'recall' and 'forget' by specifying it is for storing data, and gives concrete examples of use cases.

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

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

Explicitly says when to use: 'when you discover something worth carrying forward.' It also contrasts with siblings by mentioning 'Pair with recall to retrieve later, forget to delete.' However, it does not explicitly state when not to use the tool.

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

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

Beyond the annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint), the description richly discloses behavior: every identifier is source-labeled, unresolved identifiers are explicitly listed under `unresolved` rather than omitted, and LEI/FIGI enrichment degrades gracefully if GLEIF/OpenFIGI are unavailable. This goes well beyond the structured metadata and gives the agent a clear mental model of the tool's 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 dense but front-loaded with example queries and a clear purpose. The structure breaks down supported types with parenthetical details, and the graceful-degradation note is relevant. It is longer than strictly necessary due to repeated example phrasing, but each sentence carries information; it remains readable and efficient for a tool with this complexity.

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

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

Given the tool's complexity (multiple upstream sources, ownership data, graceful degradation) and the absence of an output schema, the description is exceptionally complete. It explains what identifiers are returned for each type, how unresolved items are handled, and what happens on partial failure. There is no significant missing context that would impede correct use; annotations cover safety, and the description fills all other 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?

Although the schema already covers parameters with 100% accuracy, the description adds valuable meaning: for 'company', it explains the cross-source identity spine (CIK, ticker, LEI, FIGI) and the meaning of 'unresolved'; for 'drug', it lists RxCUI and ingredient/brand. This extra context is not present in the schema and helps the agent understand expected output semantics, slightly above the baseline for full schema coverage.

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

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

The description clearly states the tool's function: 'resolve a user-spoken NAME to the canonical/official identifiers other tools require as input.' It gives concrete example queries and distinguishes itself from siblings by emphasizing 'Use FIRST whenever you have a name but need an ID.' The supported types (company, drug) and their specific identifier outputs are enumerated, making the purpose unmistakable.

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

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

The description explicitly provides usage guidance: 'Use FIRST whenever you have a name but need an ID.' It also details when to use each type (company vs drug) and what inputs are accepted. The note 'using resolve_entity replaces 2-3 manual lookups' reinforces its role as a primary lookup tool, effectively guiding selection among sibling tools.

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

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

Annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false) set baseline safety. Description adds probes each entity with ai_visibility_check, ranks results, returns score, confidence, signal density. 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?

Four sentences, front-loaded with verb and resource. No redundancy, each sentence adds value: purpose, mechanism, example, return fields.

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 (ranked list with score/confidence/signal density). Given complexity (4 params, comparison logic) and annotations covering safety/idempotency, description is complete for agent decision-making. Could mention error handling but not essential.

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

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

Schema coverage is 100%, baseline 3. Description adds that first entity is 'subject' for narrative, models default to workers-ai, and context disambiguates names. This exceeds schema detail, providing actionable usage guidance.

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

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

The description clearly states the tool compares AI visibility across multiple entities side-by-side, using ai_visibility_check probes, ranking, and surfacing most/least recognized. It distinguishes from sibling 'ai_visibility_check' (single entity) and 'compare_entities' (different comparison) by specifying the competitive audit use case.

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

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

The description provides a clear use case: competitive AI-marketing audits. It implies when to use vs ai_visibility_check (comparison vs single) but does not explicitly state exclusions or alternative tools. Sibling list includes ai_visibility_check for inference.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false. The description adds substantial context: the composite fan-out to two services, graceful degradation with partial failures (bundlephobia timeout), and the exact fields returned. 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 detailed but well-structured and front-loaded with the composite purpose. Every sentence adds value (usage, returns, limitations, alternatives). Slightly long but justified by the tool's complexity.

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

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

Despite no output schema, the description completely documents the return block fields, per-advisory detail, links, alternative versions, and failure behavior. It covers inputs, outputs, usage context, and ecosystem limitations, making it self-sufficient.

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

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

Schema coverage is 100%, so the description is not required to detail parameters further, but it adds extra useful context: scoped packages are accepted for 'package', and 'version' defaults to latest published. This enhances understanding beyond the schema.

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

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

The description clearly states the tool performs a composite check on an npm package using deps.dev and bundlephobia, with the specific goal of answering 'should I add this npm package to my project'. It distinguishes itself from sibling tools (none of which do dependency scanning) by its unique function.

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

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

Explicitly instructs when to use: when an agent asks about safety, popularity, size, or cost of adding a package. Also provides alternatives for non-NPM ecosystems (PyPI, Maven, etc.) by directing to deps.dev directly, and notes partial failure behavior.

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

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

The description adds significant behavioral context beyond annotations: it specifies the embedding model (BGE-base-en), similarity metric (cosine), window size (500-char overlapping), character limit (200K with truncation flag), and that results include offsets. Annotations already declare readOnly, openWorld, idempotent hints, and no contradiction.

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

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

The description is approximately 150 words, front-loads the purpose, and every sentence contributes meaningful information without redundancy. The technical details are presented clearly and efficiently.

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 explains the return format (passages with character offsets and similarity scores) and the internal mechanism, making the tool's behavior predictable. It addresses the parameter count (3) and common use cases adequately.

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

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

Schema coverage is 100%, so the schema already documents all parameters. The description enhances understanding with examples for 'query' and clarifies the size constraint for 'text' and the 'top-N' nature of 'limit'. It slightly exceeds the baseline by adding practical context.

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

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

The description explicitly states it performs semantic search inside a fetched record, uses specific verbs like 'Search Inside', and distinguishes itself from sibling tools by mentioning its pairing with `ask_pipeworx_grounded` and returning passages with offsets.

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

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

Provides explicit guidance on when to use ('when the record is too big to cram into the prompt') and mentions an alternative workflow ('Pairs with ask_pipeworx_grounded: fetch with the gateway, ground over the relevant passages').

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 idempotentHint=true and openWorldHint=true. The description adds behavioral details like phone verification, 10/day SMS cap, and webhook auto-disable, which go beyond annotations. It does not explicitly confirm idempotency but does not contradict.

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

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

The description is long but well-structured, with the main purpose front-loaded. All sentences add necessary information, though slightly verbose.

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

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

Given that there is no output schema, the description explains the return value (subscription id) and covers all important aspects: supported types, requirements, delivery, limitations. It is sufficiently complete for an agent to use.

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

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

Schema coverage is 100% and the description adds extensive examples for each subscription type's params and explains delivery options in detail. This adds significant 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 'Create a proactive monitoring subscription to a live-data event stream' and specifies it returns the subscription id. This distinguishes it from sibling tools like unsubscribe and list_subscriptions.

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

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

The description explains that a Pipeworx OAuth account is required and lists supported subscription types and delivery channels. It provides context for when to use but does not explicitly state when not to use or mention alternatives.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive. The description adds behavioral detail: it uses a live catalog of thousands of tools, returns categorized questions with exact tool shapes and argument structures, and highlights the difference between no-argument and topic-filtered calls. No contradictions.

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

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

The description is a single, well-structured paragraph that front-loads common user queries and clearly conveys purpose, output, and usage. It is dense but not verbose; minor improvement could be breaking into sections, but it is acceptably concise for its content.

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

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

Given the tool's simplicity (one optional param, no output schema), the description is thorough. It explains the return value (categorized example questions with tool shapes), usage scenarios, and how the tool integrates into onboarding. No gaps remain for an agent to invoke 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?

Schema coverage is 100% with a single optional parameter described. The description adds value by providing example topic values ('finance, pharma, betting') and explicitly stating the behavior difference when the parameter is omitted versus provided. This enhances usability 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 that the tool is the onboarding entry point for understanding what Pipeworx can do. It provides a specific verb+resource (returns category-bucketed example questions) and distinguishes itself from sibling tools like 'discover_tools' and 'ask_pipeworx' by focusing on example generation for new users.

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: '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 also explains when to use with/without the topic parameter, providing clear context and 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?

Beyond annotations (idempotent, non-destructive), the description adds key behavioral traits: ownership check, soft delete behavior, and that historical events remain accessible via 'recent_alerts', fully disclosing side effects.

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

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

Two concise sentences: first states purpose, second adds constraints and behavioral details. No redundant or unnecessary words.

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

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

Given the simple tool (1 param, no output schema), the description fully covers purpose, ownership, effect on data, and linkage to sibling tools like 'recent_alerts', making it complete for agent invocation.

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

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

The schema covers the single parameter fully (100% coverage). The description refers to 'by id' and the schema's description is clear, so the description adds no extra semantic 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 'Cancel a subscription by id,' using a specific verb and resource. It distinguishes itself from siblings like 'subscribe' and 'list_subscriptions' by explicitly mentioning the cancellation action.

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

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

It explicitly states ownership enforcement ('you can only cancel your own subscriptions') and clarifies that the row is deactivated, not deleted, telling the agent when and how to use it vs. alternatives.

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

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

Annotations declare readOnly/openWorld/idempotent, but description adds critical behavior: company financials use structured XBRL fast path with percent-delta math; other claims fall through to grounded pipeline; and the crucial warning that could_not_verify does not count as evidence, carrying verification_error. This goes well beyond annotation hints.

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

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

Description is long but every sentence carries distinct information: examples, use case, routing logic, return format, caller warnings. Structured with clear sections; 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?

With no output schema, description fully specifies return values (verdict enum, actual value, citation, reasoning) and distinguishes error vs unsupported. It also covers the two-pipeline logic and replaces multi-step calls, making the tool's behavior predictable.

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

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

Schema already has 100% coverage with decent descriptions, but the description adds practical nuance: tolerance_pct default is implied by wording capped at 5, and recommends 1-2 for hallucination detection. It also provides concrete claim examples, improving 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 identifies the tool as natural-language claim verification against authoritative sources, with multiple example phrasings ('fact check', 'verify the claim that…'). It distinguishes from siblings by specifying two distinct pipelines (SEC EDGAR for financials, grounded for all else), making scope 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?

Explicitly states 'Use whenever the agent needs to check whether something a user said is factually correct.' Also explains it replaces 4–6 sequential calls, indicating when to prefer it. However, it does not explicitly mention when-not-to-use alternatives, so it stops short of a full exclusion list.

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