Paraguay Dncp

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds valuable behavioral context: it scores 0-100, requires a BYO API key for Anthropic (with cost implication), and returns per-model details plus a combined view. No contradictions.

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

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

The description is concise and well-structured. It front-loads the main action, explains the default, the optional API key, and the return format—all in a few sentences. Every sentence earns its place.

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

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

Despite lacking an output schema, the description fully explains the return structure (per-model score, confidence, signals, raw_response, plus combined view). Given the moderate complexity and high schema/annotation coverage, the description is complete and sufficient.

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

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

Schema coverage is 100% with all parameters described. The description adds value by explaining the default model, the purpose of '_apiKey' (pay Anthropic directly), and the disambiguation role of 'context'. This goes 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?

The description clearly states the tool probes LLMs for what they know about a business or topic and scores visibility (0-100) per model. The verb 'probe' and resource 'LLMs' are explicit, and it distinguishes from sibling tools like 'scan_competitor_ai_presence' by focusing on multi-model visibility scoring.

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

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

The description provides clear usage context: 'AI-marketing audits, pre-launch brand checks, competitive monitoring.' It explains default model (free) and when to provide an API key. However, it does not explicitly state when not to use this tool or list alternatives.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds valuable context: routing logic, argument filling, stable citation URIs, 'works on every tier', and 'one fast call'. No contradiction between description and 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-loads the most critical guidance ('PREFER OVER WEB SEARCH') and each sentence delivers actionable information: domain lists, trigger phrases, examples, and alternatives. It is dense but not wasteful, though the single-paragraph structure could be slightly more scannable.

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 complex meta-tool that routes to thousands of sub-tools, the description is remarkably complete: it covers routing behavior, argument filling, citation output, tier availability, and specific escalation paths to siblings. It also addresses edge cases like breaking news and free-tier accounts, making it self-sufficient despite lacking an output schema.

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

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

Schema coverage is 100% with all six parameters documented, and all but 'question' are aliases. The description enriches semantics with concrete examples like 'current US unemployment rate' and 'Apple's latest 10-K', clarifying the expected natural-language input beyond the schema's generic 'Your question or request' phrasing.

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

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

The description clearly states the tool's function: it routes factual questions to the right one of 5,566 tools across 1,462 verified sources and returns structured answers with pipeworx:// citation URIs. It distinguishes itself from siblings by explicitly labeling itself the 'default entry point' and 'START HERE', and contrasts with ask_pipeworx_grounded and deep_research.

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

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

Provides explicit when-to-use guidance, instructing agents to prefer it over web search for a broad list of domains (SEC filings, FDA data, FRED, etc.) and trigger phrases like 'what is', 'look up', 'find', 'current'. It names specific alternatives for escalation: ask_pipeworx_grounded for grounded single answers, deep_research for multi-part fan-out, and clarifies breaking-news coverage.

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

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

The description adds useful behavioral context beyond the strong readOnlyHint/openWorldHint/idempotentHint annotations: this is a live experimental router, results are compared against the stable router to inform merges, and it remains a fully working router despite being beta. It does not contradict any annotations.

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

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

The description is dense but every sentence carries identification, current-state, or usage information. The opening phrase "Beta version of ask_pipeworx" immediately anchors the tool, and the details about candidate status, routing comparison, and full functionality are each relevant. Slightly more verbose than strictly necessary, but still efficient.

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

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

The description fully situates this tool in the beta-vs-stable context: what it is, when it differs, when it exactly matches ask_pipeworx, and why results matter (merge decisions). Although there is no output schema, the description references an identical response shape to ask_pipeworx, providing enough context for an agent to use it correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no parameter detail beyond saying it accepts the same arguments as ask_pipeworx, but every parameter is fully documented in the schema, including alias relationships.

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

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

The description clearly identifies this as "Beta version of ask_pipeworx" and an "identical universal router" with the same 5,566 tools, arguments, and response shape. It distinguishes itself from the stable sibling ask_pipeworx by emphasizing it exists to test candidate routing improvements.

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

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

Explicit usage guidance is provided: "Use it exactly like ask_pipeworx when you want the newest routing." It also clarifies when no candidate is active, the tool currently matches ask_pipeworx exactly, and that it is an experimental edge rather than a fallback or non-functional variant.

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

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

Annotations already indicate readOnly, idempotent, and openWorld hints, but the description goes far beyond by detailing the return structure ({answer, evidence, confidence, source, fetched_at, refusal_reason:null}), explicit refusal reasons (not_in_source, no_tool_match, etc.), and the extra LLM call cost. This adds substantial behavioral context not present in annotations.

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

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

The description is front-loaded with the key concept, then efficiently explains behavior, return format, and usage trade-offs. Each sentence adds value without redundancy or fluff, making it well-structured for its complexity.

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

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

No output schema is provided, so the description must explain return values—it does, listing success fields and refusal reasons. It also covers usage scenarios, cost implications, and how it routes to other tools. This makes the description complete for the tool's complexity.

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

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

Schema coverage is 100% and all 6 parameters are aliases for a single 'question' field, fully described in the schema. The description does not add parameter-specific detail, but the baseline of 3 applies because the schema handles parameter semantics completely.

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 'Hallucination-resistant answer mode for high-stakes reads' and explains it extracts answers using ONLY the tool result. It distinguishes itself from the sibling 'ask_pipeworx' by adding groundedness and evidence, making its purpose specific and unique.

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

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

Explicitly states when to use: 'whenever an answer will be quoted, cited, or acted on' with examples like financial verdicts and legal claims. It also contrasts with the alternative: 'Costs one extra LLM call vs ask_pipeworx — prefer ask_pipeworx for casual lookups,' providing clear when-not-to-use guidance.

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

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

Annotations declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds extensive behavioral context: fan-out parallelism, resolver contract with confidence levels and alternatives, parent event extractor, news fallback mechanisms, safety short-circuits (low_confidence_match, market_closed_or_inactive), wide-spread tradeability, and resolution-rule risk. These details go far beyond annotations and disclose all behavioral traits.

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 front-loaded with the most critical purpose and usage. Every section adds value given the tool's complexity, but it could be more structured (e.g., bullet points) for readability. It is not excessively verbose, but conciseness could be improved slightly.

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

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

With no output schema, the description thoroughly explains all response fields: result.market (bid/ask, liquidity, price change), result.analysis (model probability, edge, kelly fraction, 24h move warning), result.evidence (keyed by source), resolver contract (confidence, alternatives, suggestions), parent event (top legs), news fields (fallback info), and status codes (low_confidence_match, market_closed_or_inactive). It also covers resolution-rule risk and tradeability. Everything an agent needs to interpret the response is included.

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%, but the description adds significant value: it explains the three input formats for 'market', the meaning of 'depth' (quick vs thorough with examples), and the purpose of 'include_raw' (summarized vs full payloads). It also notes defaults and behavioral implications, enhancing the schema's documentation.

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

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

The description clearly states the tool's purpose: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies input types (slug, URL, question text) and output (evidence packet + market-vs-model comparison). The detailed classifiers, fan-out examples, and response shapes 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?

Explicit usage guidance is provided: 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z".' The description also explains when to inspect certain fields (e.g., market_match_confidence, parent_event) and caveats for low-confidence resolutions, closed markets, wide spreads, and resolution-rule risk. It implicitly differentiates from siblings by focusing on comprehensive single-bet research.

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

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

The description adds significant context beyond annotations, including data sources (SEC EDGAR/XBRL, FAERS), sorting by primary metric, and return format (paired data + citation URIs). No contradictions with annotations.

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

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

The description is well-organized with examples upfront, but slightly verbose. Every sentence adds value, though could be trimmed without loss of 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 lacking an output schema, the description fully explains return types, sorting, and efficiency gains. It covers both entity types thoroughly and addresses edge cases like fiscal year handling.

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

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

Schema coverage is 100%, and the description enriches parameter meaning by explaining expected formats (tickers/CIKs for companies, drug names) and constraints (2-5 items). The type parameter is clearly differentiated.

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

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

The description clearly states the tool performs side-by-side comparison of 2-5 companies or drugs, specifying data sources for each type. It includes example queries and distinguishes from sequential lookups, making the purpose unambiguous.

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

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

Explicitly advises to prefer this tool over sequential single-pack lookups, provides example natural language queries, and clarifies behavior for fiscal years. The guidelines are comprehensive and actionable.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description discloses account/plan requirements, parallel decomposition across 5,566 tools, the return packet structure, the never-invented gap[] guarantee, depth-dependent retry/contradiction passes, semantic excerpting, citation_uri resolvability, and expected latency. This is exceptionally transparent and adds critical trust details.

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

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

The description is long but dense, front-loading the critical account/paywall caveat and the alternative tool. Each sentence adds a distinct behavioral or usage detail, and the structure flows logically from access→purpose→usage→limitations→depth→return invariants→latency, though a few details are reiterated from 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?

With no output schema, the description fully characterizes the return findings packet (evidence, confidence, source, fetched_at, citation, gaps[], contradictions[], hop, citation_uri), covers prerequisites, alternatives, limitations, depth behavior, and timing. For a tool of this complexity, the description is complete and answers likely agent questions.

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

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

The input schema already fully documents both parameters (question and depth), including the enum meanings and behavioral details per depth level. The description adds the paid-plan constraint for 'thorough' and latency expectations, providing some extra semantic value, but most parameter meaning already resides in the schema.

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

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

The description explicitly states the tool performs grounded multi-source research across 1,462 structured data sources in one call, decomposing questions into facets and routing them to parallel tools. It clearly distinguishes itself from siblings by stating 'this is NOT open-web search' and contrasting with ask_pipeworx, making the purpose unmistakable.

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

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

The description provides explicit when-to-use guidance: best for broad/multi-part questions over structured data, while single lookups and breaking/current-news topics should use ask_pipeworx. It also specifies the account requirement and the alternative if not signed in, giving an agent a clear decision procedure.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable context beyond annotations: it explains that results include 'names, descriptions, and full input schemas (with curated examples)' and that 'each result is ready to call directly, no second schema lookup needed.' This clarifies the non-destructive, convenient nature of the tool.

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

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

The description is three sentences long, front-loaded with the primary purpose. The middle sentence contains a long list of domains, which, while informative, slightly reduces conciseness. Overall, every sentence adds value, but the list could be more succinct.

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?

There is no output schema, so the description compensates well by stating the output format: 'top-N most relevant tools with names, descriptions, and full input schemas.' It also mentions default limit (20) and max. The tool is a discovery meta-tool, and the description covers its behavior adequately. A minor gap: it does not explicitly state that it searches only among available tools (not external data), but that is implied.

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

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

Schema description coverage is 100%, so the schema already documents each parameter thoroughly. The description enhances by providing natural language usage context and examples (e.g., 'analyze housing market trends', 'look up FDA drug approvals'), which helps an agent understand semantic intent beyond parameter names.

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

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

The description opens with 'Find tools by describing the data or task,' clearly stating the tool's purpose as a discovery mechanism. It lists numerous specific domains (SEC filings, financials, FDA drugs, etc.) and contrasts with sibling tools like ask_pipeworx or entity_profile, which are specialized data retrieval 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 directs to 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' It also specifies when to use: 'browse, search, look up, or discover what tools exist for...' This provides strong context for both when and when not to invoke the tool.

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

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

The description discloses behavioral traits beyond annotations: it fans out across multiple sources, specifics return fields (CIK, filings, fundamentals, patents, news, LEI), and notes the USPTO PatentsView API sunset (soft-fail). No contradiction with annotations (readOnly, openWorld, idempotent, non-destructive).

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

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

The description is dense but front-loaded with examples and key guidance. Every sentence adds value, though slightly long. Well-structured for 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?

Given no output schema, the description comprehensively details return values (cik, recent_filings with URIs, fundamentals sorted, patents fallback, news, LEI) and constraints (ticker/CIK only, patents sunset). Fully adequate for 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% (both parameters fully described). The description repeats parameter info but adds no new semantic meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'full cross-source profile of a US public company in ONE parallel call'. It provides many example queries and lists data sources and returned fields. It also distinguishes from sibling tools like 'resolve_entity' by specifying that names are not supported.

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

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

Explicit guidance is given: 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view.' It also states when not to use (names not supported) and directs to 'resolve_entity' first. Clear and actionable.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, so the safety profile is clear. The description adds little beyond confirming deletion, but 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?

Two sentences, front-loaded with action and context, no wasted words.

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

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

For a simple tool with one parameter and no output schema, the description covers usage, when to use, and pairing with siblings, making it fully complete.

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

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

Schema coverage is 100% with one parameter 'key' described as 'Memory key to delete'. The description does not add extra semantic detail, so baseline 3 is appropriate.

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

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

The description uses the verb 'Delete' and specifies the resource 'memory by key', clearly distinguishing its purpose from siblings like 'remember' and 'recall'.

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

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

It explicitly states when to use the tool: 'when context is stale, the task is done, or you want to clear sensitive data', and mentions pairing with 'remember' and 'recall'.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds value by detailing the process: fetches the page, extracts title/description/key links, and emits standard markdown format. No contradiction with annotations.

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

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

The description is concise (four sentences), front-loads the main action, and includes output format and use cases. Every sentence is informative 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 two simple parameters, no output schema, and comprehensive annotations, the description sufficiently explains input, process, and output. It lacks error handling details but is complete enough for a non-critical read-only tool.

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

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

Schema description coverage is 100% and adequately describes both parameters. The description does not add new semantic meaning beyond the schema; it reiterates the process but not parameter details. Thus, 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 generates a production-ready llms.txt file for any URL, specifying the verb 'generate' and the resource 'llms.txt file'. It lists specific AI crawlers and use cases, making it distinct from siblings like 'ai_visibility_check' or 'scan_competitor_ai_presence'.

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

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

The description explicitly mentions when to use it (getting a client's site indexed, drafting for own project, auditing competitors) and implies it's for generating the file, not for checking existing ones. However, it does not explicitly exclude alternatives or state when not to use.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false. Description adds that it only returns active subscriptions by default and the specific fields, providing additional behavioral context beyond annotations.

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

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

Two sentences with no wasted words; 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?

With only one optional parameter, no output schema, and annotations present, the description fully covers the return fields, usage context, and parameter purpose.

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

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

Schema coverage is 100% and the description does not add meaning beyond what the schema already provides for the single optional parameter (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 the tool lists the caller's active subscriptions and specifies the returned fields (id, type, params, etc.), distinguishing it from siblings like subscribe/unsubscribe.

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

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

Explicitly tells when to use: to review monitored subscriptions before adding more or to find an id to cancel.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description adds value by specifying the API source, return format (OCDS release), field details (ocid, title, buyer, etc.), and language notes (Spanish values, English keys).

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

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

Three well-structured sentences that front-load the purpose, then provide input and output details. No wasted words; each sentence earns its place.

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

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

For a simple tool with one parameter and no output schema, the description fully covers API source, input alternatives, output fields, and language nuances. Complete for the given 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% with examples. Description adds clarity by explicitly stating acceptable input formats and providing concrete examples, enhancing 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 uses the specific verb 'Get' and identifies the resource as 'full Paraguay procurement record'. It distinguishes from the sibling tool 'paraguay_search_tenders' by focusing on retrieving a single record by ID rather than searching.

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

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

Provides clear input format guidance with examples (numeric ID or ocid). No explicit when-not or alternative usage, but the purpose is distinct enough that usage is implied from the sibling context.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false. The description adds crucial behavioral context: date scoping, paginated results, client-side filtering, and the fact that field values are in Spanish and amounts in PYG, which annotations do not cover.

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

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

The description is a single paragraph that efficiently conveys all necessary information without redundancy. It is front-loaded with the core purpose. Could be slightly more structured (e.g., bullet points), but it remains clear and easy to read.

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, no output schema, and moderate complexity, the description adequately explains the return fields, pagination, and date defaults. It does not detail pagination navigation or error conditions, but for a search tool this is sufficient.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining defaults for date parameters, clarifying that 'query' is a client-side filter, and mentioning the API parameter names (fecha_hasta, fecha_desde). This additional context warrants 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 it searches Paraguay government procurement processes from the official DNCP OCDS API, specifying the returned fields and noting Spanish-language values and PYG currency. It distinguishes from the sibling tool paraguay_get_record by directing users there for detailed records.

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

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

The description provides explicit usage guidance: the API requires a date range, defaults to the last 30 days, and explains that 'query' is a client-side filter with no server-side free-text search. It also tells users to use paraguay_get_record for full details, effectively distinguishing when to use which 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 provide no hints (all false), so the description carries the entire burden. It discloses rate limits (5 per identifier per day), that it's free and not quota-counted, the claim_token flow for later retrieval, and that feedback is read daily by the team. It does not explicitly state whether the feedback is sent to an external server or how long tokens remain valid, but covers the key behavioral traits.

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

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

The description is dense but every sentence adds value: purpose, use cases, exclusions, instructions, token mechanism, team behavior, rate limit, and cost. It is front-loaded with the core purpose and clearly structured, making it easy to scan despite its length.

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

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

With no output schema, the description must explain return behavior, and it does: the claim_token returned on filing and the later ability to read status. It covers the tool's scope, usage constraints, and token mechanics. Minor gaps like exact response format after filing or token expiration prevent a 5, but it is complete enough for an agent to use effectively.

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

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

Schema coverage is 100% with detailed parameter descriptions. The description adds value by explaining the claim_token's purpose and usage pattern ('pass it back later as pipeworx_feedback({claim_token:"pwfb_…"})'), which goes beyond the schema. It also reinforces the meaning of each enum value in the type parameter, increasing clarity.

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

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

The description uses a specific verb phrase, 'Tell the Pipeworx team something is broken, missing, or needs to exist,' which clearly defines the tool's purpose. It also distinguishes this tool from siblings by explicitly restricting it to feedback about Pipeworx tools and mentioning the return of a claim token, something no sibling tool does.

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

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

The description provides explicit use cases: bug, feature/data_gap, and praise, with detailed definitions. It also gives a clear exclusion criterion: feedback about tools from other MCP servers should be filed elsewhere. This is exemplary when-to-use and when-not-to-use guidance.

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

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

Annotations already indicate readOnlyHint, idempotentHint, and non-destructive behavior. The description adds valuable context: data source (CF analytics-engine), privacy (no PII), output structure (pack, tool, count), and caching intervals (5min-1h). No contradiction with annotations.

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

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

Three sentences efficiently cover purpose, use cases, and technical details. Front-loaded with core functionality, then use cases, then caching. Every sentence adds value, 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?

For a read-only info tool with one optional parameter, the description explains the output (top tools, packs, call volume) and caching behavior. Annotations cover safety. No output schema is needed as description clarifies return structure.

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 provides full enum and description for the single parameter. Description adds semantic guidance: 'Shorter windows surface what's hot right now; longer windows show steady-state demand,' which enriches the enum values beyond simple labels.

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 returns 'the top tools, top packs, and total call volume over a recent window,' specifying the verb (returns) and resource (Pipeworx trending data). This distinguishes it from sibling tools like 'discover_tools' or 'ask_pipeworx' which serve different purposes.

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

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

Three explicit use cases are listed, covering discovery, confirmation, and alignment. Window options are contrasted for hot vs steady-state. While no 'when not to use' is given, 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 declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false. Description adds context: 'walks child markets', 'checks date-axis/threshold-axis ordering', 'partition_check (sum of YES prices... deviations >3pp emit BUY/SELL EVERY LEG signal)', 'SEMANTIC ANCHOR using Jaccard similarity', 'PARTITION FILTER drops placeholder slugs', 'FILL CHECK against live CLOB depth'. No contradictions.

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

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

Description is longer than typical but each sentence adds value. Structure is logical: overall purpose, three modes with detailed behavior, advanced features (semantic anchor, partition filter, fill check), and referral to sibling tool. Front-loaded with purpose. Could trim minor redundancy like 'Call with NO args' vs 'for a trending scan' but still efficient 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?

No output schema, yet description fully explains response structure: 'opportunities[] (gap_pp, suggested_trade, reasoning, monotonicity violation context)', 'partition_check{sum_yes_prices, gap_from_1, placeholders_filtered, suggested_trade}', and 'fill_check{theoretical_edge_pp_at_book, realizable_edge_pp at 1000 shares/leg, thin_legs[]}'. Covers edge cases like 'skipped_low_similarity' and 'placeholders_filtered'. Complete for a complex arbitrage detection 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% but description adds rich meaning beyond schema. For event: 'pass a Polymarket event slug... walks child markets, checks date-axis/threshold-axis ordering AND computes partition_check'. For topic: 'pass a seed question... searches related events, flattens markets, runs comparator on union. Cross-event mode catches patterns that single-event misses.' Schema only says 'event slug' or 'topic string'; description transforms these into actionable behavior.

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

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

The description clearly states the tool finds arbitrage opportunities via 'monotonicity violations + partition-sum checks'. It distinguishes three modes: no args for trending scan, event for single-event mode, and topic for cross-event scan. The verb 'find' and specific resource 'arbitrage opportunities on Polymarket' make 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?

Explicit guidance: 'Call with NO args for a trending scan', 'event (recommended for a specific market)', 'topic for cross-event scanning'. It also explains when not to trade via fill check: 'realizable_edge_pp ≤ 0 means... do not trade it'. Alternatives mentioned: 'For custom sizing use polymarket_fill_risk'. This fully satisfies when-to-use and when-not.

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 far exceeds annotations by detailing three model families, caching behavior (1h at KV level), response structure including diagnostics, and specific edge calculations (edge_pp_net, kelly_fraction). It also mentions Fed bets exclusion and filter knobs, providing rich behavioral context beyond the readOnly/idempotent hints.

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

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

The description is comprehensive but verbose and densely packed with technical jargon. While it front-loads the purpose, the detailed model explanations could be streamlined for quicker consumption. It earns a 3 as it is adequate for an AI agent but not optimally 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?

Given the 9 parameters, no required params, 100% schema coverage, and no output schema, the description thoroughly covers expected outputs (by_segment, diagnostics, edge fields), caching, Fed exclusion, and filter mechanisms. It left no gaps for an AI agent to interpret the tool's behavior.

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

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

The input schema has 100% coverage with detailed descriptions for all 9 parameters. The tool description adds cross-referencing context (e.g., 'TRADEABLE-EDGE KNOBS') that explains how parameters interact, which enhances understanding beyond individual parameter descriptions.

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

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

The description clearly states that the tool scans Polymarket markets to find opportunities where Pipeworx data disagrees with market price. It explicitly says it's built for 'what should I bet on today' and distinguishes itself from sibling tools by focusing on edge discovery without manual paging.

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 guidance on when to use the tool (for discovering betting opportunities) and hints at alternatives (e.g., 'agents discover opportunities without paging hundreds of markets'). It also explains tradeable-edge knobs and response structure, but does not explicitly state when not to use or compare to specific siblings.

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

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

Annotations indicate safe read-only/idempotent behavior. Description adds rich detail: data source (daily snapshots), TTL limits, gap handling, computation details (daily closes, not intraday), and response structure.

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?

Efficiently structured: purpose first, then response format, then limitations. 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?

With no output schema, description fully explains response structure (tracked, expired, snapshot_dates) and field meanings. Covers limitations and edge cases (gaps, TTL). Complete 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%. Description repeats parameter info with minor additions (defaults, valid values). No new semantics beyond schema, meeting baseline.

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

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

Clear purpose: 'Edge persistence and decay telemetry' with specific question 'how long has this edge existed?' Distinguishes from siblings like polymarket_edges by focusing on time-series trends.

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 assess edge longevity and decay. Implicitly contrasts with fresh edges via example, but could be more explicit about when to use 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 (readOnlyHint, idempotentHint) indicate safe read operations. The description adds specific behavioral details: walks the order book ladder, computes VWAP fill price, slippage, verdicts (clean|degraded|cannot_fill), and warns about forced directional risk. No contradiction with annotations.

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

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

The description is well-structured with bold section headers and bullet-like formatting. It front-loads the core purpose and uses explicit marker words (SINGLE-MARKET, BASKET). While slightly lengthy, every sentence serves a purpose, and no filler is present.

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, so the description must explain return values. It fully enumerates outputs for both single-market (top_of_book, vwap_fill_price, slippage_pp, shares_filled, max_fillable_usd, verdict) and basket modes (theoretical_sum, realizable_sum, capture_ratio, profit_usd, per-leg fill detail, thin_legs, max_clean_notional_usd, forced_directional_risk). This is complete for the tool's complexity.

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

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

Schema description coverage is 100%, baseline 3. The description adds significant meaning: explains the dual interpretation of side (single-market vs basket), default auto behavior for basket, and clarifies that size_usd represents settlement notional in basket mode. Also documents the requirement for one of market or event.

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

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

The description begins with a specific verb+resource phrase: 'Realizable-vs-theoretical edge check against live CLOB order-book depth.' It clearly distinguishes from sibling tools like polymarket_arbitrage and polymarket_edges by positioning itself as a pre-trade risk check. The purpose is unambiguous.

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

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

Explicitly states when to use: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500.' It explains the rationale (partial fills convert arb to directional position, the dominant loss mode) and distinguishes between single-market and basket modes with clear requirements.

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 thoroughly discloses behavioral traits beyond annotations, including details about compatibility_warning conditions, temporal_alignment, skipped_cross_type/subtype counters, and the unreliability of most pre-mapped topics. 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 relatively long but well-structured, front-loaded with the main purpose and then detailing modes, response fields, and safety information. Every sentence contributes to understanding, though minor trimming could improve conciseness.

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

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

Despite no output schema, the description comprehensively covers what the tool returns, including leg-by-leg prices, top_spreads_pp, compatibility_warning fields, temporal_alignment, and skipped counters. The explanation of safety fields ensures a complete understanding.

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

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

Schema coverage is 100% and provides basic descriptions. The description adds significant value by explaining the two modes, giving example values for topic, and providing concrete examples 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?

The description clearly states the tool computes the cross-venue spread between Kalshi and Polymarket for the same resolving question. It distinguishes from siblings like polymarket_arbitrage by focusing on cross-venue comparison, and details two modes (topic shortcuts and explicit tickers).

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 and provides context for interpreting results, including warnings about compatibility and temporal alignment. It lacks explicit statements of when not to use it, but the cautionary notes effectively guide 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 non-destructive behavior. The description adds valuable context: scoping to user identifier, listing all keys when key omitted, and pairing with remember/forget. No contradiction with annotations.

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

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

The description is concise, well-structured, and front-loaded with the primary action. Every sentence adds value without redundancy.

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

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

Given the tool's simplicity (one optional param, no output schema), the description covers all necessary aspects: retrieval, listing, scoping, pairing, and typical use cases. It is fully informative for an agent.

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

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

Schema coverage is 100% and already describes the 'key' parameter and its omission for listing. The description repeats that information but adds examples. It does not significantly enhance beyond the schema.

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

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

The description clearly states the tool retrieves a saved value or lists all keys. The verb 'retrieve' and resource 'value' or 'keys' are specific. It distinguishes from siblings 'remember' and 'forget' by stating the pairing.

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

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

The description provides explicit usage examples (e.g., 'user's target ticker, an address, prior research notes') and explains scoping. It does not explicitly compare to other retrieval tools, but the pairing with remember/forget is clear.

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

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

Description states that mark_read mutates state (flags events read), contradicting the readOnlyHint=true annotation. This is a critical inconsistency that misleads about side effects.

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

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

Four sentences, each earning its place: purpose, return format, filtering/mark behavior, alternative access. Front-loaded with primary purpose. 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?

Covers return structure, polling suitability, and alternative endpoint. No output schema, so description compensates. Lacks details on authentication or rate limits, but annotations imply open access.

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 valuable context beyond schema: explains type format (e.g. 'sec_8k'), ISO timestamp for since, and effect of mark_read. Adds meaning beyond parameter names/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 subscription feed, specifies returned fields (source, citation_uri, raw payload), and mentions filtering options. Distinct from sibling tools like 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?

Provides explicit filtering guidance (type, since), describes mark_read behavior for polling, and notes alternative access via URL. Lacks explicit when-not-to-use but effectively guides 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?

The description details the internal fan-out to SEC EDGAR, GDELT→GNews fallback, and USPTO (with soft-fail note), plus the return format. This adds significant context beyond the annotations (readOnlyHint, idempotentHint). 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 thorough but slightly verbose due to the list of example queries at the start. However, it is well-structured and front-loaded with the purpose.

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

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

Given the complexity (multiple sources, fallback, soft-fail), no output schema, but the description covers the return structure and parameter behavior comprehensively, making it complete for an AI agent.

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

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

Schema coverage is 100%, and the description enriches parameters with usage examples (e.g., '30d', ticker vs. CIK) and clarifies that 'type' only supports 'company'.

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 over a time window, with example queries and explicit differentiation from the sibling 'entity_profile' tool.

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

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

The description provides explicit guidance on when to use this tool versus 'entity_profile' and explains the 'since' parameter with examples (ISO date vs. relative shorthand).

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

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

Adds key behavioral details beyond annotations: scoping by identifier, persistence duration (24h for anonymous, persistent for authenticated). 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 adding value, front-loaded with purpose, no superfluous content.

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

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

For a simple save tool, the description provides complete context: purpose, scope, pairing, and retention policy.

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; the description does not add new parameter-level detail beyond that.

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

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

The description uses a specific verb 'save' and resource 'data to reuse later', clearly distinguishing the tool from siblings like recall and forget.

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

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

States when to use ('when you discover something worth carrying forward') and pairs with recall/forget, but does not explicitly exclude use cases.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, but the description goes well beyond them. It discloses internal cascading through multiple lookup endpoints, graceful degradation of LEI/FIGI enrichment when GLEIF/OpenFIGI are unavailable, explicit inclusion of an `unresolved` field for failed resolutions, and source-labelled identifiers. This significantly enriches behavioral understanding.

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

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

The description is long but densely packed. It is front-loaded with purpose and example queries, then organized by SUPPORTED TYPES. While every sentence adds value, the length is slightly excessive, and some redundancy exists (e.g., emphasizing 'use first' twice). It earns a 4 rather than 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 tool's complexity—two entity types, multiple external data sources (SEC EDGAR, GLEIF, OpenFIGI, RxNorm), fallback behavior, and output characteristics—the description is remarkably complete. It covers edge cases like ISIN-to-LEI mapping, non-US issuers, graceful degradation, and explicitly notes that it replaces 2-3 manual lookups. With no output schema, the description sufficiently explains the categories of returned identifiers.

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

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

Schema coverage is 100%, but the description adds substantial meaning. For 'type', it details the cross-source identity spine for companies (CIK, ticker, LEI, FIGI) and RxNorm for drugs. For 'value', it adds ISIN as an accepted input not present in the schema, clarifies CIK formatting, and provides concrete examples (AAPL, ozempic). This is a clear enhancement beyond the schema.

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

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

The description explicitly states the tool resolves a user-spoken name to canonical/official identifiers, with concrete examples like 'What's the ticker for…' and 'find the CIK for…'. It clearly distinguishes from sibling tools by explaining it provides the IDs other tools require as input and by listing supported entity types (company/drug).

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

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

It provides explicit when-to-use guidance: 'Use FIRST whenever you have a name but need an ID.' It implies that alternatives exist (e.g., entity_profile) by noting other tools require these identifiers, but it does not explicitly name alternatives or give when-not-to-use scenarios, so it falls just short of 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 declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds that it probes each entity with 'ai_visibility_check', ranks results, and returns a ranked list with score, confidence, and signal density. This explains the process beyond annotation hints.

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

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

Two sentences: first states purpose and mechanism, second provides use case and output summary. Every sentence adds value with zero redundancy. Front-loaded with key action verb.

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

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

No output schema, but description specifies return: 'ranked list with score, confidence, signal density per entity.' Input schema is fully described. Adequate for agent to understand inputs and outputs, though exact return structure is slightly vague.

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 4 parameters. The description does not add meaning beyond schema descriptions (e.g., 'entities' is already described as array of brand names with first as subject). Baseline 3 is appropriate since the schema carries the 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 uses specific verbs ('Compare', 'Probes', 'ranks') and resources ('AI visibility across multiple entities'), clearly distinguishing it from siblings like 'ai_visibility_check' (single entity). It states the tool performs a side-by-side comparison and surfaces most/least recognized.

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

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

Provides clear context: 'Useful for competitive AI-marketing audits' with an example question. Implies when to use (multi-entity comparison) but does not explicitly state when not to use or name alternatives. Given sibling 'ai_visibility_check' is single-entity, the comparison is implicit.

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

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

Description discloses extensive behavioral traits: fans out across deps.dev and bundlephobia, partial failure handling, bundlephobia's first measurement delay (5-30s), and sources_failed list. Annotations (readOnlyHint, idempotentHint, openWorldHint) are consistent and complemented.

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

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

The description is a single paragraph but front-loads the main purpose and packs in substantial detail. Slightly dense, but effective and not overly verbose.

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

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

Despite no output schema, the description thoroughly explains the return format (summary block fields, per-advisory detail, links, alternative versions) and covers edge cases like partial failures. This makes 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 description coverage is 100%, and the description adds no significant meaning beyond what is already in the schema. Both parameters (package and version) are well-described in the schema, and the description merely restates them without extra context.

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

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

The description clearly states the tool is a composite 'should I add this npm package' check, listing specific features (license, advisories, version history, bundle size, ESM/tree-shake). It distinguishes from sibling tools like 'compare_entities' and 'entity_profile' by focusing on npm dependency analysis.

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

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

Explicitly advises use when an agent asks about safety, popularity, size, or cost of adding a package. Also specifies ecosystem (NPM only in v1) and points to alternatives for other ecosystems (deps.dev:version).

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

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

Adds rich behavioral context beyond annotations: BGE-base-en embeddings, cosine over 500-char overlapping windows, 200K char cap with truncation and flagging, character offsets, and similarity scores. No contradictions with annotations.

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

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

Three sentences, front-loaded with purpose. Every sentence adds value—purpose, usage, technical details. No wasted words.

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

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

No output schema, but description explains return format (top-N passages with offsets and similarity scores) and truncation behavior. Thorough for a 3-param tool with no output schema.

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

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

Schema coverage is 100%, but description adds extra meaning: for text it clarifies max ~200K chars, for query it gives example queries, and for limit it specifies range 1-20 and default 5, which is not in 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 'Semantic search INSIDE a fetched record' with specific verb+resource, and distinguishes from siblings by mentioning pairing with ask_pipeworx_grounded.

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

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

Explicitly says 'Use when the record is too big to cram into the prompt' and provides alternative: 'Pairs with ask_pipeworx_grounded: fetch with the gateway, ground over the relevant passages instead of the whole document.'

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

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

Adds significant behavioral context beyond annotations: OAuth requirement, delivery channel specifics (email, SMS with 10/day cap, webhook auto-disable after 10 failures, HMAC signing details). 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?

Concise yet comprehensive; frontloads purpose and requirements, organizes details logically without redundancy. Every sentence adds necessary information.

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

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

Covers OAuth requirement, all subscription types with parameter structures, delivery channels with limitations, and return value. No output schema, but return value is mentioned. Sufficient for a complex parameterized tool.

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

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

Schema description coverage is 100%, but the description enriches parameter meaning with concrete examples for each type and delivery field, explaining constraints like phone verification and webhook signature. Adds value beyond schema.

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

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

The description clearly states it creates a proactive monitoring subscription to a live-data event stream, specifies the return of a subscription id, and distinguishes from sibling tools like list_subscriptions and unsubscribe.

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

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

Explains requirement for Pipeworx OAuth account, lists supported subscription types with examples, and mentions delivery options with constraints like phone verification and daily cap. Lacks explicit when-not-to-use or alternatives, but prerequisites are clear.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds behavioral context: it returns category-bucketed example questions with exact tool + argument shapes. No contradictions exist.

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 with useful information but slightly verbose. Every sentence earns its place, covering purpose, usage, and examples. It could be tightened slightly without losing meaning.

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

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

Given one optional parameter, no output schema, and the tool's role as an onboarding entry point among many siblings, the description fully covers what an agent needs: when to use, what to expect, and how to customize. No gaps remain.

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

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

Schema coverage is 100% with a single optional parameter. The description adds value by listing example topic values (finance, pharma, etc.) and explaining behavior when omitted (full spread), which the schema alone does not convey.

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: an onboarding entry point that returns category-bucketed example questions with tool shapes. It uses specific verbs like 'returns' and 'use this FIRST', and distinguishes it from siblings by clearly defining when to invoke it.

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 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', providing clear context. However, it does not explicitly state when NOT to use it or cite alternative tools beyond mentioning meta-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?

Discloses important behavior beyond annotations: ownership enforcement and deactivation vs deletion. Aligns with annotations (destructiveHint=false, idempotentHint=true). 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, no wasted words. Front-loaded with core action, then behavioral notes. Highly efficient.

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

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

Complete for a simple one-parameter tool with no output schema. Covers action, side effects, ownership, and alternatives for historical data.

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

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

Schema already provides description for the single parameter (id). Description does not add extra param info, which is acceptable given 100% schema coverage.

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

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

Description clearly states 'Cancel a subscription by id' with specific verb and resource. Distinguishes 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?

Explains ownership enforcement and that the row is deactivated not deleted, with historical events accessible via recent_alerts. Provides context for when to use, though not explicitly listing when not to.

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

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

Annotations already cover read-only/idempotent; the description adds essential behavior: verdict enums, grounded/structured value with citation, reasoning, and critical caveats about could_not_verify and unsupported. 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?

Though long, every sentence earns its place: trigger examples, routing logic, verdict list, caveats, and efficiency claim. The description is front-loaded with use cases and avoids 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?

With no output schema, the description fully explains return values and edge cases. It covers failure modes, routing, and interpretation pitfalls, making the tool self-sufficient for an agent.

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

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

Schema covers both parameters at 100%, but description adds semantic detail beyond schema: tolerance_pct range, override behavior, hallucination-detection suggestion, and default cap. This enriches parameter understanding.

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

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

The description states a specific verb and resource: natural-language claim verification against authoritative sources. It includes trigger phrases and clearly distinguishes this tool from siblings like ask_pipeworx by focusing on fact-checking with SEC/grounded routing.

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 says 'Use whenever the agent needs to check whether something a user said is factually correct' and explains routing for company-financial vs other claims. It doesn't name specific sibling exclusions, but the guidance is strong and actionable.

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