Germany Tenders

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

Disclosed behavior beyond annotations: probing multiple models, scoring, billing implications for Anthropic (BYO key, pay directly). No contradictions with annotations (readOnly, openWorld, idempotent, non-destructive).

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, front-loaded with core action, every sentence adds unique value. No redundancy or fluff.

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

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

Even without output schema, describes return structure (per-model score, confidence, signals, raw_response + combined view). Sufficient for agent to understand what tool returns.

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

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

Schema coverage is 100%, and description adds value by explaining defaults (entity, models), optionality (_apiKey only needed for Anthropic), and disambiguation purpose of context. No param left ambiguous.

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 entity knowledge and scores visibility (0-100), specifying default model and optional Anthropic probing. It differentiates from siblings like scan_competitor_ai_presence by focusing on multi-model scoring.

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

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

Explicitly lists use cases: AI-marketing audits, pre-launch brand checks, competitive monitoring. Provides context but lacks explicit when-not-to-use or alternatives. Still clear and actionable.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering safety and idempotency. The description adds value by explaining that the tool routes to multiple sources, fills arguments automatically, and returns answers with stable pipeworx:// citation URIs. It could have added more detail on rate limits or response size but is already strong.

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 front-loaded guidance ('PREFER OVER WEB SEARCH'), examples, and when-to-step-up instructions. It is longer than typical but every sentence adds value for agent decision-making. Slightly verbose in listing domains, but this aids specificity.

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 (5,563 tools, 1,462 sources), the description effectively covers when to use it, what it does, and how it differs from siblings. The lack of an output schema is compensated by describing return type (structured answer with citation URIs). It is complete enough for an agent to invoke correctly in most scenarios.

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

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

Schema description coverage is 100%, so baseline is 3. The description does not add parameter-specific semantics beyond what the schema provides (the single 'question' parameter accepts multiple aliases). The description's examples and guidance add context to the type of questions to ask but don't enhance parameter understanding beyond schema documentation.

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

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

The description clearly states the tool routes questions to over 5,000 tools across 1,462 verified sources and returns structured answers with citations. It uses a specific verb ('routes') and resource ('authoritative structured data'), and distinguishes itself from siblings like ask_pipeworx_grounded and deep_research by noting when each alternative should be used.

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 extensive usage guidance: it explicitly says to prefer this tool over web search for a wide range of factual questions, gives concrete query examples, specifies when to 'step up' to ask_pipeworx_grounded or deep_research, and notes it works on all tiers in one fast call. This leaves no ambiguity about when to use this tool versus alternatives.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive. The description adds value by stating that no candidate is active right now (matching stable), that this is a full working router (no fallback to nothing), and that it is the 'experimental edge.' This provides current-state 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?

The description is two concise sentences, front-loaded with the tool's identity and key differentiator. Every sentence adds value with no wasted words.

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

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

For a beta tool with a simple schema (one actual parameter, no output schema) and rich annotations, the description covers identity, relationship to stable, current status, and usage intent. It could be more complete by explaining how results are compared or what 'candidate routing improvements' entails, but it is sufficient for the context.

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

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

Schema coverage is 100% with all 6 parameters (aliases for 'question') clearly documented in the schema. The description only notes 'same arguments' without adding further semantic detail. Baseline 3 is appropriate as the schema already handles parameter meaning.

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

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

The description clearly identifies the tool as a beta version of ask_pipeworx, specifies it is an identical universal router with the same 5,563 tools, same arguments, and same response shape, but with candidate routing improvements. This distinguishes it from its stable sibling and the grounded variant.

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

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

The description explicitly tells the agent to use it exactly like ask_pipeworx when wanting the newest routing. It explains that results are compared to the stable router for decision-making. It does not explicitly state when not to use, but the context is clear enough for a beta 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?

The description reveals critical behavioral traits beyond annotations: it costs an extra LLM call, it returns explicit refusals with structured reasons (e.g., 'not_in_source', 'no_tool_match'), and it guarantees no fact invention. Annotations already indicate read-only, idempotent, and non-destructive, but the description adds deep context about refusal behavior and cost trade-off.

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

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

The description is front-loaded with the core purpose and then provides nuanced usage guidance. It is somewhat long but every sentence adds value (cost, refusal structure, use cases). Slightly verbose but information-dense.

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

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

Given the tool's complexity (6 parameters, with many aliases), the description adequately explains the return format and refusal reasons. No output schema exists, so the description compensates by detailing the response structure. It is complete for high-stakes usage, though it could mention rate limits or retry behavior.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add new meaning beyond the schema; it merely mentions 'arguments' generically. No additional parameter constraints or format details are provided, so the score stays at baseline.

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

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

The description clearly states the tool is a 'Hallucination-resistant answer mode for high-stakes reads.' It specifies the verb 'extracts' and the resource 'from 5,563 across 1462 sources,' and distinguishes itself from the sibling 'ask_pipeworx' by noting it uses a different extraction strategy.

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

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

The description explicitly tells when to use this tool: 'whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts (financial verdicts, legal claims, medical lookups, public statements).' It also warns against casual use by saying 'prefer ask_pipeworx for casual lookups,' providing clear 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 flag readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description goes far beyond, detailing the resolver contract (confidence levels, alternatives), parent event extraction, news fallback fields, safety mechanisms (low_confidence_match, market_closed_or_inactive), wide-spread detection, and cancellation rule parsing. No contradictions with annotations; the description adds comprehensive behavioral context.

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

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

The description is very long and dense, covering many edge cases and details. While well-structured with paragraphs and bolded section headers, the sheer length may hinder quick scanning. The first sentence effectively front-loads the purpose, but subsequent sections could be trimmed without losing critical information. A more concise version would better serve agent efficiency.

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 (3 parameters, no output schema), the description is remarkably complete. It explains the response structure (result.market, result.analysis, result.evidence), the resolver contract, parent event extraction, news fields with error handling, safety mechanisms, and resolution-rule risk. Every important aspect is covered, leaving little ambiguity for the agent.

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

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

Schema coverage is 100%, so baseline is 3. The description does not add significant extra meaning beyond what the input schema's descriptions already provide (market, depth, include_raw). The schema examples and property descriptions are already clear. The description focuses on overall behavior rather than parameter-level details, so it does not materially improve parameter understanding.

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

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

The description opens with a clear verb+resource statement: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies inputs (slug, URL, question text) and outputs (evidence packet, market-vs-model comparison). The use cases 'should I bet on X', 'what does the data say about Y', 'is there edge in Z' distinguish it from sibling tools like polymarket_arbitrage or polymarket_edges, which focus on different tasks.

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

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

The description explicitly lists when to use the tool ('Use for should I bet on X...') and provides examples of classifier categories and fan-out scenarios. It does not explicitly state when not to use or compare to siblings, but the detailed context makes the intended usage clear. The absence of direct exclusion criteria prevents a score of 5.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows it's safe. The description adds significant behavioral context: results are sorted by primary metric (so 'largest' reads off the top), off-calendar fiscal years are handled correctly, and data sources are specified (SEC EDGAR/XBRL for companies, FAERS/FDA/trials for drugs). No contradiction with annotations.

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

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

The description is a single dense paragraph but is front-loaded with the most important information (triggers, purpose, usage advice). It covers all key points without redundancy. A minor improvement would be to break it into bullet points for easier parsing, but it remains concise and efficient.

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

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

Given the tool's complexity (two entity types, multiple data sources, sorting, citation URIs), the description covers the main aspects: what it returns, data sources, and sorting behavior. There is no output schema, but it mentions the return format (paired data + URIs). It lacks details on potential errors or rate limits, but annotations (openWorldHint) imply data may vary over time. Overall, it is sufficiently complete for an agent to use effectively.

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 still adds value: it explains the type parameter with examples ('company' vs 'drug'), and the values parameter gives concrete examples like ['AAPL','MSFT'] and ['ozempic','mounjaro'] along with constraints (tickers/CIKs for companies, names for drugs). This goes beyond the schema's short 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 user-facing trigger phrases like 'Compare X and Y' and explicitly states the tool performs side-by-side comparison of 2–5 companies or drugs in a single parallel call. It distinguishes itself from sequential single-pack lookups (e.g., entity_profile) and specifies what each entity type returns (financials for companies, adverse-event counts for drugs). This makes the purpose highly specific and actionable.

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

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

The description includes a clear preference directive: 'ALWAYS PREFER over sequential single-pack lookups when comparing entities.' This tells the agent when to use this tool over alternatives. The sibling list includes entity_profile, which is the direct alternative for single-entity lookups, so the guidance is well contextualized.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds rich behavioral detail: account requirements, paid tier for thorough depth, parallel decomposition, gap recovery, contradictions scan, hop field, citation_uri, semantic excerpting, latency expectations. No contradictions with annotations.

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

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

The description is detailed and well-structured, with critical info (account requirement) front-loaded. It uses paragraphs and dashes for organization. Every sentence adds value, but it is slightly verbose; could be tightened without losing clarity. Still highly 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?

Given the tool's complexity and the absence of an output schema, the description covers return format (findings packet with fields), gap handling, contradictory findings, hop info, and latency. Missing details on error handling or rate limits, but overall adequate 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 3. The description adds significant value beyond the schema: for 'depth' it explains the number of facets and hops per enum value; for 'question' it clarifies that broad/multi-part questions are fine. This provides context not present in parameter descriptions.

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

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

The description clearly states it performs 'grounded multi-source research' across 1462 structured data sources, distinguishing it from siblings like ask_pipeworx. It specifies the verb 'research' and the resource 'Pipeworx's structured data sources', with explicit scope and capabilities.

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

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

Explicit guidance is given: 'For a single lookup use ask_pipeworx', 'For BREAKING or colloquial CURRENT-NEWS... prefer ask_pipeworx', and 'If you are not signed in, use ask_pipeworx instead'. It also explains when deep_research is best (broad/multi-part questions over structured data) and its limitations (empty gaps for topics not in the catalog).

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 readOnly, idempotent, non-destructive. Description adds that it returns top-N relevant tools with full schemas and examples, and that results are ready to call directly. This explains the tool's behavior and output beyond annotations.

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

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

The description is a single paragraph but front-loads the purpose and use cases, then details return value. It is efficient but slightly verbose; every sentence contributes, but it could be trimmed slightly.

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

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

Given 6 parameters (many aliases), no output schema, and complex task, the description covers purpose, usage guidance, return structure (top-N tools with schemas), and examples. It is fully adequate for an agent to decide when and how to use.

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

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

Schema coverage is 100% (all parameters described). The description clarifies that 'query' accepts natural language, provides examples, and explains aliases (q, task, search, description). It also adds default and max for 'limit', adding value beyond schema.

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

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

The description clearly states 'Find tools by describing the data or task' and provides extensive use-case examples. It distinguishes from siblings by instructing to call this tool FIRST to see the option set, making its purpose unique.

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

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

Explicitly says when to use: 'when you need to browse, search, look up, or discover what tools exist for...' and 'Call this FIRST...' It gives clear context but does not explicitly mention when not to use or name specific alternatives.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive hints. The description adds significant context: fans out across multiple sources, returns specific fields (cik, filings, fundamentals, patents, news, LEI), and mentions data freshness ordering (LATEST 10-K, sorted period_end DESC). No contradictions.

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

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

The description is a single dense paragraph. While it packs a lot of useful information, it could benefit from bullet points or shorter sentences for easier scanning. However, it is not overly long and front-loads the primary purpose effectively.

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

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

Despite no output schema, the description thoroughly details what the tool returns (cik, filings with URIs, fundamentals, patents with sunset note, news, LEI). Combined with strong annotations and parameter coverage, the description is complete for an agent to correctly invoke and interpret the tool.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds essential nuance: explains that value can be ticker or zero-padded CIK, clarifies names are not supported (pointing to resolve_entity), and notes the type field currently only supports 'company'. This goes well beyond the schema.

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

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

Description starts with clear examples ('Tell me about X', etc.) and explicitly states it provides a 'full cross-source profile of a US public company in ONE parallel call'. It distinguishes itself from sibling tools like resolve_entity by specifying input requirements.

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 prefer this tool ('ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view') and provides an alternative path ('use resolve_entity first if you only have a name'). Also notes limitations like the patent API sunset.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, covering the key behavioral aspects. The description adds context about use cases but does not disclose additional behaviors beyond what annotations provide, so a baseline score of 3 is appropriate.

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

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

Two sentences with no wasted words. The key action is front-loaded, and the additional usage context is provided efficiently.

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

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

For a simple tool with one parameter, clear annotations, and explicit purpose and usage guidance, the description is complete. No output schema is needed for a delete 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%, and the parameter description 'Memory key to delete' is clear. The tool description does not add any further meaning beyond what the schema already provides, so baseline score of 3 is given.

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 begins with a clear verb 'Delete' and identifies the resource as 'previously stored memory by key'. It distinguishes itself from siblings by naming 'remember' and 'recall' as paired tools, indicating this is the deletion 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?

The description explicitly states when to use the tool: 'when context is stale, the task is done, or you want to clear sensitive data'. It also mentions pairing with siblings but does not explicitly state when NOT to use it.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows it's safe and idempotent. The description adds behavioral context: it fetches the page, extracts title/description/key links, and outputs standard markdown. This is valuable beyond annotations, though it could mention additional traits like rate limits or handling of large pages.

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

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

The description is three sentences: purpose, process, use cases. No redundant or unnecessary words. Every sentence earns its place, making it highly efficient and easy to scan.

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

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

Given the tool's simplicity (2 params, no output schema, annotations present), the description is fairly complete. It explains the output format (text blob for site-root/llms.txt) and lists use cases. It doesn't cover error scenarios or invalid URLs, but overall enough for an agent to use correctly.

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

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

Schema description coverage is 100%, so the schema already documents both parameters well. The description reiterates that 'url' is the full URL and 'max_links' has a default of 25 max 50, but adds no new semantic information beyond the schema. Baseline 3 is appropriate.

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

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

The description starts with a clear verb 'Generate' and specifies the resource 'llms.txt file for any URL'. It further details the process (fetches, extracts, emits) and distinguishes from sibling tools like ai_visibility_check and scan_competitor_ai_presence by focusing specifically on the standard llms.txt generation.

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

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

The description explicitly lists three use cases: getting a client's site indexed, drafting for own project, and auditing competitor visibility. This provides strong context for when to use. While it doesn't explicitly state when not to use, the use cases are well-defined and differentiate from other tools.

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

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

Annotations already indicate readOnlyHint, openWorldHint, idempotentHint, and no destructiveness. The description adds valuable context: the data source, return shape (OCDS fields), and that results are newest-first. 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 well-structured and front-loaded with key purpose and data source. It concisely conveys all necessary information without redundancy, though it could be slightly shorter.

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 four parameters, no output schema, and rich annotations, the description is complete: it details the return fields, filtering options, defaults, and geographic scope. An agent has enough information to correctly invoke the tool.

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

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

Schema description coverage is 100%, so baseline is 3. The description enhances parameter meaning by explaining the query matches German text fields, date parameters are for publish date, and clarifying the default behavior for date_from (only recent 7 days fetched per call).

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 searches German government public-procurement tenders from a specific federal open-data feed. It lists the fields returned and distinguishes itself from sibling tools by focusing on German tenders, a unique scope.

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

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

The description explains when to use the tool (for German tenders), how to filter by date and keyword, and provides defaults. It implicitly indicates it is for Germany only, but does not explicitly contrast with sibling tools or mention when not to use it.

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

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

Annotations already indicate readOnly, idempotent, openWorld, non-destructive. Description adds that it returns specific fields and lists only the caller's subscriptions, providing valuable context beyond annotations.

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

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

Two sentences, front-loaded with purpose, no wasted words. Efficient and clear.

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

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

Tool is simple with one optional parameter fully described. No output schema but description lists return fields. Complete for a read-only list tool given annotations and context.

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

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

Schema coverage is 100% for the single parameter 'include_inactive', which is well-described in the schema. The description does not add extra meaning to the parameter, so baseline score applies.

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

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

The description clearly states 'List the caller's active subscriptions' with a specific verb and resource, and distinguishes itself from siblings like 'subscribe' and 'unsubscribe' by focusing on listing for review or cancellation.

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 when to use: 'review what you're monitoring before adding more or to find an id to cancel,' providing clear context. Does not explicitly exclude alternatives but the guidance is sufficient.

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

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

Beyond the minimal annotations (all false), the description discloses rate limiting (5 per identifier per day), quota impact (free, doesn't count against quota), and the claim_token mechanism for later retrieval. It also clarifies the team's daily review process, with no contradiction to the annotations.

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

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

Although the description is substantial, every sentence serves a purpose: purpose, use-cases, exclusions, formatting rules, claim-token behavior, rate limits, and team schedule. The information is front-loaded with the core purpose and then supports with operational details, with no filler.

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

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

Given the tool's moderate complexity (multiple feedback types, optional structured context, claim_token retrieval, rate limits), the description covers all key behaviors and constraints. Since there is no output schema, the description explicitly states the claim_token return and later status retrieval, making it 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?

The input schema already covers 100% of parameters with detailed descriptions, raising the baseline to 3. The description adds practical guidance for the message parameter (be specific, reference Pipeworx tools/packs, don't paste user prompts) and explains the optional claim_token workflow, providing extra semantic value beyond the schema.

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

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

The description opens with a clear verb phrase ('Tell the Pipeworx team') and resource, then enumerates feedback categories (bug, feature, data_gap, praise). It explicitly disambiguates its scope to tools served by this Pipeworx connection, distinguishing it from sibling tools that handle research, memory, or 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 provides explicit use cases: when a tool returns wrong/stale data (bug), when a capability is missing (feature/data_gap), or for praise. It also gives a clear exclusion rule (file with the correct server for other MCP tools) and warns against pasting user prompts, offering strong 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 declare readOnlyHint, openWorldHint, idempotentHint. Description adds that data is derived from CF analytics-engine, no PII, and cached 5min-1h, providing context beyond annotations without contradiction.

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

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

Concise, front-loaded with core purpose, then use cases, then technical details. Every sentence adds value without redundancy. Well-structured with bullet-point-like numbering for use cases.

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

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

No output schema, but description adequately describes return type (top tools, top packs, total call volume). Caching and data source details provide enough context for the agent to understand behavior. Could include format hints but is sufficient for a simple trending tool.

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

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

Schema already documents the 'window' parameter with enum values and descriptions (100% coverage). The description adds semantic guidance: shorter windows show what's hot, longer windows show steady-state demand, which enhances understanding beyond schema.

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

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

The description clearly states the tool returns top tools, top packs, and total call volume over a window. It distinguishes itself from siblings by specifying the self-aggregating signal and use cases like discovering hot data sources or confirming canonical tools.

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

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

Explicitly lists three use cases and explains window trade-offs (short vs. long). Does not mention when not to use it or offer alternatives among siblings, but the guidance is clear and actionable.

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

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

Annotations indicate readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds extensive behavioral context beyond annotations: scanning scope (top ~200 markets), semantic anchor (Jaccard ≥0.30), partition filter (placeholder slugs), and fill check against live CLOB depth. 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 thorough but not overly verbose; each sentence adds detail about modes, filters, or response. Structured with paragraphs and lists. Could be slightly more concise but front-loads purpose effectively.

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

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

Given the complexity of arbitrage logic and lack of output schema, the description comprehensively explains input modes, filtering mechanisms, response fields (gap_pp, suggested_trade, partition_check), and fill check. It distinguishes from sibling tools like polymarket_fill_risk and covers edge cases (placeholders, low similarity).

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

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

Schema coverage is 100% with parameter descriptions. The description adds significant meaning: explains event slug/URL format, topic as seed question, and the behavior with no arguments (trending scan). This enriches the schema-provided info.

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 arbitrage opportunities on Polymarket via monotonicity violations + partition-sum checks.' It explains two modes (event and topic) and a default trend scan, making the tool's purpose specific and distinguishable from siblings like 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?

Explicit guidance on when to use each mode: 'Call with NO args for a trending_scan', 'event (recommended for a specific market)', 'topic (for cross-event scanning)'. It also explains why cross-event mode is useful. Lacks explicit 'when not to use' but the modes are clearly scoped.

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

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

Annotations already declare readOnly, idempotent, and non-destructive. The description adds value by disclosing caching behavior (1h KV cache), explaining why Fed bets are unreliable, and detailing how edge is computed net of slippage. 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 lengthy but well-organized with clear sections for each model family and response structure. It front-loads the purpose and uses parentheticals for detail. While dense, every sentence adds value and the structure aids comprehensibility.

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

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

Given the tool's complexity (9 parameters, no output schema), the description is remarkably complete: it explains the response structure (by_segment, diagnostics), why segments may be empty, filter behavior, and Fed candidate handling. All necessary context for effective use is provided.

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

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

Schema coverage is 100% with detailed parameter descriptions. The tool description adds significant context beyond the schema, such as explaining the interplay between min_partition_leg_kelly and partition arb basket trades, and how slippage_pp interacts with market conditions.

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 scans Polymarket markets to find opportunities where Pipeworx data disagrees with market price, using specific models. It distinguishes itself from siblings like polymarket_arbitrage by detailing its unique edge detection methodology.

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

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

The description explicitly frames the tool for daily bet discovery, explains when to use knobs like min_liquidity and max_spread_pp for filtering realizable edges, and mentions that Fed bets are excluded due to data limitations. However, it does not explicitly contrast with sibling tools for alternative use cases.

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 rich behavioral context: data source (daily snapshots), response structure (tracked, expired, snapshot_dates), decay computation details, and interpretation of gaps.

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 question and well-structured (overview, RESPONSE:, LIMITS:). Slightly verbose in parenthetical explanations but each sentence adds value given the tool's complexity.

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

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

Despite no output schema, the description fully explains return structure (tracked, expired, snapshot_dates) and limitations. Provides all necessary context for an agent to use the tool correctly.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds value by explaining defaults (14 days, 1wk), constraints (max 30, clamp 2-30), and the meaning of 'window' as snapshot family.

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

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

The description clearly states the tool's purpose: 'Edge persistence and decay telemetry' that answers 'how long has this edge existed and is it shrinking?'. It distinguishes from siblings by focusing on historical persistence rather than current edges.

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

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

Explicitly states when to use this tool vs. alternatives: 'a fresh wide edge and a 3-week-old wide edge are different trades (the latter is wide for a reason nobody is willing to take).' Also provides LIMITS section with practical constraints like 60-day TTL.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description does not need to repeat those. It adds valuable behavioral context: it walks the order book ladder, returns fill quality metrics (top_of_book, vwap_fill_price, slippage, etc.), and warns that partial fills convert arb into directional positions. This goes beyond the annotations, providing a clear picture of the tool's behavior.

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

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

The description is well-structured with clear sections for each mode, bold for key terms, and front-loaded purpose and guidelines. While it is lengthy, the content is justified by the tool's complexity (two modes, multiple return fields). It could be slightly trimmed, but the structure is effective and information-dense.

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

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

Given the tool's complexity (two modes, no output schema), the description comprehensively covers behavior, parameters, return fields, and risks. It lists all key return fields and provides usage warnings. The absence of an output schema is compensated by the detailed listing of return values. It is sufficiently complete for correct tool invocation.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds significant meaning beyond the schema by explaining the two modes, the default side logic for basket mode (auto based on partition sum), and the interpretation of size_usd differently for single-market vs basket. This deeper semantic context helps the agent use the parameters correctly.

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 as a 'Realizable-vs-theoretical edge check against live CLOB order-book depth' and distinguishes it from siblings like polymarket_arbitrage and polymarket_edges by specifying exactly when to use it. It uses specific verbs and clearly delineates two modes: single-market and basket.

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

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

The description explicitly instructs: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500.' It provides context on when theoretical overround is not capturable and warns about the risk of unhedged positions from partial fills, effectively guiding the agent on when to invoke this tool versus alternatives.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds substantial behavioral context beyond annotations: explains response structure (leg-by-leg prices, matched spreads), safety fields (compatibility_warning, temporal_alignment, skipped counters), and explicitly notes that most shortcut topics are not tradeable. 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 lengthy but well-structured: purpose sentence first, then two modes, then response structure, then safety fields. Every sentence adds necessary detail for a complex tool. Minor verbosity in safety field explanation but front-loaded effectively. Score 4 because it is slightly long but justified by complexity.

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

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

With no output schema, the description fully explains return values: leg-by-leg probabilities, matched spreads, top_spreads_pp, compatibility_warning conditions, temporal_alignment, and skipped counters. It also sets expectations about composability (most topics not tradeable). Complete for a 3-parameter, 0-output-schema tool.

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

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

Schema coverage is 100% with all three parameters described. The description adds meaning beyond the schema by listing the 10 topic shortcuts, explaining that explicit tickers override topic-mapped sides, and providing example formats. While the schema does heavy lifting, the description enriches parameter semantics with usage context.

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

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

The description immediately states 'Cross-venue spread between Kalshi and Polymarket for the same resolving question,' which is a specific verb+resource pairing. It clearly distinguishes from sibling tools like polymarket_arbitrage by focusing on cross-venue comparison rather than intra-venue opportunities.

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 distinct modes (topic and explicit) with clear guidance on when to use each. It warns that most pre-mapped topics return compatibility_warning and are not necessarily tradeable, and explicitly describes conditions when spreads are meaningless (temporal misalignment, shape mismatch). This provides excellent when-to and when-not-to guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. Description adds functional behavior: retrieval vs. listing, and scoping. It does not contradict annotations. No additional details about error cases or rate limits, but annotations suffice for safety profile.

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, well-structured: function, use case, scoping, and pairing. Every sentence earns its place with 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?

For a simple tool with 1 optional parameter and no output schema, the description covers all necessary context: what it does, when to use, scope, and companion tools. 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% (1 parameter with description 'Memory key to retrieve (omit to list all keys)'). The description repeats the omit-to-list behavior but adds no deeper semantic meaning 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 defines the tool's action: retrieve a saved value by key, or list all keys if omitted. It specifies the verb (retrieve/list), resource (saved values/keys), and context (from remember). This distinguishes it 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?

Description states when to use: 'look up context the agent stored earlier... without re-deriving it from scratch.' It also mentions pairing with remember and forget, and scoping by identifier. However, it does not explicitly exclude alternative tools or state when not to use.

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

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

Annotations already indicate readOnly, openWorld, idempotent, non-destructive behavior. The description adds valuable context: return structure (source, citation_uri, raw payload), mark_read side effect, polling suitability, and alternative access method. 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?

Five sentences, each earning its place. First sentence states purpose, subsequent sentences add detail on return values, filters, mark_read behavior, polling, and alternative access. No redundancy or fluff.

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

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

Despite no output schema, the description covers return format, all parameter purposes (though unread_only is mentioned only in schema), and provides operational context (polling, alternative endpoint). For a read tool with optional parameters and rich annotations, this description is complete.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds meaning by explaining the effect of 'mark_read' (flags returned events as read), gives a concrete filter example ('sec_8k'), and clarifies 'since' as ISO timestamp. This extra context justifies 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?

Clear verb 'pull' and resource 'fired events from your subscription feed'. The description states the tool's core function directly, but does not explicitly distinguish it from sibling tools like 'list_subscriptions' or 'recent_changes', leaving room for confusion.

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 usage context such as 'Polls work fine' and mentions an alternative endpoint for scripts/dashboards. However, it does not specify when not to use this tool or contrast it with alternatives, so the guidance is good but not comprehensive.

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 detailed behavioral context: fans out to multiple sources (SEC, GDELT/GNews, USPTO with deprecation note), return structure (changes grouped by source, total_changes, citation URIs), and parameter behavior. 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 lengthy but justified by the tool's complexity. It is well-structured with examples, parameter details, and alternative tool reference. Could be slightly trimmed, but overall efficient.

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

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

Given the complexity (multiple data sources, fallback, relative dates, return structure), the description provides complete context: purpose, when to use, parameter rules, behavioral details, and alternative tool. No output schema, but return structure is described.

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 valuable context beyond schema: explains relative shorthand for 'since' (e.g., '7d', '30d'), recommends '30d' for monitoring, and clarifies that 'type' only supports 'company' today. This adds meaning useful for the agent.

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

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

The description clearly states the tool provides a change feed for a company in a specified time window, with concrete examples like 'What's new with X'. It distinguishes from the sibling tool 'entity_profile' which provides 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?

Explicit guidance is given on when to use this tool versus entity_profile, and examples of queries are provided. The description also explains fallback behavior between GDELT and GNews.

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 only indicate idempotent and non-destructive. Description adds key behavioral traits: scoping by identifier, persistence difference between authenticated (permanent) and anonymous (24 hours). 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?

Three sentences, front-loaded with purpose, then usage examples, then behavioral details. No redundant or vague content. 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 2-param tool with rich annotations, the description covers purpose, usage, and behavior. Missing details on overwrite behavior or error handling, but these are not critical given idempotence hint. Close to complete.

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

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

Schema coverage is 100% with good param descriptions (key/value with examples). The description adds general context (scoping and persistence) but doesn't enhance parameter-specific semantics beyond what schema provides. 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 saves data for later reuse, using specific verbs like 'Save data' and 'stored as a key-value pair'. It distinguishes from siblings by mentioning pairing with recall and forget, and provides concrete examples (ticker, address, preference).

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 you discover something worth carrying forward'. Lists example use cases and directly contrasts with recall and forget siblings, providing clear when-to-use and alternative guidance.

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

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

Annotations already declare readOnly, idempotent, openWorld, and non-destructive. The description adds substantial behavioral detail: it labels each identifier with its source, explicitly lists unresolved identifiers under `unresolved`, and explains graceful degradation (LEI/FIGI enrichment falls back to EDGAR). It also notes internal cascading and that it replaces 2-3 manual lookups.

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

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

The description is dense and informative, with every sentence adding value. It is front-loaded with example queries and organized into supported types with additional notes. It is long but necessary for the complexity, though it could benefit from tighter formatting (e.g., bullets) to improve scannability.

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

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

Given the tool's complexity (two entity types, multiple external sources, no output schema), the description is remarkably complete. It explains return data for company (CIK, ticker, LEI, FIGI), sources, ownership relationships, unresolved field behavior, drug outputs (RxCUI, ingredient, brand, citation), and graceful degradation. This exceeds expectations for contextual completeness.

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

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

Schema coverage is 100% and the schema has simple type/value descriptions. The description dramatically enriches parameter meaning: for `value` it lists accepted formats (ticker, CIK, ISIN, name for company; brand/generic for drug) and even gives an ISIN example and its mapping behavior. For `type` it details what each enum value returns. This goes well beyond the schema.

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

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

The description explicitly states the tool resolves user-spoken names to canonical/official identifiers, with multiple example queries like "What's the ticker for…". It clearly distinguishes itself as the go-to for name-to-ID resolution and lists supported types (company, drug) with detailed output specifics.

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 an explicit usage directive: "Use FIRST whenever you have a name but need an ID." It also explains what inputs are accepted for each type. However, it does not explicitly state when not to use it or name alternative tools (e.g., entity_profile), so it lacks exclusions but provides clear context.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and non-destructive. The description adds that the tool internally calls ai_visibility_check for each entity and returns a ranked list with score, confidence, and signal density. No contradictions.

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

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

Four concise sentences with front-loaded purpose. Every sentence adds value, no filler. Structure is effective and easy to parse.

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

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

Given the rich annotations, 100% schema coverage, and clear description of inputs, process, and output (ranked list with fields), the description is fully complete for an agent to use correctly.

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

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

Schema coverage is 100%, so parameters are already described. The description adds valuable context, especially that the first entity in 'entities' is treated as the 'subject' and that 'context' disambiguates common names. This goes beyond the schema.

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

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

Description clearly states the tool compares AI visibility across multiple entities side-by-side, probes each with ai_visibility_check, and ranks results. It provides a concrete example ('does Claude know about us as well as our competitors?') and distinguishes from the single-entity sibling ai_visibility_check.

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

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

Description specifies it is useful for competitive AI-marketing audits and includes an example query. However, it does not explicitly state when not to use or mention alternatives like compare_entities, though sibling differentiation is clear.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds valuable behavioral context: partial failures degrade gracefully, bundlephobia first measurement can take 5-30s with timeout listed in sources_failed, and full detail of returned data.

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

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

Description is a single paragraph that packs significant information, but it is well front-loaded with the composite nature and key use cases. Could be slightly more structured with bullet points for returned data.

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 enumerates exactly what is returned (summary block, advisory detail, links, alternative versions) and explains partial failures. This is adequate for a tool combining two external services.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds minor context (scoped packages accepted, version defaults to latest) but no additional semantics beyond schema.

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

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

The description clearly states it combines deps.dev and bundlephobia to answer questions about npm packages. It uses specific verbs ('scan', 'fan out') and resources ('deps.dev', 'bundlephobia'), distinguishing it from siblings like 'scan_competitor_ai_presence'.

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

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

Explicitly tells when to use: when agent asks 'is X safe/popular/small' or 'what does adding lodash cost me'. Also notes limitations: NPM only in v1, with fallback guidance to deps.dev:version for other ecosystems.

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

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

Beyond annotations (readOnlyHint, idempotentHint, etc.), the description discloses key behavioral traits: returns top-N passages with character offsets and similarity scores, uses BGE-base-en embeddings with cosine similarity over 500-char overlapping windows, and has a 200K char limit with truncation flagging. This fully prepares the agent for how the tool operates.

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

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

The description is a single well-structured paragraph that is concise yet comprehensive. Every sentence provides essential information without redundancy. Key details are front-loaded ('Semantic search INSIDE a fetched record'), and the length is appropriate for the complexity of the tool.

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

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

Given that there is no output schema, the description fully covers what the agent can expect: passages with offsets and similarity scores. It also specifies the embedding model, window size, and truncation behavior, making it complete for understanding inputs, behavior, and outputs in a single description.

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

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

The input schema has 100% coverage with descriptions for each parameter. The description adds contextual value by explaining 'the text you already pulled,' providing example queries, clarifying the 'limit' parameter as 'top-N passages,' and mentioning the char limit for 'text.' This supplements the schema effectively.

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 performing semantic search inside a fetched record, using specific verbs ('search') and resource ('text'). It distinguishes itself from siblings by explaining the workflow: fetch first, then search within, and mentions complementary tools like 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?

The description explicitly states when to use the tool: 'when the record is too big to cram into the prompt' and explains that it 'saves context, returns only the passages that matter.' It also provides a pairing recommendation with ask_pipeworx_grounded and implies when not to use it (when the document fits in 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 declare readOnlyHint=false (write), idempotentHint=true, destructiveHint=false. The description confirms creating a subscription, which is consistent. It adds behavioral details not in annotations: returns subscription ID, requires verification for SMS, webhook signing mechanics, and auto-disable after 10 failures. However, it does not explicitly state idempotency, which is in annotations.

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

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

The description is well-structured with sub-bullets for types and delivery channels, making it scannable. While lengthy, every sentence adds necessary context for a multi-option tool. Could be slightly more concise by removing 'always on' redundancy, but overall efficient.

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

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

Given the complexity (multiple subscription types, delivery channels, constraints), the description covers all critical aspects: what it returns, prerequisites (OAuth), type-specific parameters, delivery options with detailed behavior (verification, caps, auto-disable). No output schema, but return value is stated.

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 extensive meaning: explains each type-specific params structure with examples, and details delivery sub-properties including phone verification, email validation, and webhook signing secret retrieval. This goes well beyond the schema definitions.

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

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

The description explicitly states the tool creates a 'proactive monitoring subscription to a live-data event stream' and lists supported types and delivery channels. It clearly distinguishes from siblings like list_subscriptions and recent_alerts, which handle listing and retrieving alerts, respectively.

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 and when-not guidance: requires a Pipeworx OAuth account (anonymous/BYO cannot persist), and details delivery channels with constraints (SMS verification required, 10/day cap). It implies alternatives for pulling alerts (recent_alerts) and listing subscriptions (list_subscriptions).

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 destructiveHint. The description adds behavioral detail: returns live catalog examples, explains topic filtering. No contradiction; adds context beyond annotations.

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

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

The description is somewhat lengthy but each sentence adds value. It is well-structured, front-loaded with the main purpose, and efficiently covers use cases.

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

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

For a simple tool with one optional parameter and no output schema, the description fully covers purpose, usage, topic options, and return content. No missing information for an agent to use it correctly.

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

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

Schema coverage is 100% for the single optional parameter. The description adds meaning beyond schema by listing example topic values (finance, pharma, etc.) and explaining the effect of omitting vs. passing a topic.

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 the onboarding entry point, lists example questions, and explains it returns category-bucketed example questions with tool + argument shapes. It distinguishes itself from sibling tools like ask_pipeworx, entity_profile, etc.

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 this FIRST when you do not yet know what Pipeworx can do' and mentions alternatives (ask_pipeworx, entity_profile, compare_entities). 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?

The description adds context beyond annotations by explaining that the row is deactivated (not deleted) and historical events remain available via recent_alerts. This complements the annotations (destructiveHint=false, idempotentHint=true) and provides full 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?

Two sentences with no wasted words. The first sentence states the action; the second adds critical ownership and data handling details. Information is front-loaded and efficiently conveyed.

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

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

For a simple one-parameter tool with no output schema, the description covers all essential aspects: action, ownership constraint, and side effects (deactivation vs deletion). It is fully complete given the tool's complexity.

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

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

Schema description coverage is 100%, with the id parameter fully described as 'Subscription id (uuid) returned by subscribe.' The description adds little beyond repeating 'by id,' so a baseline score of 3 is appropriate.

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

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

The description clearly states 'Cancel a subscription by id,' providing a specific verb and resource. It distinguishes from siblings like subscribe, list_subscriptions, and recent_alerts by describing a cancel operation with ownership enforcement and a soft-delete behavior.

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

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

The description explicitly notes ownership enforcement ('you can only cancel your own subscriptions'), guiding when to use the tool. It does not explicitly mention alternatives or prerequisites, but the ownership condition is a clear usage guideline.

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

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

The description goes well beyond the read-only and idempotent annotations by clarifying verdict semantics, especially the critical distinction between 'could_not_verify' (check did not happen) and 'unsupported' (no source found). It also details the dual pipeline and the inclusion of pipeworx:// citations, giving the agent important behavioral context for interpreting results.

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

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

The description is dense but every sentence carries useful information, including examples, routing logic, output verdicts, and caller warnings. It is well-structured with clear sections, and the length is justified by the tool's complexity.

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

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

In the absence of an output schema, the description fully specifies the return verdict enum, the presence of citations, and error handling. It also explains how the tool fits into a larger workflow, making it complete for an agent to invoke and interpret results 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?

Despite 100% schema coverage, the description adds meaningful guidance on the tolerance_pct parameter, explaining how to use it for hallucination detection and the default behavior. The claim parameter is also illustrated with concrete examples, further enriching 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 specifies the verb 'validate' and the resource 'claim', and provides multiple natural-language examples that make the tool's function unmistakable. It also distinguishes itself from siblings by explicitly stating it replaces 4–6 sequential calls and covers both structured SEC data and grounded fallback.

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 gives explicit guidance on when to use it ('Use whenever the agent needs to check whether something a user said is factually correct') and explains the internal routing for company-financial vs. other claims. However, it does not explicitly mention alternative tools or exclusion criteria, so it stops short of a full when-not-to-use.

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