Epa Regulations

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

Annotations already declare the tool as read-only, idempotent, and non-destructive. The description adds value by explaining that Anthropic calls require a BYO API key and incur direct costs, and it details the return structure. It does not contradict annotations.

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

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

The description is well-structured, with a clear first sentence stating the core purpose, followed by details on models and return format. It is efficient but could be slightly shortened without losing clarity.

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

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

Despite no output schema, the description thoroughly explains the return structure (per-model score, confidence, signals, raw_response plus combined view). It covers use cases, default behavior, and optional configurations. The sibling context is broad, but the tool is distinct enough.

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

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

Schema description coverage is 100% for all 4 parameters. The description adds extra meaning: it explains the action of 'probing', the optionality of models, the need for _apiKey only with Anthropic, and the disambiguation role of context. This is beyond what the schema provides.

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

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

The description clearly states the tool 'probes one or more LLMs' for visibility scoring (0-100), which is a specific verb and resource. It succinctly distinguishes itself from sibling tools like 'scan_competitor_ai_presence' by focusing on per-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?

The description outlines appropriate use cases ('AI-marketing audits, pre-launch brand checks, competitive monitoring') and explains default behavior. However, it does not explicitly mention when not to use the tool or how it differs from similar siblings like 'scan_competitor_ai_presence', which could cause confusion.

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

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

Annotations already declare read-only, open-world, idempotent, and non-destructive behavior. The description adds valuable behavioral context: the tool routes to other tools, fills arguments, and returns pipeworx:// citation URIs. It also mentions speed ('one fast call') and universal tier availability, enriching the annotation 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?

The description is long and somewhat repetitive, but the key usage directive is front-loaded. Many example queries are included, which adds value, yet some sentences could be trimmed without losing meaning. Overall, it is informative but not strictly concise.

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

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

The tool is complex (a router to many sources) and lacks an output schema, but the description compensates by explaining the return format (structured answer with citations) and providing comprehensive usage context. It does not cover error handling or failure modes, but the given guidance is substantial for an agent to invoke the tool correctly.

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

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

All six parameters are aliases for the same question field, and the schema provides 100% description coverage for each. The description includes example questions but does not add constraints or formatting details beyond the schema. Since the schema already fully documents the parameters, 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 explicitly states the tool's function: it routes questions to one of many sources, fills arguments, and returns structured answers with citations. It also distinguishes itself from sibling tools like ask_pipeworx_grounded and deep_research, making its unique role clear.

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

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

The description gives explicit when-to-use guidance: 'PREFER OVER WEB SEARCH' and 'START HERE for most questions'. It lists specific alternatives and the conditions for stepping up, plus examples of user phrasings that signal the tool's 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?

Beyond the annotations (readOnlyHint, openWorldHint, idempotentHint), the description discloses the experimental nature: candidate routing improvements can be live-tested, currently none are active, and the last was retired on a specific date. It also states that the tool is a full working router with no fallback, providing valuable 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 four sentences, each serving a distinct purpose: identifying the beta, stating current status, giving usage guidance, and clarifying it is a full router. It is front-loaded with the key definition and avoids redundancy, making it appropriately sized and well-structured.

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

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

Given the tool's complexity as a universal router with aliases and no output schema, the description provides complete context: it explains the relationship to ask_pipeworx, the current inactive candidate, the comparison mechanism, and that it is a full working router. This covers all necessary information for an agent to invoke it correctly.

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

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

The schema already covers all 6 parameters with descriptions indicating they are aliases for the question field (100% coverage). The description only adds 'same arguments' relative to ask_pipeworx, which is minimal additional meaning. The baseline of 3 applies as the schema does the heavy lifting.

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

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

The description clearly states it is a beta version of ask_pipeworx, defining it as an identical universal router with the same tools, arguments, and response shape. It explicitly differentiates from the stable ask_pipeworx by mentioning 'candidate routing improvements' and 'experimental edge,' making the purpose unmistakable.

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

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

It explicitly instructs to 'Use it exactly like ask_pipeworx when you want the newest routing,' providing clear context for when to choose this tool over the stable alternative. It also clarifies that it is a full working router, not a fallback, and explains that results are compared with the stable router for merge decisions, ruling out misuse.

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

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

The annotations already indicate readOnly, openWorld, and idempotent, but the description goes further by disclosing the explicit refusal reasons (not_in_source, no_tool_match, tool_error, data_truncated, llm_error), the guarantee to use only the tool result, and the extra LLM call cost. This adds significant behavioral context beyond the annotations, with no contradiction.

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

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

The description is packed with useful information but is somewhat long, running about 160 words. It is front-loaded with the primary purpose and includes concrete behavior and cost details. No fluff, but it could be tightened without losing substance.

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

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

Despite having no output schema, the description completely specifies the return shape on success and failure, including refusal reason enums. It covers use cases, cost, and alternatives, making it easy for an agent to decide and invoke the tool correctly. The context is rich enough for high-stakes usage.

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

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

The input schema has 100% coverage, documenting the 'question' parameter and its aliases fully. The description does not add any parameter-specific details beyond restating the routing logic, so it relies on the schema. Baseline 3 is appropriate because the schema carries the semantic load.

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

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

The description clearly states this is a hallucination-resistant answer mode that extracts answers from tool results, and distinguishes itself from the sibling ask_pipeworx by noting 'Same routing as ask_pipeworx' while adding the grounded extraction behavior. The specific verb 'extracts' and the mention of the refusal mechanism make the purpose unambiguous.

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

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

Explicitly provides usage guidance: 'Use whenever an answer will be quoted, cited, or acted on' and 'prefer ask_pipeworx for casual lookups.' It also mentions the added cost of one extra LLM call, giving clear criteria for when to choose this over the sibling tool, and references the alternative by name.

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

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

Annotations already convey read-only, idempotent, open-world, non-destructive behavior. The description goes far beyond: it details market resolution, classifier fan-out, response field semantics (e.g., market_match_confidence, parent_event, news fallbacks), safety on low-confidence matches, closed market handling, wide-spread warnings, and cancellation rule parsing. This is exemplary transparency.

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

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

The description is lengthy but well-structured with labeled sections (CLASSIFIERS, FAN-OUT EXAMPLES, etc.) and front-loaded purpose. Every sentence adds value for an agent, covering many edge cases without redundancy. Given the tool's complexity, the length is justified 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 multifaceted nature (resolving markets, fanning out to data sources, returning evidence packets), the description is remarkably complete. It covers match confidence, parent events, news fallbacks, safety mechanisms, closed markets, wide spreads, and cancellation rules. No output schema exists, but the response shapes are well-documented.

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 enriches each parameter: explains market accepts slug/URL/text and gives examples; clarifies depth defaults and trade-offs; describes include_raw with size implications. This adds practical guidance beyond the schema descriptions.

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

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

The description clearly states the tool's purpose: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies the verb (research), resource (Polymarket bet), and unique capability (one-call comprehensive data pull). The examples and classifier list distinguish it from sibling tools like polymarket_edges or polymarket_arbitrage.

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

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

The description explicitly advises use for questions like 'should I bet on X', 'what does the data say about Y', or 'is there edge in Z'. It includes warnings to inspect match confidence and mentions illiquid markets. However, it does not compare directly to sibling tools or state when not to use it, which would be helpful.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds contextual details: results sorted by primary metric, returns paired data with citation URIs, handles off-calendar fiscal years for companies, and replaces multiple sequential lookups. No contradictions.

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

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

The description is concise yet comprehensive. It front-loads the purpose with example phrases, then efficiently covers data sources, sorting, output format, and edge cases. Every sentence adds value, and it avoids redundancy with the schema.

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

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

Given no output schema, the description adequately explains what is returned (paired data + citation URIs). It covers entity types, parameter constraints, data sources, sorting behavior, and special handling (off-calendar fiscal years). The tool is complex but thoroughly 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% with both parameters described. The description adds significant meaning: for type='company' it specifies data from SEC EDGAR/XBRL including revenue, net income, cash, debt; for type='drug' it specifies FAERS, FDA, trial counts. It also clarifies that values are tickers/CIKs for companies and names for drugs, and the min/max constraints.

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 side-by-side comparison of 2-5 entities (companies or drugs) with specific data sources. It provides example natural language phrases and explicitly distinguishes from single-entity lookups by stating 'ALWAYS PREFER over sequential single-pack lookups', effectively differentiating from siblings like entity_profile.

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

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

The description explicitly says when to use the tool (comparison queries like 'compare X and Y', 'rank these companies') and what to prefer it over ('sequential single-pack lookups'). It also explains the behavior for each entity type and the constraints on the values parameter.

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, and non-destructive hints, and the description adds substantial behavioral context beyond that: it explains the parallel decomposition, gaps[] for unanswered facets, contradictions[], hop fields, citation_uri resolvability, semantic excerpting, and expected latency (15-90s). This enriches the agent's understanding of how results are produced and validated.

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

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

The description is long but information-dense and well-structured, with clear sections for account requirements, use cases, comparisons to alternatives, and depth-specific behavior. Every sentence adds value, though the length is borderline for a very verbose description. It front-loads the most critical account requirement and alternative tool guidance.

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

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

Given the tool's complexity (5,529 tools, parallel routing, multiple depth levels, gaps/contradictions) and lack of output schema, the description is remarkably complete. It covers prerequisites (account tiers), expected latency, return contents (evidence, confidence, source, fetched_at, citations), edge cases (empty gaps for non-catalog topics), and how to interpret results (hop field, citation_uri).

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, but the description adds significant semantic value by explaining what 'depth' levels actually do (quick=3 facets, standard=5 with gap recovery, thorough=8 with iterative leads) and clarifying that 'question' is meant to be broad/multi-part. This goes beyond the schema by providing operational meaning.

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

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

The description clearly states the tool performs grounded multi-source research across structured data sources in one call, with a specific verb ('research'), resource ('Pipeworx's 1455 STRUCTURED data sources'), and scope ('broad/multi-part questions'). It also distinguishes itself from sibling tools by explicitly contrasting with ask_pipeworx for single lookups and news topics.

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

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

The description provides explicit guidance on when to use this tool vs alternatives: use ask_pipeworx for single lookups or breaking/current-news topics, and use deep_research for broad/multi-part questions over structured data. It also mentions account requirements and depth tiers, giving clear context for selection.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds that it returns top-N tools with full schemas and curated examples, and that each result is ready to call directly. This fully characterizes 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, starting with a clear one-liner and then expanding. It is slightly lengthy but every sentence adds value (lists domains, explains return format, provides usage guidance). Could be marginally tighter but remains efficient.

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

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

Given the complexity (many siblings, no output schema), the description fully describes the return value (top-N tools with names, descriptions, schemas, examples) and how to use it. It is complete for a discovery tool.

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

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

Schema coverage is 100%, so baseline is 3. The description adds clarifying context: explains aliases (task, q, search, description) and provides concrete examples of natural language queries (e.g., 'look up FDA drug approvals'). This adds meaning beyond the schema.

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

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

The description clearly states the purpose as 'Find tools by describing the data or task' and lists many specific domains (SEC filings, FDA drugs, etc.). It distinguishes from sibling tools by framing itself as a discovery tool, not for answering a single query.

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

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

Explicitly states 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' This provides clear when-to-use guidance and implies alternatives for direct answers. Also provides example task descriptions.

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 and non-destructive. Description adds significant context: sources (SEC, XBRL, USPTO, news, GLEIF), parallel execution, return fields, and patent sunset behavior. No contradiction.

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

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

The description is comprehensive but front-loaded with examples and usage guidance. Every sentence contributes, though minor redundancy in parameter descriptions could be trimmed.

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

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

For a composite tool with no output schema, the description thoroughly lists all return fields (cik, filings, fundamentals, patents, news, LEI) and data sources, making the tool's behavior fully predictable.

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

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

Schema coverage is 100% with clear descriptions for both parameters. Description reinforces the distinction between ticker and CIK and repeats that names are unsupported, adding value by linking to resolve_entity.

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

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

The description uses specific verbs and resources (full cross-source profile) and distinguishes from sibling tools like resolve_entity by explicitly stating names are not supported. Examples cover a wide range of user intents.

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 prefer this tool over chaining individual lookups and when to use resolve_entity first. Also notes patents soft-fail pending reactivation.

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

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

Annotations already mark the tool as read-only, idempotent, and non-destructive. The description adds valuable behavioral details: returns currently in-force wording, forgiving citation input, and behavior for part vs. section queries. This goes beyond the annotations.

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

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

The description is somewhat long but every sentence adds value: core purpose, examples, coverage, and disambiguation from sibling tools. It is front-loaded with the essential verb-resource pair. Could be slightly trimmed without loss, but remains efficient.

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

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

For a simple tool with one parameter and no output schema, the description fully explains what is returned (full text or section list) and provides concrete examples. It covers the entire scope of Title 40 regulations, making it complete for any 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% for the single required parameter 'citation'. The description enriches it with examples of valid formats, including paragraph stripping, and clarifies that passing a whole part yields a section list. This adds significant meaning beyond the schema.

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

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

The description states it retrieves the full text of one EPA regulation by citation, listing examples like '40 CFR 261' and '§60.1'. It clearly distinguishes this regulation tool from data tools (epa-echo/epa-emissions), making its purpose unambiguous.

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

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

Explicitly tells when to use (for regulation text) and when not to (for EPA data, pointing to alternative tools). Also clarifies input flexibility and that passing a whole part returns a section list, leaving no ambiguity about appropriate usage.

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 and idempotent. Description adds return format details (citation, heading, excerpt, source URL) and notes 'Keyless', providing useful 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?

Well-structured with front-loaded purpose, use cases, and examples. Slightly verbose but each sentence adds value.

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

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

Given no output schema, description thoroughly covers return fields, domain (40 CFR), and keyless access. Includes examples and differentiates from data retrieval tools.

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

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

Schema covers both parameters with descriptions (100% coverage). Description adds examples and context but does not significantly enhance meaning beyond schema.

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

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

Description clearly states verb ('search'), resource ('EPA regulations'), and scope ('40 CFR'). Provides specific examples and distinguishes from sibling tools (epa-echo/epa-emissions).

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 ('what EPA regulations cover X') and when not to ('for EPA DATA use...'). Lists relevant topics and provides alternative tools.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, so the description's 'Delete' aligns but adds no new behavioral context beyond 'clear sensitive data,' which is more about usage context than behavior. No contradiction.

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

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

Two sentences, front-loaded with action and purpose. No wasted words. Very concise and structured.

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

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

For a simple destructive tool with one well-documented parameter and clear annotations, the description is fully adequate. No output schema needed.

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

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

Schema covers 100% of parameters with 'key' described as 'Memory key to delete.' Description only says 'by key,' adding no extra meaning beyond the schema. Baseline 3 for high coverage.

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

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

Description clearly states 'Delete a previously stored memory by key.' It identifies the verb (delete), resource (memory), and the identifier (key). It distinguishes from siblings 'remember' and 'recall' by mentioning them.

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

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

Provides explicit use cases: 'when context is stale, the task is done, or you want to clear sensitive data.' No explicit when-not-to-use or alternatives, but the context is clear and helpful.

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

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

Annotations already provide safety and idempotence hints. The description adds valuable workflow details (fetch, extract, emit) and output format, which are not evident from annotations alone. No contradiction.

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

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

The description is front-loaded with the core action, followed by a brief workflow and bullet-pointed use cases. Every sentence contributes meaning, with no redundancy.

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

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

Given the simple tool (2 params, safe, no output schema), the description covers purpose, workflow, output format, and use cases fully. It compensates for lack of output schema by describing the output as a text blob.

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

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

Schema coverage is 100% with both parameters already described. The description adds no new semantic information beyond reinforcing the URL parameter, so score is at baseline for high coverage.

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

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

The description uses a clear verb 'Generate' and specific resource 'production-ready llms.txt file for any URL', distinguishing it from sibling tools. It also lists concrete use cases, leaving no ambiguity about the tool's purpose.

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

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

The description provides clear use cases such as indexing a client's site or auditing a competitor, but does not explicitly state when not to use or compare to alternatives. The context is clear but lacks explicit exclusions.

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

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

Annotations already provide safety and idempotence cues. Description adds return field details and usage context. No contradictions.

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

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

Two sentences: first states purpose and return, second gives usage guidance. No fluff, front-loaded.

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

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

Sufficient for a simple list tool with one optional param. Return fields are enumerated. No missing critical 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 covers 100% of parameters, so description adds minimal value. The mention of 'active' aligns with default false for include_inactive.

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

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

Description clearly states verb (list), resource (subscriptions), scope (caller's active), and lists returned fields. It distinguishes from sibling tools like subscribe/unsubscribe.

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

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

Explicitly states when to use: to review monitoring before adding more or to find an id to cancel. Implicitly contrasts with subscribe/unsubscribe.

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

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

The description goes far beyond annotations, disclosing rate limits ('Rate-limited to 5 per identifier per day'), cost ('Free; doesn't count against your tool-call quota'), and the claim_token flow ('Filing without an account returns a claim_token; pass it back later... to read whether it was fixed'). It also explains the team's review process ('reads digests daily and signal directly affects roadmap'). No contradiction with annotations.

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

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

The description is a single well-organized paragraph that front-loads the core purpose, then flows through usage conditions, exclusions, message guidance, token mechanics, and rate limits. Every sentence adds necessary information with no filler or repetition, making it dense but 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 has 4 parameters, zero required, no output schema, and non-trivial behaviors, the description covers all critical aspects: return values (claim_token and status), rate limiting, scope restrictions, and message formatting. It leaves no major functional gap for an agent to make a correct call.

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?

While the schema covers all parameters, the description enriches them with usage context: it advises 'Describe the issue in terms of Pipeworx tools/packs — don't paste the end-user's prompt,' and gives a concrete syntax example for claim_token usage. It also clarifies how the 'type' field maps to real scenarios, which is more than the schema's enum definitions alone.

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

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

The description opens with 'Tell the Pipeworx team something is broken, missing, or needs to exist,' which immediately identifies the verb and resource. It clearly differentiates from siblings like ask_pipeworx or discover_tools by focusing on feedback submission, not information retrieval or tool discovery.

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

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

Explicit when-to-use guidance is given: 'Use when a tool returns wrong/stale data (bug), when a tool you wish existed isn't in the catalog (feature/data_gap), or when something worked surprisingly well (praise).' It also provides clear exclusions: 'ONLY for tools served by this Pipeworx connection... if the tool came from a different MCP server... file it with that server instead,' and suggests an alternative action for uncertain 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?

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

Four sentences, each earning its place: main purpose, three use cases, technical details. 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?

Single parameter, no output schema, but description fully covers usage, behavioral details, and parameter semantics. Complete for the tool's simplicity.

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

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

Schema has 100% coverage with enum for window. Description adds practical advice: shorter windows surface what's hot, longer show steady-state demand.

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

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

Clearly states it returns top tools, packs, and total call volume over a window. Verb 'Returns' and specific resources differentiate it from siblings like 'discover_tools'.

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

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

Explicitly lists three use cases (hot sources, canonical choice, alignment). No exclusion criteria or direct alternatives mentioned, but context is clear.

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

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

Annotations declare readOnlyHint=true and non-destructive; description reinforces this and adds details: scans top ~200 markets, uses Jaccard similarity, filters placeholders, and includes fill check logic. No contradictions.

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

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

Description is fairly long but well-structured with sections (SEMANTIC ANCHOR, PARTITION FILTER, FILL CHECK). Every sentence adds value, though some compression could be possible. Still, it remains clear and organized.

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

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

With no output schema, the description fully explains the response structure: opportunities[] fields, partition_check fields, and fill check details. It covers edge cases and practical usage, making it complete for agent decision-making.

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

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

Schema descriptions for both event and topic are clear, but description adds significant context: provides examples of slugs and seed questions, explains when to use each, and describes their effects in detail. Schema coverage is 100%, and description further enriches understanding.

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

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

Clearly states it finds arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. Distinguishes between modes (no args, event, topic) and differentiates from sibling tools like polymarket_fill_risk.

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

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

Explicitly tells when to use each mode: no args for trending scan, event for specific market, topic for cross-event scan. Recommends event mode and warns against trading when fill check shows realizable_edge_pp ≤ 0. Mentions alternative polymarket_fill_risk for custom sizing.

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

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

The description goes far beyond the annotations: details model families, edge calculation (edge_pp_net, Kelly fractions), 24h-move warning, caching at KV level, and why Fed bets are unreliable. Annotations are limited to readOnly, openWorld, idempotent, non-destructive — the description provides rich 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 dense but well-structured with clear segmentation (MODEL_DRIVEN, STRUCTURAL_ARBITRAGE, etc.) and parenthetical clarifications. While lengthy for an agent, the detail is justified given the complexity of the models and parameters.

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 is provided, but the description fully explains the response structure (by_segment, fed_candidates, diagnostics) and how to interpret results. It covers edge cases like empty segments and caching, making it complete for agent 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% with good descriptions. The description adds practical usage guidance (e.g., on slippage_pp: 'Bump for very thin partitions; drop to 0 if you have a smarter fill model') and explains the role of min_partition_leg_kelly for partition arbs, adding value beyond the schema.

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

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

The description explicitly states it scans Polymarket markets for opportunities where Pipeworx data disagrees with market price. It clearly distinguishes from siblings by its focus on edge discovery from multiple model families, contrasting with tools like polymarket_arbitrage or polymarket_edge_tracker.

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 the 'tradeable-edge knobs' (min_liquidity, max_spread_pp) and how to use diagnostics when segments are empty. It also explains caching and the exclusion of Fed bets. However, it does not explicitly contrast with sibling tools or state when not to use this tool.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds rich behavioral context: it explains the data source (daily snapshots), limits (60-day TTL, snapshot gaps mean no scan), that decay numbers are from daily closes not intraday, and the meaning of missing snapshot dates. This significantly adds value beyond annotations.

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

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

The description is long but front-loaded with purpose and response structure. Every sentence adds necessary information, especially since there is no output schema. Could be slightly tighter but appropriate for the complexity.

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

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

Given no output schema, the description comprehensively details the response: tracked[] with first_seen, trend, decay_pp_per_day; expired[] with lifespan_days; snapshot_dates[]. It also explains limits and interpretation of gaps. Complete for a complex tool.

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

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

Schema coverage is 100%, so baseline is 3. The description adds context beyond schema: 'lookback' and 'snapshot family' terms, defaults, and a max of 30 (schema says clamp 2-30, minor omission of lower bound). This enhances 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 clearly states the tool's purpose: 'Edge persistence and decay telemetry built from daily polymarket_edges snapshots' and answers the specific question 'how long has this edge existed and is it shrinking?'. It distinguishes itself from sibling tools by noting it analyzes persistence over time, unlike raw snapshot tools 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?

The description explains when to use the tool with the example that a fresh wide edge differs from a 3-week-old one. It provides context for interpreting results but does not explicitly state when not to use or give alternative tools.

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

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

Annotations already declare readOnly, openWorld, idempotent, non-destructive. Description adds rich behavioral detail: walking the ladder, returning verdicts (clean|degraded|cannot_fill), basket risks, forced directional risk, and the dominant loss mode. No contradiction.

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

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

Two well-structured paragraphs: first sentence states purpose, then separate sections for single-market and basket modes. Every sentence adds essential information; no redundancy or 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?

Although no output schema, description enumerates all return fields for both modes (e.g., top_of_book, vwap_fill_price, capture_ratio, thin_legs) and covers input conditions, risks, and defaults. Fully adequate for effective 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 coverage is 100%, but description adds value beyond schema: explains size_usd as settlement notional for basket, side auto-detection, clamp range (10–1,000,000), and per-leg fill details. Baseline 3, plus 1 for extra context.

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

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

Clearly states verb-phrase 'Realizable-vs-theoretical edge check against live CLOB order-book depth' and distinguishes between single-market and basket modes, differentiating it from sibling tools like polymarket_arbitrage and polymarket_edges.

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

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

Explicitly advises using this tool before acting on arbitrage or edge signals above ~$500, explains why (partial fills convert arb to directional risk), and specifies required modes (market or event) with defaults.

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 (readOnly, idempotent) are complemented by detailed behavioral context: compatibility_warning conditions, temporal alignment, skipped types/subtypes. No contradiction.

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

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

Long but all sentences add value. Could be slightly more structured, but front-loaded with key info and 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?

No output schema, yet description thoroughly explains response fields (leg-by-leg prices, spread[], safety fields). Complete for a complex tool.

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

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

Schema covers all 3 parameters fully. Description adds value by explaining the two modes and override behavior. Baseline 3, plus extra context for explicit parameters.

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

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

Clearly states it computes cross-venue spread between Kalshi and Polymarket for the same question. Two modes are explained. Distinguishes from sibling tools that focus on single venues.

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

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

Explicitly describes when to use (cross-venue comparison), explains the two modes, and warns that most pre-mapped topics return compatibility warnings, guiding the agent on limitations.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds context on how the retrieval works (omit key to list all keys, scoping to identifier, and pairing with remember/forget). No contradictions.

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

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

Three sentences that front-load the action, follow with use cases and alternatives, and end with scoping. Every sentence adds value; no fluff.

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

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

Given a single parameter, high schema coverage, and clear annotations, the description covers purpose, usage, and behavior. It lacks return format details, but without an output schema, this is acceptable. It could mention pagination or limits for listing many keys.

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

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

Schema coverage is 100% with a clear parameter description. The description reinforces that omitting the key lists all keys, which is already in the schema. It adds minimal new meaning beyond the schema.

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

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

The description clearly states the verb (retrieve/list), resource (saved memories), and distinguishes from sibling tools (remember, forget). It provides concrete use cases (target ticker, address, notes) and explicitly contrasts with the alternative of re-deriving context.

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

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

The description explicitly says when to use the tool (look up stored context) and mentions sibling tools for complementary actions (save, delete). It also notes scoping to the agent's identifier, but does not explicitly state when not to use it, which would elevate the score to 5.

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

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

Annotations already indicate read-only, idempotent, non-destructive. Description adds valuable context: explains state change with mark_read, polling suitability, and feed persistence. 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 concise, front-loaded sentences. Each sentence adds distinct value: purpose, return fields, filtering, state management, polling advice, 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?

Describes return fields and filtering, but lacks explicit ordering (though 'most recent' implies recency). No output schema, but description covers key behavioral aspects. Slight gap in pagination or sorting, but adequate for the tool's complexity.

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

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

Schema covers 100% of parameters with descriptions. Description adds examples (e.g., 'sec_8k' for type, ISO timestamps) and explains the effect of mark_read, going beyond the schema's basic descriptions.

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

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

Clearly states it pulls fired events from the subscription feed, specifies returned fields (source, citation_uri, payload), and distinguishes from sibling tools like list_subscriptions and subscribe. The mention of an alternative endpoint for scripts/dashboards further clarifies its use case.

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

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

Provides explicit filtering options (type, since) and state management (mark_read). Mentions polling works and gives an alternative REST endpoint, indicating when to use the tool vs. other methods. Lacks explicit when-not-to-use, but the context is clear enough.

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

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

Annotations already provide readOnlyHint, idempotentHint, and openWorldHint. The description adds significant context: it fans out to multiple sources (SEC EDGAR, GDELT/GNews with fallback, USPTO), explains rate-limiting behavior, and notes API sunset. 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 slightly long but well-structured. It starts with example queries, then explains behavior, parameter details, and ends with sibling comparison. Every sentence adds value; length is justified given 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?

The tool has 3 required params and no output schema, but the description explains return fields (changes[], total_changes count, citation URIs) and covers behavior across sources, fallbacks, and limitations. It provides a complete picture for agent usage.

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

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

Schema coverage is 100%, baseline 3. The description adds substantial meaning: explains `since` accepts ISO or relative shorthand with examples and suggests typical usage ('30d'). It clarifies `type` is limited to 'company' and `value` accepts ticker or zero-padded CIK.

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 the last N days/weeks/months in ONE parallel call' with example queries like 'What's new with X'. It explicitly distinguishes itself from the sibling tool entity_profile.

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

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

The description gives explicit when-to-use guidance with natural language examples (e.g., 'latest on Y', 'updates on Acme') and explicitly directs users to entity_profile for static profiles. It also explains fallback behavior and soft-fail conditions.

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 behavioral context beyond the annotations, such as scoping by identifier, persistence for authenticated users, and 24-hour retention for anonymous sessions. However, it does not disclose potential limits like storage quotas or rate limits, which could be relevant.

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 moderately concise at four sentences, with the purpose stated upfront. It could be slightly more condensed, but it avoids unnecessary detail. Every sentence adds value.

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

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

Given the tool's simplicity, the description adequately covers key aspects: purpose, usage, scoping, and persistence. However, it does not describe the return value or error handling, which would be helpful for an agent to interpret results.

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

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

The input schema has 100% coverage with descriptions for both parameters. The tool description does not add significant new semantic information beyond the schema's examples, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Save data the agent will need to reuse later.' It specifies the verb 'save' and the resource 'data,' with examples of use cases. It also distinguishes itself from siblings by mentioning 'recall' and 'forget' as complementary tools.

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

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

The description explicitly tells when to use the tool ('when you discover something worth carrying forward') and provides concrete examples. It also gives guidance on alternatives by stating 'Pair with recall to retrieve later, forget to delete,' which helps the agent choose between related 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?

Beyond the annotations (read-only, idempotent), the description discloses that the call 'cascades through several lookup endpoints internally,' that 'LEI/FIGI enrichment degrades gracefully' if external sources are unavailable, and that unresolved identifiers are explicitly listed under `unresolved` rather than omitted. These are meaningful behavioral traits not captured by the annotations.

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

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

Though lengthy, the description is front-loaded with example queries that help pattern-matching, then structured by supported types. Every sentence earns its place: examples, purpose, type details, source labeling, fallback behavior, and lifecycle context (replaces manual lookups). No fluff or repetition.

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

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

Given no output schema, the description thoroughly explains what the tool returns: identifier fields for companies (CIK, ticker, LEI, FIGI), drugs (RxCUI, ingredient, brand), source labeling, unresolved handling, and graceful degradation. It also mentions the citation format for drugs. This is complete for a tool with this complexity.

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

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

The schema already covers both parameters 100%, but the description adds substantial meaning: it elaborates on the 'company' type with details about CIK/ticker/LEI/FIGI sources and ownership hierarchy, and the 'drug' type with RxCUI/brand/ingredient specifics. It also gives value examples (ticker, CIK, brand name). This goes beyond simple schema descriptions.

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

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

The description opens with concrete examples of user queries ('What's the ticker for…') and then states the core purpose: 'resolve a user-spoken NAME to the canonical/official identifiers other tools require as input.' This is a specific verb+resource combination (resolve name → identifiers), and it clearly differentiates from siblings like entity_profile or compare_entities by focusing on ID lookup rather than profiles or comparisons.

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 FIRST whenever you have a name but need an ID.' It also explains the tool replaces 2-3 manual lookups, indicating the recommended scenario. However, it does not explicitly say when NOT to use it (e.g., if you already have an ID) or name alternative tools, so it's clear context but lacks explicit exclusions/alternatives.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint as false, which is consistent with the description. The description adds behavioral context: it internally calls ai_visibility_check for each entity, treats the first entity as the subject, 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?

The description is three sentences, each serving a clear role: purpose, mechanism, and use case/output. No filler words or redundancy. It is front-loaded with the main action and remains highly readable.

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 (4 params, no output schema, but strong annotations), the description explains the output format (ranked list with score, confidence, signal density) and the special treatment of the first entity. It lacks details on error handling or limits but is sufficient for typical usage.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value beyond the schema for the 'entities' parameter by specifying that the first entry is treated as the 'subject' for narrative. This semantic nuance helps agents correctly structure the input. Other parameters are briefly mentioned but not elaborated; still, the addition 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?

The description clearly states the tool's purpose: 'Compare AI visibility across multiple entities side-by-side.' It specifies the verb (compare), resource (AI visibility), and actions (probes, ranks, surfaces). It differentiates from sibling tools like ai_visibility_check (single probe) and compare_entities (generic comparison), making its unique value evident.

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

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

The description provides a clear use case: 'Useful for competitive AI-marketing audits' with an example question. It implies that for a single entity, one should use ai_visibility_check (since this tool probes multiple). However, it does not explicitly state when not to use this tool or list alternatives, which would have earned a 5.

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

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

Annotations already indicate read-only and idempotent behavior. The description adds critical behavioral details: composite fan-out to two services, graceful partial degradation, potential 5-30s delay on first bundlephobia measurement, and the sources_failed field. No contradictions.

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

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

The description is detailed but well-structured: purpose first, then return format and edge cases. Every sentence adds utility; however, minor trimming could improve conciseness without losing information.

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

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

Despite no output schema, the description fully explains return values (summary block with fields, advisories, links, alternative versions) and error handling. Given the tool's moderate complexity, this provides complete contextual information for agent invocation.

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

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

Schema coverage is 100% with descriptions for both parameters. The description enhances understanding by noting scoped package syntax acceptance (@types/node) and version defaulting to latest. This adds value beyond the schema.

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

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

The description explicitly states the tool's purpose: a composite check for adding npm packages, covering license, advisories, version history, and bundle size analysis. It distinguishes from siblings by specifying NPM ecosystem only and referencing deps.dev directly for other ecosystems.

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

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

The description provides explicit when-to-use guidance: 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me".' It also notes exclusion of other ecosystems and directs to deps.dev:version directly for PyPI, Maven, etc., making sibling differentiation clear.

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

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

Annotations already indicate readOnly, openWorld, idempotent, non-destructive properties. The description adds significant behavioral details: embeddings model (BGE-base-en), windowing (500-char overlapping), cap (200K chars with truncation flag), and return format (offsets, similarity scores). No contradiction.

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

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

Two well-structured paragraphs: first explains purpose and usage, second provides technical details. Every sentence adds value, no fluff. Front-loaded with the core action.

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 describes return elements (passages, character offsets, similarity scores). Covers limitations (200K chars, truncation). Pairs with sibling tool. No gaps given the complexity.

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

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

Schema coverage is 100%, but the description adds context beyond definitions: explains that 'text' should be already fetched, gives examples for 'query', and clarifies default and range for 'limit'. Provides behavioral context like truncation.

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 semantic search inside a fetched record, using specific verbs like 'search' and 'returns'. It distinguishes from siblings like ask_pipeworx_grounded by explaining the pairing. References to SEC 10-K and articles make the purpose concrete.

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 the record is too big to cram into the prompt'. Provides context on saving context and returning only relevant passages. Mentions pairing with ask_pipeworx_grounded, guiding the AI on 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 indicate mutation (readOnlyHint false) and idempotency (idempotentHint true). The description adds substantial behavioral context: authentication requirements, supported event types with example parameters, delivery channel mechanics (email validation, SMS verification with rate cap, webhook HMAC signing and auto-disable on failures), which goes well beyond the annotations.

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

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

The description is well-structured, front-loading the core purpose and then providing details on requirements, types, and delivery. At ~150 words, it is appropriately sized for the tool's complexity, with no wasted sentences. A slightly more concise treatment of delivery options could bump it to 5.

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 complex tool with multiple subscription types and delivery options, the description covers most behavioral aspects thoroughly. However, it omits details about the return value structure (beyond 'new subscription id') and does not mention error scenarios or rate limits beyond the SMS cap. The absence of an output schema makes this omission noticeable.

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

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

The input schema covers all 3 parameters with 100% coverage, but the description greatly enriches each parameter: 'type' gets context for each enum value (e.g., 'sec_8k: 8-K filings matching ticker + item codes'), 'params' gets type-specific examples and rules, and 'delivery' gets detailed behavioral descriptions including verification requirements and webhook signing. This adds significant value beyond the schema.

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

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

The description clearly states 'Create a proactive monitoring subscription to a live-data event stream' and 'Returns the new subscription id,' with a specific verb (create) and resource (subscription). This distinguishes it from sibling tools like list_subscriptions (list) and unsubscribe (delete).

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 requires a Pipeworx OAuth account and notes that anonymous/BYO cannot persist subscriptions, providing a clear prerequisite. While it does not explicitly contrast with alternatives, the purpose itself implies when to use this tool (to create a subscription) versus listing or deleting existing ones via siblings.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds valuable context: that the tool returns example questions drawn from a live catalog of thousands of tools, and that it can be called with or without a topic parameter. This goes beyond the annotations without contradicting them.

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

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

The description is well-structured with a list of acceptable variations at the start, followed by a clear explanation of output and usage. It is somewhat long but every sentence adds value; could be slightly more condensed by removing the full category list, but the list is informative.

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

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

Given the simplicity of the tool (one optional parameter, no output schema), the description provides complete context: what the tool does, when to use it, what input to provide, and what output to expect. It also mentions meta-tools, fully covering the onboarding use case.

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 'topic' parameter. The description adds meaning by listing example values (finance, pharma, etc.) and clarifying that omitting the topic returns a cross-category spread, while providing one focuses on a specific area. This adds functional understanding beyond the schema.

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

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

The description clearly states that this tool is the onboarding entry point for an agent to learn what questions to ask Pipeworx. It specifies the output (category-bucketed example questions with exact tool+argument shape) and distinguishes itself from sibling tools like ask_pipeworx and entity_profile by its role as a discoverability aid.

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 for you, or to learn how to call the meta-tools'. It also explains when to call with no arguments vs. with a specific topic, providing clear context for when to use this tool over alternatives.

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

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

The description discloses that the row is deactivated (not deleted) and historical events remain available, adding crucial behavioral context beyond the annotations. 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?

Two sentences that are efficient and front-loaded: the first covers action and constraint, the second explains the behavioral effect. No unnecessary words.

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

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

With one parameter, no output schema, and comprehensive annotations, the description fully covers what the agent needs: ownership enforcement, soft-delete behavior, and parameter usage. 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?

The schema has 100% coverage, and the description adds meaning by stating that the id is a 'Subscription id (uuid) returned by subscribe', which helps the agent understand the parameter's origin.

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

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

The description clearly states the action ('Cancel a subscription by id') and the resource ('subscription'), which distinguishes it from sibling tools like 'subscribe' and 'list_subscriptions'.

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

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

The description specifies ownership enforcement ('you can only cancel your own subscriptions'), providing clear context for when to use the tool. It does not explicitly mention alternatives, but the constraint 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 read-only, open-world, idempotent, non-destructive, and the description adds rich behavioral context: the two routing paths, return format (verdict list, citation, reasoning), and crucial semantics for could_not_verify vs unsupported, including verification_error details. This goes well beyond the annotations and prevents misinterpretation.

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

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

The description is long but front-loaded with trigger phrases and structured logically: usage, routing, return values, then warnings. It is dense with necessary information for a complex verify tool; the 'Replaces 4–6 sequential calls' note adds efficiency context. Some minor redundancy exists (e.g., restating verdict types), but overall it earns its length.

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

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

For a tool with 2 params, no output schema, and strong annotations, the description fully covers: purpose, routing logic, output format, verdict definitions, error semantics, and the benefit over sequential calls. Nothing critical is missing for an agent to safely and effectively invoke it.

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

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

Schema coverage is 100% for both parameters, providing solid baselines. The description adds extra meaning beyond schema by explaining tolerance_pct overrides the implied tolerance and its default cap, and shows examples for claim. This is a small but meaningful increment over 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 identifies the tool as a natural-language claim verification tool with a specific verb ('check'), resource ('factual claims'), and scope ('against authoritative sources'). It includes multiple trigger phrases and distinguishes from siblings by describing the company-financial fast path vs. grounded pipeline, making it unmistakable when to invoke.

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

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

Explicit 'Use whenever the agent needs to check whether something a user said is factually correct' sets a clear condition. It also implies exclusions by contrasting with the grounded pipeline and noting it replaces 4–6 sequential calls, though it doesn't explicitly mention alternative tools or 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.