Acled

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

Annotations indicate readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false. The description adds that the tool calls LLMs (potentially paid Anthropic) and returns per-model scores with raw response. It also notes the default free model. 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 concise and well-structured. It opens with the primary purpose, then details parameters and use cases. Every sentence is informative and earns its place.

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

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

For a tool with 4 parameters and no output schema, the description adequately covers purpose, parameters, return structure (per-model fields), and use cases. Completeness is high, though it could optionally mention rate limits or response size.

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%. Description adds value by explaining the _apiKey parameter (BYO key, you pay Anthropic directly), the default model (Workers AI Llama-3.3-70b free), and the context parameter for disambiguation. This goes beyond basic schema descriptions.

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

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

The description clearly states the tool probes LLMs for knowledge about an entity and returns a visibility score (0-100). It is distinct from sibling tools like ask_pipeworx (general Q&A) and deep_research (in-depth research) by focusing specifically on AI visibility scoring.

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

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

The description specifies the tool is useful for AI-marketing audits, pre-launch brand checks, and competitive monitoring. It explains the default model and optional Anthropic probe with BYO key. No explicit when-not-to-use guidance, 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?

Annotations already mark it as read-only and non-destructive. The description adds behavioral context beyond annotations: it routes internally, fills arguments, returns structured answers with stable pipeworx:// citation URIs, and claims to work on every tier with one fast call. This enriches the agent's understanding without contradicting 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?

Though relatively long, every sentence contributes unique information: purpose, routing behavior, example queries, guidance to prefer this tool, and when to switch to siblings. The structure is front-loaded with 'PREFER OVER WEB SEARCH' and 'START HERE', making it easy to scan. No redundant phrases.

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 breadth and lack of an output schema, the description explains the return format (structured answer with citation URIs), the scope (current/historical data), and the limitations (step up when needed). It thoroughly answers 'what does this do' and 'when should I use it' with concrete examples.

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% (all parameters documented), so the baseline is 3. The description adds value by giving example questions and specifying the type of content expected, but it doesn't delve into parameter-level details beyond what the schema already provides. Thus a 4 is warranted.

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: routes questions to 5,529 tools across 1,455 verified sources, fills arguments, and returns structured answers with citation URIs. It distinguishes itself from siblings by explicitly referencing ask_pipeworx_grounded and deep_research for alternative 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?

Provides explicit guidance on when to use: 'PREFER OVER WEB SEARCH', 'START HERE for most questions', and gives concrete examples. It also tells when step up is needed: 'for hallucination-resistant single answer use ask_pipeworx_grounded; for broad/multi-part question use deep_research'.

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

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

The description goes beyond annotations by disclosing live candidate routing improvements, the retirement of the last candidate, and the current equivalence to ask_pipeworx. It also clarifies that it is a full working router that 'falls back to nothing' and that results are compared against the stable router, giving valuable behavioral insight for a beta tool.

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 well-structured sentences, each serving a distinct purpose: definition, current state, usage instruction, and clarification. It is front-loaded with the key identification and contains no redundant 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?

For a router tool with no output schema, the description sufficiently explains what it does, how to use it, and its relationship to ask_pipeworx. It notes the same response shape as the stable tool, providing a reference point, and clearly conveys the experimental status and current operational state.

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 fully documents all 6 parameters (all aliases for 'question') with 100% coverage, so the description's lack of parameter detail is acceptable. The description adds no additional semantic meaning beyond the schema, meriting the baseline score.

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' and an 'identical universal router' with the same 5,529 tools and arguments. It distinguishes itself from the stable sibling by being the 'experimental edge' with candidate routing improvements, making its 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?

It explicitly instructs to 'Use it exactly like ask_pipeworx when you want the newest routing' and notes that results are compared against the stable router, providing clear when-to-use guidance and referencing the alternative. It also explains the current state (no active candidate) which directly affects usage decisions.

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 the annotations by detailing the internal routing mechanism (picks tools from 5,529 across 1455 sources), the strict extraction policy (uses ONLY what the tool result contains), the exact return shape on success and failure, and the explicit refusal reasons. This is rich behavioral context that helps the agent predict tool behavior. The annotations (readOnly, openWorld, idempotent, not destructive) align perfectly with the described behavior, with 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 well-structured and efficient. It front-loads the core purpose and differentiator, then explains the mechanism, output format, use cases, and cost trade-off in a logical flow. Every sentence carries actionable information, and the length is appropriate for the tool's complexity — not overly verbose, but complete.

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?

This is a complex tool with no output schema, but the description compensates by fully specifying the return contract: {answer, evidence, confidence, source, fetched_at, refusal_reason:null} on success, and the explicit refusal object with all possible refusal_reason values. It also covers routing scale, cost, and usage guidance. The description is sufficiently complete for an agent to select and invoke this tool correctly without additional docs.

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

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

The input schema is fully self-documenting: all six parameters are aliases for the same 'question' field, each with a description (e.g., 'Alias for question'). Schema description coverage is 100%, so the parameter semantics are already complete. The tool description does not add parameter-specific details, but the behavioral context about how the question is routed and processed adds ambient value. The baseline of 3 is appropriate when schema covers all 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 opens with a specific and informative phrase: 'Hallucination-resistant answer mode for high-stakes reads.' It clearly distinguishes itself from the sibling tool ask_pipeworx by emphasizing the grounded extraction and refusal mechanism, and explicitly describes the tool's core action: extracting answers only from tool results. This provides a concrete verb+resource definition with clear differentiation from siblings.

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

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

The description provides explicit usage guidance: 'Use whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts.' It also names the alternative tool and gives a comparative trade-off: 'Costs one extra LLM call vs ask_pipeworx — prefer ask_pipeworx for casual lookups.' This is a textbook example of when-to-use and when-not-to-use guidance.

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

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

The description extensively explains behavior beyond annotations: it describes resolution, classification, fan-out, response shapes, resolver contract with confidence levels, parent event extraction, news fallback, safety mechanisms for low-confidence/closed markets, wide spreads, and cancellation rule risk. This provides a comprehensive view of what the tool does and its edge cases.

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

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

The description is quite lengthy with multiple paragraphs and detailed sections. While well-structured (sections like RESOLVER CONTRACT, PARENT_EVENT EXTRACTOR), it could be more concise for an AI agent to parse quickly. It front-loads the core purpose but includes a lot of detail.

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

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

Given the tool's complexity (multiple features, safety checks, output details), the description is very complete. It covers response shapes, resolver contracts, parent event extraction, news fallback, various safety mechanisms, and cancellation rule risk. There is no output schema, so the description compensates by explaining the response structure thoroughly.

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

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

Schema description coverage is 100%, and the description adds significant context: it explains that 'market' can be slug, URL, or question text; 'depth' enum values and defaults; 'include_raw' default and when to use true. This goes well beyond the schema descriptions.

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

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

The description starts with a clear verb+resource: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies the input types (slug, URL, question text) and distinguishes from sibling tools by focusing on a single bet research call, contrasting with polymarket_edges or polymarket_arbitrage.

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

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

Explicit use cases are given: 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z".' This clearly indicates when to use the tool. However, it does not explicitly state when not to use it or mention alternative tools for simpler queries, so it misses a small bit of completeness.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds behavioral specifics: it pulls SEC EDGAR/XBRL data for companies, handles off-calendar fiscal years, and sorts results by primary metric. 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 front-loaded with the core purpose and usage cues. Each sentence adds value, though it is slightly verbose with multiple examples. It efficiently conveys all necessary information without extraneous text.

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

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

Given the simplicity of the tool (2 parameters, no output schema), the description covers the purpose, parameter usage, return format (paired data + citation URIs), and behavioral notes. It is complete enough for an agent to select and invoke correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning beyond the schema by explaining how 'values' should be formatted per entity type (tickers/CIKs vs drug names) and that results are sorted by primary metric, which helps the agent understand parameter usage and output behavior.

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

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

The description uses specific verbs ('compare', 'side-by-side comparison'), identifies the resources ('companies or drugs'), and provides natural language triggers ('X vs Y'). It clearly distinguishes from sequential lookups by stating it replaces 8–15 sequential calls.

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

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

The description explicitly states 'ALWAYS PREFER over sequential single-pack lookups when comparing entities,' providing a clear directive on when to use. It also gives example queries and specifies the tool handles 2–5 entities, effectively guiding the agent.

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

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

Beyond the annotations (readOnly, openWorld, idempotent), the description discloses critical traits: account/paid requirements, expected latency ('15-60s'/'up to ~90s'), gap handling ('gaps[]' and 'never invented'), citation fetchability ('citation_uri... present only when the source emits one'), contradiction scanning, semantic excerpting, and the hop field. It thoroughly explains what the tool returns and when gaps appear.

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

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

The description is long but densely packed with essential information, and the most critical call-to-action (account requirement and fallback) is front-loaded. Each sentence contributes operational or behavioral value, though a few phrases ('this is NOT open-web search') could be tightened without loss. Overall it earns its length for such a complex 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?

With no output schema, the description fully explains the return value: findings packet, evidence, confidence, source, fetched_at, citations with uris, gaps[], contradictions[], and hop field. It also covers edge cases (unresolvable citations, semantic excerpting), timing, and depth options. For a tool of this complexity, the description is remarkably complete.

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

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

Although schema coverage is 100%, the description adds significant semantics to the 'depth' parameter by explaining the numeric facet counts, hop behavior, gap recovery, contradictions scan, and paid tier. It also clarifies that 'question' can be broad/multi-part, which is not obvious from the schema. This goes well beyond the structured definitions.

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

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

The description clearly identifies the tool's function: 'Grounded multi-source research across Pipeworx's 1455 STRUCTURED data sources... in ONE call.' It distinguishes itself from siblings by explicitly stating it is 'NOT open-web search' and by contrasting with ask_pipeworx for single lookups and current news.

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

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

The description provides explicit when-to-use and when-not-to-use guidance. It states 'For a single lookup use ask_pipeworx' and 'For BREAKING or colloquial CURRENT-NEWS... prefer ask_pipeworx.' It also notes 'If you are not signed in, use ask_pipeworx instead,' and states it is 'Best for broad/multi-part questions over structured data.' These are clear alternatives and exclusions.

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

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

Annotations already indicate read-only, idempotent, non-destructive. The description adds value by detailing the output format (names, descriptions, full schemas with examples) and that results are 'ready to call directly'. 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 concise (5 sentences) and well-structured: purpose first, then usage guidance, then output details. No redundancy or filler; each sentence adds new 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 simple parameter set and full schema coverage, the description sufficiently explains what the tool does and returns. It covers purpose, usage, and output. Could elaborate on the 'limit' parameter's role, but schema handles it.

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

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

Schema coverage is 100% (all 6 parameters documented). The description provides examples of query usage and notes aliases (task, q, search, description), adding practical meaning beyond the schema's property descriptions.

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

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

The description clearly states 'Find tools by describing the data or task' and provides specific examples (SEC filings, drugs, economic data). The name and title directly convey the purpose, distinguishing it from sibling tools.

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

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

The description explicitly says 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' While it doesn't state when not to use it, the guidance is clear and helpful.

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

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

Annotations declare readOnly=true, idempotent=true, etc. Description adds context: mentions USPTO API sunset and soft-fail behavior, lists exact return fields, and explains the fan-out process. 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?

A single dense paragraph; front-loaded with example queries, but could be broken into sections for readability. However, every sentence earns its place with useful 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?

For a tool with no output schema, the description thoroughly explains return values (CIK, filings, fundamentals, patents, news, LEI), internal URIs, fallback behavior, and limitations. It is fully self-contained.

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

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

Schema coverage is 100%, but description adds meaning by specifying supported types (only 'company'), value format (ticker or zero-padded CIK), and the limitation that names are not supported. This goes beyond the raw schema.

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

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

The description uses specific verbs like 'brief me on' and 'full cross-source profile', clearly stating it aggregates data from multiple sources for US public companies. It distinguishes itself from siblings like resolve_entity by noting when to use which.

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 'ALWAYS PREFER over chaining single-pack lookups' and warns that names are not supported, directing to resolve_entity. Provides clear when-to-use and when-not-to-use guidance.

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

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

Annotations already provide readOnlyHint, idempotentHint, and non-destructive hints. The description adds context that the tool groups data by country and operates over a date range, which enhances behavioral understanding beyond annotations. 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 two short sentences: the first states the core function, the second provides usage context. No fluff, every sentence earns its place.

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

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

For a simple aggregation tool with an output schema, the description provides the essential purpose and use case. It could be more explicit about the grouping by country and default scope, but overall is adequate given the annotations and schema coverage.

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

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

Schema description coverage is 100%, so baseline is 3. The tool description does not add additional parameter-level meaning beyond what the schema already provides. No extra semantics needed.

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 aggregates event and fatality counts by country over a date range, which is a specific verb+resource. It also explains its utility for cross-country comparison and time-bounded risk snapshots, distinguishing it from siblings like search_events or compare_entities.

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

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

The description implies usage for cross-country comparison and time-bounded risk snapshots, but does not explicitly state when not to use this tool or mention alternatives among siblings. No direct exclusion or comparative guidance is provided.

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

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

Annotations already provide destructiveHint=true and idempotentHint=true. Description adds minimal extra behavioral context beyond 'delete' and 'by key'. Missing details on behavior when key not found or if deletion is reversible.

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

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

Two concise sentences, front-loaded with action and immediately followed by usage guidance. 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 tool simplicity and high parameter coverage, most context is covered. Lacks explanation of return value or confirmation, but annotations compensate for destructive nature.

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

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

Schema coverage is 100% with clear parameter description 'Memory key to delete'. The description adds no additional semantic value beyond the schema; baseline 3 is appropriate.

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

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

Description clearly states 'Delete a previously stored memory by key' with a specific verb and resource. It distinguishes itself from sibling tools 'remember' and 'recall' by being the delete counterpart.

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

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

Explicitly states when to use: 'Use when context is stale, the task is done, or you want to clear sensitive data the agent saved earlier.' Does not provide explicit when-not-to-use but pairs with siblings for 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 strongly signal safe, read-only, idempotent behavior. The description adds valuable behavioral detail: fetches the page, extracts title/description/links, and returns standard llms.txt markdown. It does not discuss potential error conditions (e.g., invalid URL), which is a minor gap.

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 five concise, front-loaded sentences. It starts with the core action, explains the process, describes the output, and lists use cases—all without extraneous words. Every sentence earns its place.

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

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

Given the tool's simplicity (2 parameters, no output schema) and rich annotations, the description covers the main functionality and use cases. Missing details about error handling (e.g., what happens if the URL is unreachable) would improve completeness.

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

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

Schema description coverage is 100%, and the description does not add new meaning beyond what the schema already provides. For example, the max_links parameter default and max are already in the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool generates a production-ready llms.txt file for any URL, specifying the exact process (fetch page, extract title/description/links, emit markdown format). It also lists concrete use cases (client indexing, own project, competitor audit), making the purpose unambiguous.

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

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

The description provides clear usage context: 'getting a client's site indexed by AI, drafting llms.txt for your own project, or auditing how an AI crawler would see a competitor.' However, it does not explicitly exclude scenarios where alternatives like ai_visibility_check or scan_competitor_ai_presence might be more appropriate.

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?

Consistent with annotations (readOnlyHint, idempotentHint, destructiveHint=false). Adds context that it returns only the caller's subscriptions and specific fields, which annotations don't cover. No contradictions.

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

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

Two concise sentences. First states core function, second provides usage guidance. No wasted words, front-loaded with key information.

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

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

Adequate for a simple list tool with one optional parameter. Describes return fields (compensating for missing output schema). Could mention whether items are paginated or any limits, but not critical.

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 fully describes the single parameter (include_inactive) with 100% coverage. Description does not add any additional parameter semantics beyond what the schema provides.

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

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

Clearly states it lists the caller's active subscriptions and enumerates returned fields (id, type, params, etc.). Distinguishes from siblings like subscribe and unsubscribe.

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

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

Explicitly tells when to use: 'review what you're monitoring before adding more or to find an id to cancel.' Could be improved by also mentioning when not to use or comparing with similar tools like search_within.

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

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

Annotations are all false, so the description carries the full burden. It discloses the rate limit (5 per day), that it's free, does not count against tool-call quota, returns a claim_token when no account is used, and that the team reads digests daily. It also clarifies that only feedback about Pipeworx-provided tools is actionable. This exceeds what annotations convey and manages expectations effectively.

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

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

The description is long but information-dense. Every sentence serves a purpose: purpose, use cases, exclusions, formatting, token flow, rate limits, and cost. It could be tightened, but it is structured logically and front-loaded with the primary purpose. The slight verbosity is justified by the amount of necessary guidance.

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

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

With 4 parameters, a nested object, no output schema, and no safety hints in annotations, the description flawlessly compensates. It explains the output (claim_token), when and how to use each parameter, limitations, and the feedback loop. It covers all essential aspects an agent needs to invoke the tool correctly and understand consequences.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining the semantics of claim_token (how to use it to check status), the requirement to phrase feedback in terms of Pipeworx tools, and the typical message length. It doesn't add new parameter names, but it deepens the meaning, justifying 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 clearly states a specific action ('Tell the Pipeworx team something is broken, missing, or needs to exist') and identifies the resource (Pipeworx tools/packs). It distinguishes itself from siblings by focusing on feedback reporting rather than asking questions or discovering tools, making the purpose unambiguous.

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

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

The description provides explicit when-to-use criteria: bug, feature/data_gap, praise. It also specifies when NOT to use it (for tools from other MCP servers) and instructs users to file with the appropriate server instead. Formatting guidance (describe in terms of Pipeworx tools/packs, don't paste prompt) and the claim_token workflow are clearly explained.

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

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

Beyond annotations (readOnly, idempotent, etc.), the description discloses caching behavior (5min-1h), data source (CF analytics-engine), and privacy (no PII). 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?

Three well-structured sentences: first states core functionality, second lists use cases, third explains data source and caching. Front-loaded, no unnecessary words.

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

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

The description covers purpose, use cases, data source, caching, and privacy. It does not include an example output, but the mention of 'top tools, top packs, and total call volume' is sufficient given the straightforward nature of the tool and no 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?

The only parameter 'window' is fully described in the schema. The description adds context on how shorter vs longer windows affect results, providing extra meaning beyond the enum.

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

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

The description clearly states the tool returns top tools, packs, and call volume over a window. It lists three specific use cases, distinguishing it from sibling tools like ask_pipeworx and 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?

The description provides three explicit use cases for when to use this tool (discovering hot data, confirming canonical tool, aligning use case). However, it does not explicitly state when not to use it or directly compare to specific 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 indicate read-only, open-world, idempotent, non-destructive behavior; description aligns fully. Discloses detailed behavioral traits: monotonicity checks, partition checks, similarity thresholds, partition filters, fill check against live CLOB depth, and conditions for ignoring signals.

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

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

Description is lengthy but well-structured with clear sections. Each sentence adds value; however, some repetition (e.g., fill check) could be trimmed. Front-loaded with main 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?

No output schema, but description outlines response structure (opportunities array, partition_check object). Covers key aspects of tool behavior and references sibling tools. Complete enough for use, though response format details are slightly sparse.

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%; description adds significant value beyond schema by explaining each parameter in depth, including examples, recommended usage, and behavioral details for event and topic modes.

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

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

The description clearly states the tool finds arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It distinguishes three modes (no-args trending scan, event mode, topic mode) and differentiates from sibling tools like polymarket_edges and polymarket_fill_risk.

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

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

Explicitly states when to use each mode: no args for trending scan, event for specific market (recommended), topic for cross-event scanning. Provides examples and warns when not to trade (realizable_edge_pp ≤ 0), referencing polymarket_fill_risk for custom sizing.

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

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

The description extensively discloses behavioral traits beyond annotations (readOnlyHint, idempotentHint, etc.). It explains the three response segments, edge calculation (edge_pp_net, Kelly fractions), diagnostic structure (_diagnostics with funnel counters), caching (1h at KV level), and the effect of each knob. There is no contradiction with annotations.

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

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

The description is well-structured with sections (FIVE MODEL FAMILIES, TRADEABLE-EDGE KNOBS, RESPONSE TOP-LEVEL) and front-loaded with purpose. However, it is verbose: e.g., detailed model family definitions and diagnostic explanations could be shortened. Given the complexity, it remains clear, but some redundancy (e.g., repeating Kelly cap) could be trimmed.

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

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

Despite no output schema, the description fully explains the response structure (by_segment, fed_candidates, _diagnostics), edge metrics, caching, and filtering logic. For a tool with 9 parameters and complex behavior, it addresses all likely agent questions: how edges are computed, when segments are empty, and how knobs affect results. This is exceptionally 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?

All 9 parameters are described in the schema with 100% coverage. The description adds significant value: it explains the purpose of each knob in context (e.g., max_spread_pp for tradeable-edge filter, min_partition_leg_kelly for partition filter), provides practical defaults and scenarios (e.g., slippage_pp guidance for thin markets), and ties parameters to the response structure. This far exceeds the baseline 3 for high 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 it scans top Polymarket markets and returns opportunities where Pipeworx data disagrees with market price. It distinguishes from siblings by explaining the three response segments and model families (model_driven, structural_arbitrage, concentrated_longshot). The verb 'scan' and resource 'Polymarket markets' are specific, and the description differentiates from sibling tools like 'polymarket_arbitrage' and 'polymarket_edge_tracker' by detailing unique features.

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 it's built for 'what should I bet on today' and that agents discover opportunities without paging hundreds of markets. It provides detailed guidance on tradeable-edge knobs (min_liquidity, max_spread_pp) and when to use them. However, it does not explicitly state when NOT to use this tool versus alternatives like 'polymarket_arbitrage' or 'polymarket_edge_tracker', leaving some ambiguity.

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

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

The description discloses return structure (tracked[], expired[], snapshot_dates[]), computational details (trend, decay computed on |edge_pp_net|), and limitations (60-day TTL, cache-miss gaps). Annotations already indicate safe read-only, idempotent behavior; 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 detailed but well-structured, front-loading purpose. Every sentence adds value, though slightly verbose with RESPONSE details. It earns its length.

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

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

Given no output schema, the description fully explains the return fields, data sources, and limitations (TTL, gaps, decay computation). It is complete for an agent to understand what to expect.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning by explaining days default/clamp, window snapshot family, and semantics of 'lookback'. This goes beyond the schema's brief field descriptions.

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

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

The description clearly states it provides edge persistence and decay telemetry, answering specific questions about edge duration and trend. It distinguishes itself from sibling polymarket_edges by focusing on time-series and historical context.

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 by contrasting fresh vs. old edges and explicitly framing the question 'how long has this edge existed and is it shrinking?'. However, it does not provide explicit when-not-to-use or list 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 mark it read-only, open-world, and idempotent. The description adds value by detailing internal behavior like 'walks the ladder', return fields (e.g., top_of_book, vwap_fill_price, slippage_pp, verdict), and warns about forced directional risk and partial basket fills being the 'dominant loss mode'. 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 well-structured with clear sections (SINGLE-MARKET, BASKET) and bullet-like enumeration of return fields. Every sentence adds value, though some redundancy exists (e.g., repeating 'US$1' for basket shares). Still, it's 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 no output schema, the description fully enumerates all return fields, including edge cases like thin_legs[], max_clean_notional_usd, and forced_directional_risk. It also explains the tool's role in the arb-bot workflow and accounts for complex behaviors like partial fills and unhedged positions.

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), but the description adds rich semantics: explains size_usd differs by mode (max spend on buys vs target proceeds on sells, and settlement notional for baskets), clarifies side defaults and mode-specific options, and emphasizes the market/event exclusivity (REQUIRES one of). These details go far 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 'Realizable-vs-theoretical edge check against live CLOB order-book depth' and distinguishes single-market and basket modes with specific behaviors. It differentiates from siblings like polymarket_arbitrage and polymarket_edges.

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

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

Explicitly states 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500'. Provides clear context for single-market vs basket, includes warnings about thin books and partial fills converting arb to directional positions.

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 provide readOnlyHint, openWorldHint, idempotentHint as true, and destructiveHint false. The description adds substantial behavioral context: it details the two modes, response structure, safety fields (compatibility_warning conditions, temporal_alignment, skipped_cross counters), and warns about non-equivalent bet shapes and temporal gaps. No contradiction with annotations.

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

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

The description is well-structured and front-loaded, opening with the core purpose. It uses clear section labels (TWO MODES, RESPONSE, SAFETY FIELDS) and bullet-like formatting. However, it is somewhat lengthy; some details (e.g., skipped_cross_subtype explanation) could be trimmed without loss of clarity. Still, every sentence serves a purpose.

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

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

Given the tool's complexity (three parameters, two modes, multiple safety warnings, no output schema), the description is thorough. It explains the response structure ('leg-by-leg prices', 'top_spreads_pp'), safety fields, and edge cases (non-equivalent bet shapes, temporal misalignment). The agent can understand what to expect and how to interpret results without external documentation.

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

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

Schema coverage is 100%. The description adds significant meaning beyond the schema: it explains the topic parameter's 10 pre-mapped shortcuts with examples, describes how explicit tickers override auto-mapping, and provides context on how parameters interact (e.g., topic used alone vs. combined with explicit tickers). This helps the agent select the right input combination.

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

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

The description clearly identifies the tool as a cross-venue spread calculator between Kalshi and Polymarket. It specifies the verb ('Cross-venue spread') and resource ('Kalshi and Polymarket for the same resolving question'). This distinguishes it from sibling tools like polymarket_arbitrage (intra-venue) and others unrelated to cross-venue comparison.

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

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

The description explains two usage modes (topic shortcuts vs. explicit tickers) and provides safety fields (compatibility_warning, temporal_alignment) that guide appropriate use. It cautions that 'real cross-venue spreads are rarer than the macro-shortcut list suggests' and that pre-mapped topics often return warnings. However, it does not explicitly compare to alternatives like polymarket_arbitrage or suggest when not to use this tool.

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

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

Annotations already declare readOnlyHint true and destructiveHint false. The description adds behavioral context: it can retrieve single values or list all keys, is scoped to an identifier, and avoids re-derivation. No contradiction with annotations.

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

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

Three sentences, front-loaded with the core purpose. Every sentence adds value: retrieval vs listing, usage context, scoping and pairing. 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 tool with one optional parameter, 100% schema coverage, and clear annotations, the description covers retrieval behavior, listing mode, scoping, and companion tools. It is fully complete for its complexity.

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

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

Schema coverage is 100% so baseline is 3. The description adds value by explaining that omitting the key argument lists all keys, which clarifies the optional parameter's behavior beyond the schema's type 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 retrieves a value saved via remember or lists all keys when the key argument is omitted. It specifies the verb (retrieve/list) and resource (saved values/keys), and distinguishes itself from sibling tools like remember and forget.

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

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

The description provides guidance on when to use the tool: to look up context the agent stored earlier without re-deriving it. It mentions scoping to the identifier and pairing with remember and forget. However, it does not explicitly state when not to use it or compare to other retrieval siblings.

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

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

The description states that setting mark_read:true flags events as read, which is a side effect. However, annotations declare readOnlyHint=true, indicating no state modification. This contradiction undermines transparency.

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

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

The description is five sentences with no redundancy. It front-loads the main purpose and efficiently covers key features without wasting 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?

Despite no output schema, the description specifies return fields and parameter behaviors. It lacks pagination details but is sufficient for a tool with simple parameters and clear annotations.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining type with an example, since as ISO timestamp, and the effect of mark_read/unread_only, going beyond schema names.

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 pulls fired events from a subscription feed, returns specific fields (source, citation_uri, payload), and offers filtering. This distinguishes it from siblings like search_events or 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 mentions polling works fine and provides an alternative HTTP endpoint for scripts/dashboards. It does not explicitly exclude scenarios or contrast with sibling tools, 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?

Annotations already indicate safe read-only, non-destructive behavior. Description adds significant context: fans out across multiple sources, explains fallback logic, soft-fail for USPTO, and return structure with citations.

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

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

Front-loaded with use cases, then explains sources and parameters, then contrasts with alternative. Every sentence adds value, no fluff.

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

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

Despite no output schema, description details return structure. The complexity of multiple data sources and fallback is fully covered. The description is complete for an agent to select and invoke this tool correctly.

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

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

Schema coverage is 100%, but description adds examples and guidance (e.g., 'Use 30d or 1m for typical monitoring'), clarifies value accepts ticker or CIK, and explains since formats.

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 specifies it is a change feed for a company with examples like 'What's new with X' and distinguishes from sibling tool 'entity_profile' which covers static profiles.

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

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

Explicitly states when to use (e.g., updates, news, changes) and when to use entity_profile instead, plus fallback behavior for data sources.

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

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

Adds context beyond annotations: key-value storage, scoping by agent identifier, and retention details (persistent for authenticated, 24h for anonymous). No contradiction with annotations (idempotentHint=true, destructiveHint=false).

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 with clear front-loading of purpose. Each sentence adds essential information without 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?

The description covers all necessary aspects: behavior, scoping, retention, and pairing with related tools. No output schema needed for a store operation.

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

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

Schema coverage is 100%, so baseline is 3. Description adds useful examples for key (e.g., 'subject_property') and clarifies value as 'any text', which adds meaning beyond the schema types.

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

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

The description clearly states the tool saves data for reuse later, with specific verb 'Save data' and resource 'key-value pair'. It distinguishes from siblings like recall and forget by mentioning retrieval and deletion.

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

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

Explicitly states when to use ('when you discover something worth carrying forward') and provides alternatives (recall, forget). Also mentions scoping and persistence differences for authenticated vs anonymous sessions.

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

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

Beyond the annotations (read-only, idempotent), the description discloses that each call cascades through multiple lookup endpoints, that identifiers are source-labelled, that unresolved identifiers are explicitly listed, and that LEI/FIGI enrichment degrades gracefully. This is substantial behavioral context that helps the agent trust the tool's output.

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 examples and a clear purpose statement, followed by structured detail on supported types. It is longer than ideal but every section adds value (inputs, outputs, degradation behavior). The dense wall of text slightly reduces readability, but it is well-organized.

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

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

Given there is no output schema, the description does a good job explaining what the tool returns for both entity types, including source labels and unresolved handling. It also covers graceful degradation and the fact that it replaces multiple lookups. Minor gaps remain around exact response structure, but the description is quite 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?

The input schema already fully describes both parameters (type enum and value formats). The description restates some of this (e.g., ticker/CIK/name for company) but does not add meaningful new semantics beyond what the schema provides. Baseline 3 applies due to high 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 opens with concrete example queries and explicitly states it resolves user-spoken names to canonical identifiers needed by other tools. It also distinguishes itself from siblings by saying 'Use FIRST whenever you have a name but need an ID,' clearly positioning it as the lookup gateway.

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

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

It provides clear guidance to use this tool first when a name needs to be converted to an ID, and explains what each supported type returns. However, it does not explicitly mention when not to use it or name alternative tools (e.g., entity_profile), so it stops short of full when/when-not coverage.

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

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

Annotations already declare readOnly, idempotent, openWorld. The description adds that it calls ai_visibility_check per entity, ranks results, and treats the first entity as subject. This enriches the behavioral context.

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

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

Two front-loaded sentences plus an example phrase. Every sentence earns its place with no waste.

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

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

Given annotations and full schema coverage, the description covers behavior, parameters, and return format (ranked list with score, confidence, signal density). No gaps.

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

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

Schema coverage is 100%, but the description adds clarification: first entity is the subject, rest are competitors, and models are explained with default and API key requirement. This adds value beyond the schema.

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

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

The description clearly states it compares AI visibility across multiple entities, probes each with ai_visibility_check, ranks by score, and surfaces the most/least recognized. It distinguishes from siblings like ai_visibility_check by being a composite comparison tool.

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

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

The description provides a clear use case (competitive AI-marketing audits) and an example question. It does not explicitly state when not to use, but context is adequate.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description adds valuable behavioral context: partial failures degrade gracefully, bundlephobia's first measurement can take 5-30s, and sources_failed will list timeouts. 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 slightly long but well-structured and front-loaded with the core purpose. Every sentence adds useful information, and the layout is logical. Minor length could be trimmed, but it remains effective.

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

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

For a composite tool with two external sources, partial failures, and timeouts, the description is remarkably complete. It details the return summary block fields, behavior on failures, and the first-measurement latency. Despite no output schema, the description covers what is returned 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 baseline is 3. The description adds meaning by clarifying that package accepts scoped npm packages (e.g., '@types/node') and that version defaults to latest. This provides helpful context beyond the schema descriptions.

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

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

The description explicitly states the tool performs a composite check for adding an npm package, listing exactly what it fans out across (deps.dev and bundlephobia). It distinguishes from siblings by specifying 'NPM ecosystem only in v1' and directing other ecosystems to alternative tools.

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

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

The description explicitly says 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me"' and clarifies when not to use it for non-NPM packages.

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

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

Annotations already declare read-only, idempotent, non-destructive. Description adds context about the data source and return fields, enhancing transparency beyond annotations.

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

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

Two sentences, no wasted words, front-loaded with purpose. Efficiently conveys 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?

Covers purpose, filters, and output fields adequately for a search tool with output schema. Lacks mention of pagination but limit parameter is described in schema.

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

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

Despite 100% schema coverage, description provides additional clarity (e.g., pipe-separated OR for country, lists event type values) and a concise overview, adding value beyond schema descriptions.

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

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

Clearly states verb 'Search', specific resource 'ACLED political-violence and protest events', and lists filtering options. Distinguishes from siblings by focusing on ACLED data.

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

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

Implies usage context (searching ACLED events) but does not explicitly state when to use this tool versus alternatives or when not to use it. No exclusionary guidance.

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

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

Discloses embedding model, window size, character cap, truncation behavior, and output offsets—information beyond annotations that informs agent 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?

Concise paragraph structured with purpose, usage, pairing, technical details—no superfluous sentences.

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

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

Even without output schema, description explains return format (offsets and scores), limitations, and technique, making it fully contextual.

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 all parameters; description adds value by explaining text is a fetched record and query is natural language, and hints at limit with 'top-N passages'.

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 semantic search inside an already-fetched record, distinguishing it from siblings by mentioning pairing with ask_pipeworx_grounded.

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

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

Explicitly advises use when the record is too large for the prompt and explains how search_within saves context. Mentions alternative tool ask_pipeworx_grounded for grounding.

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 contradicts the annotation 'idempotentHint: true'. The description says 'Returns the new subscription id,' implying each call creates a new subscription, which is not idempotent. Annotations indicate idempotent, but the description suggests non-idempotent behavior. This is a major inconsistency. Aside from that, the description discloses other behaviors (requires OAuth, returns ID, delivery constraints) that add value, but the contradiction overrides.

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 every sentence adds value. It starts with the main purpose, then systematically covers types, examples, delivery options, and constraints. A slightly more structured format (e.g., bullet points) would improve readability, but the content is well-organized and front-loaded.

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

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

Given the absence of an output schema, the description mentions only 'Returns the new subscription id,' which is minimal but sufficient for a creation tool. It fully covers input parameters, prerequisites, delivery channels, and constraints. However, it could include more on error conditions or confirmation behaviors.

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

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

The schema already has 100% coverage, but the description adds significant value by providing concrete examples for each 'type' and 'params' combination, as well as detailed delivery channel semantics (phone verification, webhook HMAC signing, auto-disable). This enriches the schema far beyond its 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 'Create a proactive monitoring subscription to a live-data event stream.' It uses a specific verb ('Create') and resource ('proactive monitoring subscription'), and the context of 'live-data event stream' distinguishes it from sibling tools like list_subscriptions, unsubscribe, and recent_alerts.

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 outlines when to use this tool: it lists supported subscription types with detailed examples (sec_8k, polymarket_edge, fred_series), prerequisites (Pipeworx OAuth account, phone verification for SMS), delivery channel options, and constraints (10/day SMS cap). It implicitly advises against use for anonymous/BYO accounts.

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. The description adds that the tool returns 'category-bucketed example questions' with 'exact tool + argument shape', drawn from a live catalog. This contextualizes the output without contradicting annotations.

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

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

The description is a single paragraph, but it is dense with information: common questions, categories, and usage patterns. It is front-loaded with the natural language queries. Slightly long but every sentence adds value.

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

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

Given the tool is a discovery entry point with no output schema, the description fully explains the return value (category-bucketed example questions with tool shapes) and mentions meta-tools. It leaves no ambiguity about what the agent will get.

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% (only one parameter). The description adds meaning by listing example topics (finance, pharma, etc.) and explaining that omitting the parameter gives a cross-category spread. This goes beyond the schema's simple 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 identifies the tool as the onboarding entry point for a new agent, answering questions like 'what can I ask?' and 'what can you do?'. It lists specific categories (company financials, drugs, etc.) and distinguishes from sibling tools like ask_pipeworx by positioning it as a discovery tool.

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

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

Explicitly states 'Use this FIRST when you do not yet know what Pipeworx can do for you'. It explains calling without arguments for a full spread or with a topic to focus. It does not explicitly mention when not to use it, but given the context, 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?

Description adds behavioral details beyond annotations: deactivation vs deletion, ownership enforcement. Annotations idempotentHint=true and destructiveHint=false are supported and not contradicted.

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

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

Two concise sentences, front-loaded with action, no extraneous information.

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

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

Simple tool with one parameter and no output schema; description covers action, side effects, and constraints completely.

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

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

Single parameter 'id' fully described in schema (100% coverage). Description doesn't add meaning beyond 'by id', which is baseline adequate.

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

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

Clear verb+resource: 'Cancel a subscription by id.' Distinguishes from siblings like subscribe and list_subscriptions.

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

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

Explicitly states ownership enforcement ('you can only cancel your own subscriptions') and effect (deactivation, not deletion). No explicit exclusion of alternatives, but 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?

Beyond the annotations (readOnly, openWorld, idempotent, non-destructive), the description adds critical behavioral detail: it explains failure modes with verification_error, warns that could_not_verify must not be treated as evidence, and clarifies unsupported means no source. It also describes the internal routing (structured vs grounded) and return semantics, which the annotations do not cover.

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

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

The description is longer than average but every sentence carries useful information, especially the critical warning about could_not_verify. It is slightly dense and could be split into shorter sentences, but it is well-structured and front-loaded with the tool's core purpose. No filler or repetition.

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

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

Given the tool's complexity, the description covers return values (verdict types, actual value with citation, reasoning), failure modes, unsupported semantics, and the internal pipeline. No output schema exists, so this description carries full responsibility for return-value clarity—and it delivers.

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 enriches the tolerance_pct parameter by explaining the default behavior (implied by wording, capped at 5) and practical usage for hallucination detection (set 1–2). It also gives an example for the claim parameter. This adds value beyond the bare 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 natural-language claim verification against authoritative sources, with a specific verb (validate/verify) and resource (claims). It includes multiple trigger phrases and explicitly says 'Use whenever the agent needs to check whether something a user said is factually correct,' which distinguishes it from siblings like ask_pipeworx or 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 provides strong usage context: it specifies when to use the tool (fact-checking user statements) and even differentiates between company-financial claims (SEC EDGAR path) and other claims (grounded pipeline). It does not explicitly name alternatives or state when NOT to use it, but the context is clear enough for an agent to select it over general Q&A or research tools.

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