Cvr Dk

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

Annotations already declare readOnly, idempotent, and non-destructive. The description adds valuable context: the free default model, the BYO-key cost implication for Anthropic, and the per-model return structure. This goes beyond annotations and clarifies financial and operational behavior.

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

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

Three sentences, front-loaded with the core purpose, and zero filler. Every sentence adds new information: the action/result, the model config/cost note, and the return format/use cases. 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?

With no output schema, the description compensates by listing per-model fields ({score, confidence, signals, raw_response}) and the combined view. It also covers the optional key and context parameter. It lacks details on scoring internals or error scenarios, but for a tool with 4 documented parameters, it is sufficiently 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%, giving a baseline of 3. The description adds extra meaning by explaining the default Workers AI model, the relationship between models and _apiKey, and that calls to Anthropic are paid directly by the user. This enriches the schema's plain 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 starts with a specific verb 'Probe' and clearly states the resource (LLMs) and outcome (score visibility 0-100 per model). It distinguishes this tool from siblings like ask_pipeworx or scan_competitor_ai_presence by focusing on cross-model AI visibility scoring.

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

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

The description provides explicit use cases ('AI-marketing audits, pre-launch brand checks, competitive monitoring') and explains the default model vs. Anthropic opt-in. However, it does not mention when to avoid this tool or name alternatives such as scan_competitor_ai_presence, so it stops short of full exclusion guidance.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false – so the tool's safety profile is fully transparent. The description adds valuable behavioral context: it routes questions to the right tool internally, fills arguments, returns structured answers with citation URIs. The only gap is no mention of rate limits or timeout behavior, but this is minor given the comprehensive 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 most critical guidance ('PREFER OVER WEB SEARCH') and provides extensive context in a structured way. It's efficiently written with actionable examples and sibling differentiation. One point deducted because the description could be slightly more concise – some repetition occurs (e.g., listing many example domains then again in examples). Still, every sentence adds value.

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

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

Given the tool has no output schema and 6 parameters (100% schema coverage), the description perfectly fills the gaps. It explains the routing behavior, the types of sources handled, the nature of the output (structured answer with citation URIs), and provides extensive example queries. The description is complete enough for an agent to use this tool appropriately without additional context.

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

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

Schema description coverage is 100% – the schema documents all 6 parameters (question and 5 aliases: q, text, input, query, prompt) with clear descriptions. The description goes further by explaining that the question should be in natural language and gives concrete examples of successful queries. However, the description doesn't add much beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states this tool routes questions to 5,563 tools across 1,462 verified sources for authoritative structured data with citations. It explicitly lists the types of questions it handles (SEC filings, FDA drug data, etc.) and distinguishes itself from siblings like ask_pipeworx_grounded and deep_research.

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

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

Exceptionally strong guidelines: explicitly says 'PREFER OVER WEB SEARCH', gives detailed when-to-use with example queries, and clearly states when to step up to alternatives (ask_pipeworx_grounded for hallucination-resistant answers, deep_research for broad/multi-part questions, and web search for breaking news). The description also notes it works on every tier with one fast call.

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 valuable context: it is a full working router with experimental improvements that may be active, and currently matches the stable version exactly. 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 four sentences, front-loaded with the critical identity and purpose. Every sentence adds unique value: beta identity, current state, usage guidance, and emphasis that it's a full router. No wasted words.

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

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

Given the tool's complexity as a beta version with many siblings, the description is complete. It explains the experimental nature, current state, relationship to the stable version, and usage. No output schema exists, but the description references the same response shape as ask_pipeworx, which 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 description coverage is 100% with descriptions for all 6 parameters. The description adds no additional parameter-level meaning beyond what the schema provides. Baseline 3 is appropriate since the schema handles this well.

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

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

The description clearly states it is a beta version of 'ask_pipeworx' with identical capabilities (5,563 tools, same arguments, same response shape) but with candidate routing improvements. It distinguishes itself from the stable version and from siblings like 'ask_pipeworx_grounded' by explicitly noting the experimental edge and comparison purpose.

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

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

The description says 'Use it exactly like ask_pipeworx when you want the newest routing; results are compared against the stable router to decide what merges.' This provides clear when-to-use guidance. It could be stronger by explicitly stating when not to use (e.g., for production consistency), but the context implies it's for testing.

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 are false, so the description does not need to cover those. It adds value by detailing the exact return format (answer, evidence, confidence, source, fetched_at, refusal_reason) and failure modes, which is rich 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?

The description is well-structured and front-loaded with the key behavioral distinction (hallucination-resistant), but contains some redundancy (e.g., 'Same routing as ask_pipeworx' and then elaboration on that routing) and could be slightly tightened without losing substance.

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

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

Given the tool has no output schema and only one simple parameter (question), the description fully covers the output format, refusal reasons, use cases, and cost tradeoff. No additional information is needed for an agent to invoke this tool correctly.

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

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

Schema description coverage is 100%, so baseline is 3. The description reinforces that the single required parameter is a natural language question but adds no new meaning beyond what the schema already provides (all five aliases are listed in the schema description).

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

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

The description clearly states the tool performs 'Hallucination-resistant answer mode for high-stakes reads,' explicitly distinguishes it from sibling ask_pipeworx by explaining the same routing plus extraction step and return format, and contrasts with casual lookups.

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

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

Provides explicit guidance on when to use (high-stakes reads needing cited/quoted answers, e.g., financial verdicts, legal claims, medical lookups) and when not (prefer ask_pipeworx for casual lookups), and mentions a cost tradeoff (one extra LLM call).

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

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

The description goes far beyond the annotations by detailing numerous behavioral traits: fan-out logic, resolver contract with confidence levels, parent-event extraction, safety short-circuits for low-confidence matches, closed market handling, and cancellation-rule risk. It even specifies response fields and error/fallback behaviors. This is extensive and transparent.

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

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

The description is lengthy but well-structured with clear section headers (CLASSIFIERS, FAN-OUT EXAMPLES, RESPONSE SHAPES, etc.) and front-loads the key purpose and input format. Each section provides concrete examples and safety notes. While it could be trimmed, the density is justified by the tool's complexity.

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

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

Given the complexity of the tool and the absence of an output schema, the description thoroughly explains the response shape, key failure modes, resolver behavior, parent-event details, and edge-case handling. It even discloses cancellation-rule risk, making it highly complete for an agent to use correctly.

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

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

The input schema already covers 100% of parameter descriptions, including the 'market' parameter's acceptable formats, 'depth' enum, and 'include_raw' purpose. The description adds value by giving real-world examples and explaining fan-out behaviors, but it does not substantially enrich the per-parameter semantics 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 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call,' which is a specific verb+resource+scope. It distinguishes itself from siblings like polymarket_edges and polymarket_arbitrage by focusing on data-gathering for a single bet, including explicit use cases ('should I bet on X', 'what does the data say about Y', 'is there edge in Z').

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

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

The description provides clear context on when to use the tool ('Use for...') but does not explicitly mention when not to use it or name alternative tools. It gives helpful usage scenarios and even differentiates depth levels, which serves as practical guidance.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive. The description adds valuable context: pulls latest 10-K data, handles off-calendar fiscal years, sorts results by primary metric, and returns citation URIs. 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 dense but not overly verbose; every sentence adds useful information. It is front-loaded with trigger phrases and usage guidance, though the all-caps 'ALWAYS PREFER' is slightly aggressive but acceptable.

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

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

For a tool with two params, annotations, and no output schema, the description is quite complete: it explains data sources, sorting behavior, and return format (paired data + URIs). Minor missing edge cases (e.g., invalid entity handling) are not required for basic invocation.

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

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

Schema coverage is 100% with clear descriptions for both params. The tool description adds some context (e.g., off-calendar fiscal years and what each type pulls) but parameters are already well-documented in the schema, so minimal additional value from description.

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

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

The description clearly states it performs side-by-side comparisons of 2-5 companies or drugs in a single call. It gives specific trigger phrases and distinguishes from sequential single-pack lookups via the 'ALWAYS PREFER' guidance.

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

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

Explicitly provides when-to-use: 'ALWAYS PREFER over sequential single-pack lookups when comparing entities.' Also provides trigger examples and indicates data per type, so agents know when to select this tool over alternatives.

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

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

The description goes far beyond annotations, revealing account requirements, paid plan for thorough, expected response times (15-60s, up to ~90s), parallel decomposition, return format (findings with evidence, confidence, source, citations, gaps array, contradictions), semantic excerpting, hop field, and that large records are excerpted by relevance. It also clarifies that it's not open-web search and returns empty gaps for topics not in the catalog. 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 long but every sentence adds value. It is front-loaded with the critical account requirement and alternative tool. The structure flows logically: prerequisites, core purpose, when to use vs alternatives, depth options, output format, limitations, and time expectations. While dense, it remains readable and well-organized. A minor reduction in wordiness could be possible, but the completeness justifies the length.

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

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

Given the tool's complexity (2 parameters, no output schema, many behavioral traits), the description covers all necessary aspects: what it does, when to use, when not to use, limitations, output format, depth options, time expectations, account requirements, and even the nature of citations. It is fully self-contained and leaves no major gaps for an agent to infer.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds significant value by explaining the meaning of depth levels ('quick=3... standard=5... thorough=8...') and what each involves (single hop, gap-recovery, contradictions scan). For the question parameter, it specifies that broad/multi-part questions are fine and decomposition is the point. This extra context enhances understanding beyond the schema.

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

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

The description clearly states the tool's purpose: grounded multi-source research across 1462 structured data sources, decomposing questions into facets and routing to thousands of tools. It distinguishes from sibling ask_pipeworx by specifying that this is for broad/multi-part questions over structured data, not single lookups or current news. The verb 'research' and resource 'structured data sources' are specific and unambiguous.

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

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

Explicitly tells when to use this tool vs alternatives: for single lookups use ask_pipeworx, for breaking current news prefer ask_pipeworx, and if not signed in use ask_pipeworx. It also explains depth levels (quick, standard, thorough) and when to choose each. The guidance is concrete 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 readOnly=true and idempotent=true, covering the safety profile. The description adds valuable behavioral context beyond annotations: it explains the return format ('top-N most relevant tools with names, descriptions, and full input schemas') and promises 'no second schema lookup needed,' both of which inform invocation.

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 and front-loaded with the core purpose ('Find tools by describing the data or task'). The long list of data domains is somewhat verbose but informative, and each sentence serves a distinct role: purpose, use case, and return semantics.

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 compensates by explaining what the tool returns (top-N tools with names, descriptions, full schemas) and that no second schema lookup is needed. It also provides contextual guidance via 'Call this FIRST' and mentions the option-set orientation, making it complete for a read-only discovery tool.

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

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

The input schema provides full descriptions for all six parameters, including aliases, achieving 100% coverage. The description adds little beyond the schema—it only generalizes that the query is a natural-language task description, which the schema already states. Thus, the baseline 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 opens with a specific action and object: 'Find tools by describing the data or task,' which clearly establishes the tool's purpose. It distinguishes from siblings by stating 'Call this FIRST' when looking to browse or discover, and it enumerates many concrete data domains, making the scope unmistakable.

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

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

The description explicitly states when to use it: 'Use when you need to browse, search, look up, or discover what tools exist' and 'Call this FIRST when you have many tools available.' However, it does not mention when not to use it or name alternative tools, so it narrowly misses a perfect score.

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 read-only, idempotent, and non-destructive behavior. The description adds rich behavioral detail: fanning out across SEC EDGAR, XBRL, USPTO, news, and GLEIF, USPTO PatentsView sunset and soft-fail, GDELT→GNews fallback, and exact return fields. No contradiction with annotations.

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

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

The description is long but front-loaded with examples and a clear purpose, followed by relevant details in a logical order. Some example paraphrases could be trimmed, but each part adds useful context for intent matching and usage.

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 compensates by enumerating every major return field, including recent filings URIs, fundamentals sorting, patents soft-fail, news fallback, and LEI. Input constraints and alternatives are also covered, making the description complete for this complex tool.

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

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

Schema description coverage is 100%, with both parameters fully documented (type as enum, value as ticker/CIK). The description repeats the same information without adding new semantics, so the baseline 3 applies.

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

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

The description clearly states the tool creates a full cross-source profile of a US public company in one parallel call, with concrete example intents. It distinguishes itself from sibling tools by preferring it over chained lookups and explicitly referencing resolve_entity for names.

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 usage guidance: use this when the user asks for a holistic view, rather than chaining single-pack lookups. It also clarifies that names are not supported and points to resolve_entity as the alternative, giving clear direction on when and 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 signal destructiveHint=true and idempotentHint=true. The description adds context about what is deleted (previously stored memory) and appropriate use cases (sensitive data), going beyond the structured annotations without contradiction.

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

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

Three concise sentences, front-loaded with the action, and every sentence provides useful information. No redundancy or fluff.

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

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

For a simple one-parameter delete tool with strong annotations and no output schema, the description sufficiently covers purpose, usage, and behavior. Nothing essential is missing.

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

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

The input schema fully covers the single 'key' parameter with a clear description ('Memory key to delete'), giving a baseline of 3. The tool description only repeats 'by key' without adding further semantics or usage details.

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

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

The description clearly states the action ('Delete') and the specific resource ('a previously stored memory by key'), distinguishing it from sibling tools like remember and recall. It explicitly names the operation and target.

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 conditions are provided: 'Use when context is stale, the task is done, or you want to clear sensitive data'. It also mentions pairing with remember and recall, but lacks an explicit when-not clause, so slightly below a perfect 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?

Beyond the annotations (readOnly, idempotent, openWorld, non-destructive), the description adds behavioral detail: it fetches the page, extracts content, and emits a markdown blob. This helps the agent understand the process and side effects (network fetch, output format), which is useful despite the annotations already declaring safety.

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 front-loaded with the core purpose. It avoids redundancy, uses a clear structure, and every sentence adds value—the process, output format, and use cases are all relevant.

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 two-parameter read-only tool with high schema coverage, the description is quite complete. It explains the output format and use cases. However, it does not mention potential edge cases like fetch failures or rate limits, which could be relevant for a network-fetching tool, hence a 4 rather than 5.

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

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

The schema description covers both parameters completely (url and max_links with explanations). The description does not add additional parameter-specific meaning beyond what the schema provides, so the baseline of 3 applies.

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

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

The description clearly states the tool generates a production-ready llms.txt file for any URL, specifying the exact actions (fetches, extracts title/description/key links) and output (standard llms.txt markdown). This differentiates it from sibling tools like 'ai_visibility_check' or 'scan_competitor_ai_presence' that likely focus on analysis rather than file generation.

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

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

The description provides explicit use cases: getting a client's site indexed, drafting for own project, or auditing a competitor. This gives clear context for when to use the tool, though it does not explicitly state when not to use it or name alternative tools.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description adds that only active subscriptions are listed by default and specifies return fields, which is useful contextual behavior beyond the annotations.

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

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

The description is compact: one sentence for purpose and return fields, one for usage. No wasted words, and the key information is front-loaded.

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

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

For a simple list tool with one optional parameter and no output schema, the description adequately covers purpose, return fields, and usage guidance. It misses nothing critical for an agent to use it correctly.

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

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

Schema coverage is 100% for the single parameter include_inactive, with a clear description in the schema. The tool description does not add extra detail about the parameter, so it does not elevate beyond the baseline.

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

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

The description states 'List the caller's active subscriptions' with a specific verb and resource, and enumerates the returned fields. This clearly distinguishes it from sibling tools like subscribe and unsubscribe.

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

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

It provides explicit use cases: 'Use this to review what you're monitoring before adding more or to find an id to cancel.' This gives clear context for when to call, though it doesn't explicitly name alternatives like subscribe/unsubscribe.

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

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

Beyond annotations (all false), the description discloses rate limiting ('5 per identifier per day'), quota independence ('doesn't count against your tool-call quota'), the claim_token workflow for anonymous submissions and follow-up, and the team's daily digest behavior. No contradiction with annotations, and it substantially informs the agent of side effects and constraints.

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 every sentence adds unique, actionable context, and it is front-loaded with the core purpose. It loses a point for being somewhat dense, requiring a careful read to absorb all the nuance, though no sentence is wasted.

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

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

Given the absence of an output schema, the description fully explains the return behavior (claim_token when no account, status updates later). It covers scope, exclusions, rate limits, and protocol for effective feedback, making the description self-sufficient for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100%, and each parameter already has a description. The description adds value by explaining how claim_token is used ('pass it back later as pipeworx_feedback({claim_token:...})') and gives guidance on message content ('Describe the issue in terms of Pipeworx tools/packs'), raising it above the baseline.

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

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

The description opens with a specific verb+resource: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It clearly distinguishes from the sibling research/market tools by focusing on feedback about Pipeworx itself, with no overlapping tool in the sibling list.

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 for bugs, features/data gaps, and praise, and when not to use (tools from other MCP servers, pointing to filing with that server instead). It also provides instructions on describing issues in terms of Pipeworx tools/packs and not pasting user prompts, making usage guidance exceptionally 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?

Beyond the annotations (readOnlyHint, idempotentHint, etc.), the description adds meaningful behavioral context: it discloses the data source ('derived from CF analytics-engine'), privacy implications ('no PII'), the exact data shape ('just (pack, tool, count)'), and caching behavior ('Cached 5min-1h depending on window'). 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 concise and well-structured: one sentence stating the core function, one sentence listing use cases, and one sentence with technical details. Every sentence adds value, and the most important information is front-loaded.

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

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

Given the tool's simplicity (one optional parameter, no nested objects, no output schema), the description is complete. It covers the output format ('top tools, top packs, and total call volume'), the data shape, caching, and use cases. Combined with thorough annotations and schema, 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% and the enum values already include detailed semantics ('24h (default) | 7d | 30d. Shorter windows surface what's hot right now; longer windows show steady-state demand.'). The tool description merely restates the window options without adding extra meaning beyond the schema.

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

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

The description clearly states the tool's function: 'Returns the top tools, top packs, and total call volume over a recent window.' It uses a specific verb ('Returns') and resource ('what other AI agents are calling on Pipeworx'), and distinguishes itself from siblings like ask_pipeworx (question-answering) and discover_tools (tool discovery).

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

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

The description provides three explicit 'Useful for' scenarios, including 'confirming a popular tool is the canonical choice before asking your own question.' This gives clear context for when to use the tool, though it doesn't name alternatives or exclusion conditions explicitly.

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

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

The description goes far beyond the readOnly/idempotent annotations. It discloses the partition-check threshold (>3pp), placeholder filtering, Jaccard similarity semantic anchor, fill check behavior (realizable_edge_pp ≤ 0 means do not trade), and skipped_low_similarity counter. This is rich behavioral context annotations cannot convey.

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?

Despite its length, the description is tightly structured with labeled sections (SEMANTIC ANCHOR, PARTITION FILTER, FILL CHECK) and every sentence carries operational value. The core purpose is front-loaded, and no filler exists.

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 specifies both modes, the response fields (opportunities[], partition_check, fill_check), edge cases (thin_legs, placeholder fractions), and points to a related tool for custom sizing. Without an output schema, this is a complete operational guide.

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

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

The schema covers both parameters with brief descriptions, but the tool description adds concrete examples (event slugs, seed questions), explains the difference between event and topic modes, and clarifies which mode to choose. This significantly enhances the schema's basic parameter info.

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

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

The description opens with a specific verb and resource: 'Find arbitrage opportunities on Polymarket via monotonicity violations + partition-sum checks.' It clearly differentiates from siblings like polymarket_edges and polymarket_fill_risk by describing its multi-mode scanning and response structure.

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 instructions are provided: 'Call with NO args for a trending_scan', 'pass event for...', 'or topic for...'. It also recommends event for specific markets and points to polymarket_fill_risk for custom sizing, offering clear alternatives and when-to-use guidance.

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

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

Annotations already declare readOnlyHint and idempotentHint, but the description adds substantial behavioral detail: three model families, response segments, diagnostics funnel, caching (1h KV), and a caveat that Fed signals are unreliable. 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 long but well-structured into sections (model families, knobs, diagnostics, caching). Every section earns its place for a tool of this complexity, though some redundancy with schema parameter descriptions exists and a slightly tighter presentation would improve readability.

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

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

Despite having no output schema, the description thoroughly explains the response top-level (by_segment, fed_candidates/fed_note, _diagnostics), including why a segment might be empty. It covers knobs, cache behavior, and limitations, making it complete for correct invocation.

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

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

Schema descriptions cover 100% of parameters, so baseline is 3. The description adds extra meaning for knobs like min_liquidity/max_spread_pp ('drop opportunities where edge isn't realizable') and explains why min_kelly doesn't apply to partition arbs, enriching the agent's understanding.

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

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

The description opens with a specific verb and resource: 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price.' It clearly differentiates from sibling tools like polymarket_edge_tracker by focusing on current edge discovery rather than tracking or arbitrage.

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

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

The description provides clear usage context: 'Built for "what should I bet on today"' and explains when to apply tradeable-edge knobs like min_liquidity and max_spread_pp. It does not explicitly name alternatives or exclusions, but the intended scenario is well conveyed.

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. The description adds valuable behavioral details beyond those hints: snapshots are written on cache-miss with implied data gaps, decay is computed from daily closes (net of slippage) not intraday, and expired means 'closed, resolved, or arbed away.' These nuances about data freshness and calculation methodology are crucial for interpreting results.

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

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

The description is long but well-organized with ARGS, RESPONSE, and LIMITS sections. Each sentence contributes contextual detail (return structure, data caveats, limitations). It is front-loaded with the purpose and then dives into mechanics. While it could be condensed slightly, the structure keeps it scannable, and there is no redundant filler.

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

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

With no output schema, the description fully compensates by detailing the response structure: tracked[] with time-series fields (edge_pp_net, first_seen, trend, decay_pp_per_day), expired[] with lifespan_days, and snapshot_dates[]. It also explains limitations (60-day TTL, snapshot start time). This is a self-sufficient explanation for a moderately complex telemetry tool, covering what is returned and how to interpret it.

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

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

The schema describes both parameters with 100% coverage, including defaults and clamping (days: 'default 14, clamp 2-30'; window: '24hr | 1wk | 1mo (default 1wk)'). The description merely restates these (e.g., 'lookback, default 14, max 30') and introduces the concept of 'snapshot family' for window. Since schema coverage is high, the description adds minimal marginal value; it does not clarify types or edge cases beyond what schema already provides.

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

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

The description opens with a precise statement: 'Edge persistence and decay telemetry built from daily polymarket_edges snapshots.' It clearly answers a specific question ('how long has this edge existed and is it shrinking?') and differentiates itself from sibling tool polymarket_edges by focusing on historical persistence rather than current edge values. The purpose is unmistakable and actionable.

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

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

The description provides strong contextual guidance by framing the tool around a decision ('a fresh wide edge and a 3-week-old wide edge are different trades'). It also explains limitations (TTL, data gaps) that set expectations. However, it does not explicitly name alternative tools or state 'use this when...' with exclusions, though the implied use case is clear enough.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false; the description adds deeper behavioral context: it 'walks the ladder', warns that 'partial basket fills convert an arb into an unhedged directional position,' and exposes 'forced_directional_risk' as a return field. This goes beyond structured 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 structured, with front-loaded purpose and clear mode separators (SINGLE-MARKET, BASKET). No filler; every sentence carries unique information, including output fields and risk warnings.

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 compensates by listing every return field for both modes, covering parameters, mode selection, and the dominant risk. It is self-sufficient for even a complex two-mode 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?

While schema coverage is 100%, the description enriches parameter meaning: it clarifies that in basket mode side 'sell_yes = capture overround by selling every leg' and size_usd 'interpreted as settlement notional S (shares per leg)'. It also resolves the mutual exclusion requirement not visible 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 opens with a precise definition: 'Realizable-vs-theoretical edge check against live CLOB order-book depth.' It clearly distinguishes between single-market and basket modes and explicitly references sibling tools (polymarket_arbitrage, polymarket_edges) to set it apart.

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 instruction 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500' provides direct conditional guidance. It also explains the two modes ('SINGLE-MARKET' vs 'BASKET') and when each is appropriate, plus the risk of unhedged positions.

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

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

Beyond the read-only and idempotent annotations, the description discloses substantial behavioral context: it details when compatibility_warning fires, how temporal_alignment affects spread validity, and how skipped_cross_type/subtype counters expose dropped comparisons. It also sets expectations that real spreads are rare. This adds far more than the structured annotations alone, with no contradiction.

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

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

The description is multiple paragraphs long and uses ALL CAPS and many field names, which makes it dense and somewhat overwhelming. It is not front-loaded and could be restructured into bullet-style sections for better scanability. However, every sentence carries meaningful information, so it's not wasteful.

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 accounts for the missing information by explicitly describing the response structure: leg-by-leg prices, matched spread array, safety fields (compatibility_warning, temporal_alignment, skipped counters). Given the tool's complexity in comparing cross-venue bet shapes, the description covers all necessary context for correct invocation and interpretation.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by explaining the two modes: the topic parameter maps to 10 named shortcuts, and the explicit ticker/slug parameters override the topic-mapped side. This clarifies the relationship between parameters and the auto-fetch behavior, going beyond the schema's simple property descriptions.

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

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

The description clearly states that the tool computes and returns the cross-venue spread between Kalshi and Polymarket for equivalent resolving questions, with two input modes (topic shortcuts or explicit tickers/slugs) and a response containing per-venue prices and matched spread values. This specific verb+resource+scope distinguishes it from sibling tools like polymarket_arbitrage or polymarket_edges, which focus on different aspects.

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 each mode: topic mode for 10 pre-mapped macro shortcuts, explicit mode for custom pairings. It also warns that most pre-mapped topics currently return compatibility warnings and that pre-mapped ≠ tradeable, providing context for when the tool will be useful. However, it doesn't explicitly mention alternative tools for related purposes, so it lacks a clear exclusionary guideline.

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

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

Annotations already indicate read-only and non-destructive behavior, so the description's burden is lower. The description adds valuable context about scoping to the agent's identifier (anonymous IP, BYO key hash, or account ID) and clarifies the listing behavior. It does not contradict annotations.

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

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

The description is four sentences long, front-loaded with the primary action, and each sentence contributes essential information (purpose, usage, scoping, paired tools). No redundant or filler content, making it appropriately sized.

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

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

For a simple tool with one optional parameter and no output schema, the description covers all necessary aspects: what it does, when to use it, how scoping works, and relationships to related tools. It is sufficiently complete for an agent to decide when and how to invoke it.

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

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

Schema coverage is 100%, providing baseline of 3. The description adds semantic value by illustrating example keys (user's target ticker, address, prior research notes) and reiterating that omitting the key lists all saved keys, which enriches understanding beyond the schema's basic description.

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

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

The description clearly states the tool's function with specific verbs 'Retrieve' and 'list all saved keys,' and distinguishes it from siblings by referencing remember and forget. It also specifies the optional condition for listing all keys, making the purpose unambiguous.

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

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

The description explicitly tells when to use the tool ('Use to look up context the agent stored earlier... without re-deriving it from scratch') and mentions the associated tools (remember and forget) for related operations. It also explains the scoping mechanism, providing clear usage context without needing to infer.

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

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

The description states that setting mark_read:true flags events as read and affects subsequent calls, which is a persistent state modification. This directly contradicts the readOnlyHint:true annotation, which implies the tool does not modify data. This is a clear annotation contradiction, so the score is 1.

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 efficiently written, with no fluff. Every sentence provides useful information: purpose, return fields, filtering options, side-effect behavior, and an alternative access method. It is front-loaded with the core purpose and remains compact.

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

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

Despite having no output schema, the description explains return values (source, citation_uri, raw payload). It covers filtering, mark_read side effects, and polling suitability. The parameter details are left to the comprehensive schema, but the description provides the essential behavioral and return context, making it complete for a read/polling tool.

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

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

The schema covers 100% of parameters with descriptions, so the baseline is 3. The description adds value by explaining the behavioral effect of mark_read (so the next call only shows newer events) and providing a concrete example for type (sec_8k). This goes beyond the schema, justifying a 4.

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

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

The description opens with a specific verb and resource: 'Pull fired events from your subscription feed.' It clearly defines the tool's function and distinguishes it from sibling tools like recent_changes or list_subscriptions by focusing on alert events and the persisted feed. The inclusion of source, citation_uri, and raw payload further clarifies its niche.

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

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

The description gives clear usage context: you can filter by type and since, and set mark_read to control read state. It also notes that polling works fine and provides an alternative HTTP endpoint for scripts/dashboards. However, it does not explicitly contrast this tool with sibling tools or state when not to use it, so it falls 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 declare read-only, idempotent, open-world, non-destructive. The description adds significant context beyond these: fans out to multiple sources (SEC, GDELT/GNews, USPTO), explains fallback logic and soft-fail behavior, and notes the parallel call nature without contradicting annotations.

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

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

The description is long but every sentence earns its place: query examples, source enumeration, fallback details, parameter clarification, return structure, and alternative tool. It is front-loaded with user intents and well-organized for easy scanning.

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 explicitly states the return shape (changes[], total_changes, pipeworx:// URIs). It covers fallback scenarios, rate-limit handling, soft-fail for patents, and parameter semantics, making it complete for a tool of this complexity.

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

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

Schema coverage is 100% for all parameters, providing baseline 3. Description enriches with `since` usage guidance ('Use 30d or 1m for typical monitoring') and clarifies `value` accepts ticker or CIK, adding value over schema without redundancy.

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

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

The description clearly defines the tool as a change feed for a company over a time window, with specific user query examples. It explicitly distinguishes from sibling tool entity_profile by contrasting dynamic changes with static profiles.

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

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

Provides explicit when-to-use context via natural language intents and directs to entity_profile as the alternative for static data. Also documents fallback behavior (GDELT→GNews) and parameter usage (`since` formats) with typical monitoring recommendations.

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 idempotence and non-destructiveness. The description adds valuable context about persistence ('Authenticated users get persistent memory; anonymous sessions retain memory for 24 hours') and scoping ('scoped by your identifier'), going beyond what annotations provide without contradicting them.

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

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

The description is four sentences, each earning its place: purpose, usage triggers, storage mechanics, and companion tools. It's front-loaded with the primary action and remains dense without fluff.

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

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

For a simple two-parameter write tool, the description covers purpose, usage scenarios, persistence behavior, scoping, and related tools. With no output schema needed and strong annotations, this is 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?

The input schema already documents both parameters with clear descriptions (100% coverage). The description still adds value by explaining that it's a key-value pair and providing example keys and value types, which enhances semantic understanding beyond the schema fields.

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 with a specific verb and resource: 'Save data the agent will need to reuse later.' It also distinguishes itself from sibling tools by explicitly naming recall and forget as companions for retrieval and deletion.

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

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

The description provides clear when-to-use guidance with concrete examples ('a resolved ticker, a target address, a user preference, a research subject'). It also implies when not to use it by mentioning the companion tools recall and forget, creating a complete usage model.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and non-destructive. The description adds valuable behavioral context: it cascades through multiple lookup endpoints, replaces 2-3 manual lookups, degrades gracefully (if GLEIF/OpenFIGI unavailable, EDGAR still returns), and handles unresolved identifiers explicitly. This goes beyond the annotations and reveals internal complexity.

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

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

The description is quite long (over 200 words) and includes extensive detail about the company resolution process, sources, and degradation behavior. While it is well-structured (starting with examples, then general purpose, then type details), it could be more concise. Several sentences elaborate on internal mechanics that might be better placed in an output schema or separate documentation.

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 bears the burden of explaining return values. It does so adequately: for 'company', it mentions identifiers (CIK, ticker, LEI, FIGI) with source labels and explicit unresolved fields; for 'drug', it mentions RxCUI, ingredient, brand, and citation. It also covers graceful degradation and internal cascading. The description is comprehensive enough to set expectations, though a formal output schema would be more precise.

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% – both parameters have detailed descriptions. The tool description adds examples of natural language queries but does not provide new information beyond what the schema already states for the 'type' and 'value' parameters. The schema already explains input formats (ticker, CIK, name for company; brand/generic for drug), so the description adds minimal extra value for 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 immediately states the tool's purpose with concrete examples ('What's the ticker for...', 'find the CIK for...') and explicitly says it resolves a name to canonical identifiers. It clearly distinguishes itself from sibling tools by stating 'Use FIRST whenever you have a name but need an ID' and positioning it as a prerequisite for other tools. The scope is well-defined with two supported entity types.

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

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

The description provides explicit when-to-use guidance ('Use FIRST whenever you have a name but need an ID') and gives practical query examples. However, it does not explicitly mention when not to use this tool or suggest alternatives among the sibling tools (e.g., entity_profile, compare_entities). The guidelines are clear but lack exclusionary 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 meaningful behavioral details: it probes each entity with ai_visibility_check, ranks results, and returns a ranked list with score, confidence, and signal density. This goes beyond annotations and enriches the agent's understanding of the tool's operation.

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, front-loaded with the core purpose, and every sentence adds value. It avoids redundancy and unnecessary detail, making it 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?

Given the tool's complexity (4 params, no output schema), the description is complete: it explains the process, use case, and output format. The schema covers parameter details, and annotations cover safety. No significant 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 description coverage is 100%, so the schema already documents all parameters. The description adds some context (entities as 'your brand + N competitors') but does not add significant new meaning beyond the schema. Baseline 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 a specific verb ('Compare') and resource ('AI visibility across multiple entities side-by-side'). It distinguishes itself from the sibling ai_visibility_check by emphasizing side-by-side comparison and ranking, making its unique value obvious.

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 a clear use case ('competitive AI-marketing audits') and an example question, which implies appropriate scenarios. However, it does not explicitly name alternatives or state when not to use it, so it lacks full exclusionary guidance.

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

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

Beyond the annotations (readOnly, idempotent, etc.), the description discloses key behaviors: composite fan-out, partial failure degradation, the 5-30s first-measurement latency for bundlephobia, and the sources_failed field. This gives the agent accurate expectations for real-world usage.

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

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

The description is dense but well-structured, front-loading the core purpose and use case, then listing return fields and failure behavior. Every sentence carries necessary information, though the length is slightly high due to the composite nature of the tool.

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

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

With no output schema, the description fully compensates by enumerating the summary block fields, per-advisory details, links, alternative versions, and the sources_failed mechanism. It also covers ecosystem limitations and latency, making the tool's behavior predictable and complete for the agent.

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

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

The input schema already provides 100% coverage for 'package' and 'version', including the default-latest behavior. The description adds contextual meaning around the tool's purpose but does not add parameter-specific semantics beyond what the schema already states, so the high-coverage baseline applies.

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

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

The description clearly identifies the tool as a composite 'should I add this npm package' check, specifying the two data sources (deps.dev and bundlephobia) and the exact question it answers. It distinguishes itself from sibling tools by naming its scope (NPM ecosystem) and the specific data it aggregates.

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 usage guidance: 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me"'. It also gives an exclusion/alternative by stating NPM-only in v1 and directing other ecosystems to deps.dev:version directly.

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?

Even with readOnlyHint=true, the description adds rich behavioral detail: returns passages with character offsets and similarity scores, uses BGE-base-en embeddings with 500-char overlapping windows, and caps at 200K chars with truncation flagging. This goes well beyond the annotations.

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

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

The description is four sentences but each is dense with distinct value: purpose, use case, pairing, and technical details. It is front-loaded and well organized, though slightly longer than strictly necessary.

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

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

For a tool with no output schema, the description fully explains return format (passages with offsets and similarity scores), algorithm, windowing, and truncation behavior. Combined with annotations and 100% schema coverage, it leaves no critical gaps.

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

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

Schema description coverage is 100%, so each parameter is already documented. The description adds minor context (e.g., 'text you already pulled', 'natural-language query', 'top-N passages') but largely echoes 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 'Semantic search INSIDE a fetched record' with a specific verb and resource, and distinguishes it from siblings by framing it as a companion to ask_pipeworx_grounded. The scope (search within a text you already have) 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 explains when to use it ('when the record is too big to cram into the prompt') and how it relates to the alternative ask_pipeworx_grounded. The pairing suggestion ('fetch with the gateway, ground over relevant passages') gives clear usage direction.

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 key behavioral traits beyond annotations: OAuth account requirement, phone verification for SMS, SMS daily cap, and the always-on feed. However, it omits the webhook delivery channel and two subscription types, which are only documented in the schema.

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 information-dense and front-loaded with the primary purpose, followed by requirements, types, and delivery options. It is efficient but somewhat dense and omits some schema details, making it less clear than it could be.

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 and nested parameters, the description should explain return values and all options. It does state the return value and key constraints, but misses two subscription types and the webhook channel, leaving significant gaps for a tool of this complexity.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds significant value by providing concrete examples for sec_8k, polymarket_edge, and fred_series, and clarifying delivery constraints. It does not cover all types (missing patent_grant, clinical_trial) nor webhook, but still enhances understanding.

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

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

The description clearly states the tool's function: 'Create a proactive monitoring subscription to a live-data event stream. Returns the new subscription id.' It also lists supported types, distinguishing it from sibling tools like list_subscriptions, unsubscribe, and recent_alerts.

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

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

The description provides clear context, including the OAuth account requirement and the ability to pull alerts via recent_alerts or the registry URL. However, it does not explicitly state when to choose this tool over alternatives or when not to use it.

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

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

The description adds meaningful context beyond the readOnlyHint and idempotentHint annotations by explaining that the tool returns live catalog data and that results are category-bucketed. It also discloses the dynamic behavior of the optional 'topic' parameter. It does not mention potential limitations like rate limits or response size, but annotations already cover safety, so this is sufficient.

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

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

The description is well-structured and front-loaded with example queries that immediately convey the tool's purpose. Every sentence adds value: returns, categories, parameter behavior, and usage guidance. Despite its length, it is concise with no redundant or vague phrasing.

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

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

Given the simple interface (0 required parameters, optional topic) and no output schema, the description adequately covers return structure (category-bucketed examples with tool+argument shape) and calling conventions. It could go further by detailing the exact response format, but for a discovery 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?

While the input schema covers 100% of parameters, the description enriches the meaning of the 'topic' parameter by giving concrete examples ('finance', 'pharma', 'betting') and explaining the effect of omitting it (cross-category spread). This goes beyond the schema's description, justifying a score above the baseline of 3.

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: it is the onboarding entry point for new Pipeworx agents, returning category-bucketed example questions with tool and argument shapes. It distinguishes itself from siblings by positioning itself as the 'FIRST' tool to use when unfamiliar with Pipeworx, and specifically references meta-tools like ask_pipeworx and entity_profile.

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

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

The description provides explicit context on when to use this tool: 'Use this FIRST when you do not yet know what Pipeworx can do for you, or to learn how to call the meta-tools.' It also explains the difference between calling with no arguments versus passing a topic. However, it does not explicitly name alternatives or state when NOT to use this tool, so it falls 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?

The description adds significant behavioral context beyond annotations: it explains ownership enforcement, deactivation (not deletion), and that historical events remain available via recent_alerts. This complements the idempotentHint and destructiveHint annotations.

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

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

Three concise sentences front-load the core action, then add important constraints and side effects. 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 single-parameter mutation, the description covers the operation, ownership restrictions, and the soft-delete behavior. Despite lacking an output schema, it provides enough context for an agent to understand side effects.

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

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

Schema coverage is 100% for the 'id' parameter, which is well described as the subscription ID returned by subscribe. The description adds ownership context but does not fundamentally change parameter semantics beyond what the schema already provides.

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

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

The description clearly states the tool cancels a subscription by ID, using a specific verb and resource. It distinguishes from siblings like subscribe and list_subscriptions by focusing on cancellation.

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

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

The description implies when to use the tool (to cancel subscriptions) and provides a constraint (ownership enforced), but does not explicitly mention alternatives or when-not-to-use scenarios. It is clear enough for most cases.

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

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

Beyond the readOnly/idempotent annotations, the description discloses critical behavioral details: the distinction between 'could_not_verify' (system failure, no evidence) and 'unsupported' (no source exists), and explicitly warns callers not to treat 'could_not_verify' as evidence. It also describes the two internal pipelines (structured SEC EDGAR vs. grounded pipeline) and the return structure (verdict, citation, reasoning), providing deep transparency.

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

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

The description is a single dense paragraph, but every sentence contributes unique information: trigger phrases, usage, routing, return values, and caller warnings. It is slightly long but well-structured with a clear progression from what it does to how to interpret results, and the critical 'IMPORTANT' caveat is set apart. Minor improvement would be bullet points, but it remains efficient.

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

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

Given the tool's complexity (diverse claim types, two pipelines, nuanced verdicts) and no output schema, the description covers the essential return semantics, including verdict values and error handling. It omits details like how to display 'approximately_correct' versus 'confirmed' or how to surface the tolerance math, but these are not critical for an agent to invoke the tool correctly.

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

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

Schema coverage is 100% for both parameters, but the description adds substantial extra context: it explains how tolerance_pct overrides the claim-wording-implied tolerance, gives a default (capped at 5), and provides a concrete use case (set 1-2 for hallucination detection). It also gives realistic examples for the claim parameter beyond the schema's examples.

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

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

The description clearly states the tool performs natural-language claim verification against authoritative sources, using specific trigger phrases like "fact check" and "verify the claim that." It distinguishes itself from generic Q&A tools by emphasizing verdict-based output and the replacement of multi-step sequential calls, making its unique purpose unmistakable.

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

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

The description explicitly says to use the tool 'whenever the agent needs to check whether something a user said is factually correct,' providing clear guidance on when to invoke it. It also explains the routing behavior for company-financial versus other claims, but it does not name alternative tools or explicitly state when *not* to use this tool (e.g., for open-ended research), which prevents a top score.

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