Hurricanes

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds key facts: 'Keyless' (no auth needed) and 'Returns an empty list in the off-season', which provide behavioral context 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 concise, using bullet-like phrasing (dash-separated fields) and separate short sentences for filters, keyless, and seasonal behavior. Every sentence adds unique value with no redundancy.

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

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

For a simple read-only listing tool with one optional parameter and no output schema, the description covers purpose, capabilities, and edge cases (off-season). Missing aspects like data freshness are minor given the tool's simplicity.

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

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

Schema coverage is 100% with a clear description of the 'basin' parameter. The description only repeats 'Filter by basin', adding no new semantic value beyond what the schema provides.

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

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

The description explicitly states 'List currently active tropical cyclones' with a specific source (US National Hurricane Center) and enumerates the returned fields. It distinguishes from sibling tools by focusing on active storms listing, while 'storm_details' likely provides per-storm info.

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

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

The description implies usage for listing active storms and notes that empty list is returned in off-season. However, it does not explicitly compare to alternatives like storm_details or specify when not to use this tool.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false. The description adds behavioral context: default model (free), optional Anthropic probe with BYO key, and return structure (score, confidence, signals, raw_response). No contradictions. This additional context enhances transparency beyond annotations.

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

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

Three sentences, no filler. Essential information is front-loaded: the tool's core function, default model, optional API key behavior, and return structure. Every sentence carries weight.

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

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

Given the simple parameter set (4 params, 100% schema coverage) and rich annotations, the description covers all relevant aspects: purpose, use cases, model selection, API key handling, and return format. No output schema exists, but the description summarizes the return fields sufficiently. The tool's complexity is low, and the description matches 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 description coverage is 100%, so the schema already documents all parameters. The description adds meaning by explaining the default model behavior, how the API key is passed, and the optional context parameter's purpose. This raises the value beyond the schema alone, 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 uses a specific verb-resource pair ('Probe...LLMs for what they know...score visibility') and clearly distinguishes the tool from siblings by focusing on multi-model visibility scoring. Siblings like 'compare_entities' or 'scan_competitor_ai_presence' have different purposes, so this tool's unique role is well established.

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.' It also explains the default model and when to use an API key. However, it does not explicitly state when not to use this tool or name direct alternatives among siblings, leaving some ambiguity for the agent.

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

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

The description discloses meaningful internal behavior: it routes the question, fills arguments automatically, and returns structured answers with stable pipeworx:// citation URIs. It also adds important turn-level caveats like 'one fast call per turn' and notes that ask_pipeworx_grounded is the better choice when grounded/precise answers are required. These traits go well beyond the readOnly/openWorld/idempotent annotations and give the agent a realistic model of how the tool behaves.

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 the most important directive ('PREFER OVER WEB SEARCH') followed by scope, examples, and alternatives. Every major section earns its place given the large sibling set and the need to differentiate this router from many other tools. It loses one point because the final breaking-news remark and the 'one fast call per turn' caveat are somewhat awkwardly placed, making the text a bit more sprawling than 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 complex router tool with no output schema, the description provides everything needed: when to use it, what it does internally, what the return format looks like (structured answer with stable citation URIs), concrete example queries, and clear routing to sibling tools in edge cases. There are no significant gaps that would leave an agent unsure about selecting or invoking the tool.

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

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

The input schema already documents the single meaningful parameter and all aliases at 100% coverage, so the baseline is 3. The description adds example queries and clarifies that the argument is a natural-language question, but it does not add substantive semantics beyond what the schema already provides. The examples in the schema itself reinforce this, so no deduction is needed.

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

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

The description clearly identifies ask_pipeworx as a general-purpose router that sends natural-language questions to the appropriate tool among thousands of verified sources and returns a structured answer with citation URIs. It sharply distinguishes itself from siblings by positioning itself as the default starting point and explicitly naming alternatives. This is a specific verb+resource definition, not a tautology.

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

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

The description gives explicit when-to-use guidance: prefer over web search for authoritative structured data, use for factual lookup triggers like 'what is', 'find', and 'get the latest', and even says to use it even when web search might work. It also names exclusions and alternatives: pipeworx_trending for latest, bet_research for rough counts, entity_profile for profile one-pagers, ask_pipeworx_grounded for grounded answers, and deep_research for broad multi-part questions. No inference is required.

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

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

The description discloses that this is the experimental edge, that candidates are enabled live only under test, and that there is currently no active candidate—behavior not captured by the readOnly/idempotent/destructive annotations. The 'falls back to nothing' clarification confirms it is a full working router rather than a wrapper, adding valuable operational context.

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

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

The description is dense but every sentence earns its place: identity, current state, usage instruction, and fallback behavior are all covered in a compact block. The most decision-relevant information about beta versus stable and current parity 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 tool with a rich schema and annotations, the description provides the missing context an agent needs: why this variant exists, when to prefer it, that it has the same response shape, and that it is fully functional. Nothing critical is left unexplained.

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 every parameter is already documented as an alias for question, so the description does not need to add parameter-level detail. The generic 'same arguments' reference adds no 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 identifies this as a beta version of ask_pipeworx: an identical universal router with the same 5,798 tools, arguments, and response shape. It distinguishes itself from the stable ask_pipeworx sibling while stating exactly what it does.

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

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

It gives an explicit trigger: use it like ask_pipeworx when you want the newest routing, and explains that results are compared against the stable router to decide merges. It also notes no candidate is currently active, so it matches ask_pipeworx exactly, preventing unnecessary beta usage.

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

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

Beyond the annotations, the description discloses return shape, fields like evidence, confidence, fetched_at, and explicit refusal reasons such as not_in_source and data_truncated. It also surfaces the extra LLM call cost and the tool's strict 'ONLY what the tool result contains' behavior. No contradiction with the readOnly, openWorld, idempotent, or non-destructive annotations.

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

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

The description is dense but every sentence earns its place: it names the mode, explains the routing and evidence constraint, specifies success and refusal return shapes, gives concrete use cases, and ends with a cost-based routing tradeoff. It is front-loaded with the most decision-relevant line.

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 fully documenting return values and refusal reasons. It covers the single required parameter through schema aliases, explains behavior, cost, and when to choose the sibling tool. Nothing an agent needs to invoke this tool safely and correctly 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?

Schema description coverage is 100%: every parameter is an alias for the same natural-language question field and the schema documents it thoroughly. The description adds no parameter-level meaning, but it does not need to because the schema already carries the full burden.

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

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

The description clearly identifies this tool as a hallucination-resistant answer mode for high-stakes reads, and explicitly contrasts it with sibling ask_pipeworx by highlighting the same routing but stricter evidence-based extraction. This distinguishes it from ask_pipeworx and ask_pipeworx_beta without ambiguity.

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

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

The description gives explicit when-to-use guidance: use whenever an answer will be quoted, cited, or acted on and the agent must not invent facts. It also states the alternative and preference rule: prefer ask_pipeworx for casual lookups. This is clear, actionable routing advice.

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

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

Annotations indicate read-only, idempotent, non-destructive. Description adds extensive behavioral context: market resolution, classification, fan-out, response shapes, resolver contract, safety mechanisms (low-confidence, closed markets, wide spreads), and resolution-rule risk. No contradiction with annotations.

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

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

Very long description but well-structured with labeled sections (RESPONSE SHAPES, RESOLVER CONTRACT, etc.). Front-loaded with purpose and usage. Slightly verbose but necessary given tool complexity.

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

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

No output schema, but description fully compensates by detailing market fields, analysis fields, evidence keys, resolver contract, parent event extractor, news fields, safety behaviors, and resolution-rule risk. Comprehensive for a complex research tool.

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

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

Schema coverage is 100%, and description significantly enhances understanding: explains market parameter accepts slug, URL, or question text; describes depth enum (quick vs thorough) and include_raw boolean with clear trade-offs. Adds practical 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?

Clearly states the tool researches a Polymarket bet by pulling Pipeworx data in one call. Distinguishes itself from siblings like polymarket_arbitrage and polymarket_edges by focusing on deep-dive research for a specific question.

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

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

Provides explicit use cases: 'should I bet on X', 'what does the data say about Y', 'is there edge in Z'. Lacks explicit when-not-to-use or named alternatives, but the context with sibling tools provides enough differentiation.

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, etc. Description adds valuable behavioral details: company data from latest 10-K with off-calendar fiscal year handling, drug data from FAERS, results sorted by primary metric, citation URIs. 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?

Front-loaded with trigger phrases, then explains data sources and behavior. Every sentence adds value, though slightly dense. Could be slightly more streamlined but efficient for the information density.

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 2 params and no output schema, description covers input types, output (paired data + citations), sorting order, and replaces 8-15 lookups. Fully complete for the tool's purpose.

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

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

Schema coverage is 100%. Description adds meaning with examples (tickers vs drug names), clarifies off-calendar handling, and explains sorting behavior. Baseline 3 but extra context justifies 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?

Description uses specific verbs like 'compare', 'rank', 'head to head' and clearly states it provides 'side-by-side comparison of 2–5 companies or drugs in ONE parallel call.' It distinguishes from siblings by emphasizing one call vs sequential 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?

Explicit guidance: 'ALWAYS PREFER over sequential single-pack lookups when comparing entities.' Provides example query patterns. No explicit when-not-to-use, but context is clear.

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

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

Annotations declare readOnly, idempotent, openWorld, non-destructive. Description adds substantial behavior: parallel decomposition, gaps[] for unanswered facets, "never invented", stable fetchable citations, contradictions[] for standard/thorough, large-record excerpting, expected latency, and paid-plan requirement for thorough. 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?

Dense and front-loaded with the auth gate and sibling routing, but it is long and repeats some depth semantics already present in the schema (e.g., gap recovery and contradictions). Still, almost every sentence carries actionable information.

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

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

For a complex parallel research tool with no output schema, this covers prerequisites, scope, output packet shape, depth differences, citation resolvability, latency, gap/contradiction behavior, and alternatives. An agent gets enough to invoke correctly and interpret results.

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

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

Schema coverage is 100%, so the schema already documents both parameters. The description adds meaning beyond it with concrete question examples ("compare X and Y's regulatory + financial exposure"), clarifies what broad/multi-part questions look like, and ties depth choices to behavior and pricing. Minor redundancy with schema depth text prevents a 5.

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?

States a specific verb and resource: "Grounded multi-source research across Pipeworx's 1517 STRUCTURED data sources". Explicitly differentiates itself from open-web search and names ask_pipeworx as the single-lookup alternative, making sibling distinction clear.

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

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

Provides explicit when-to-use guidance: "Best for broad/multi-part questions over structured data", "For a single lookup use ask_pipeworx instead", and "If you are not signed in, use ask_pipeworx". Covers auth constraints and depth tier restrictions as routing conditions.

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

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

Annotations provide readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds behavioral traits beyond annotations: returns top-N most relevant tools, each result ready to call directly without second schema lookup. No contradiction; description adds useful context.

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

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

The description is approximately 5 sentences, front-loaded with the core purpose. Every sentence contributes value: purpose, usage context, supported domains, return value details, and a call to action. No unnecessary words.

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

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

Given no output schema, the description explains return values (top-N tools with names, descriptions, schemas). It covers parameter aliases and limits. For a discovery tool with 6 parameters (1 required), the description provides sufficient context for an agent to invoke it correctly.

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

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

Schema coverage is 100% with all 6 parameters documented. The description explains the main parameter 'query' with natural language description and aliases, and notes the 'limit' parameter's default and max. This adds meaning beyond the schema definitions.

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

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

The description clearly states the tool's purpose: 'Find tools by describing the data or task.' It lists many domains (SEC filings, financials, etc.) and indicates it returns top-N relevant tools with names, descriptions, and schemas. This distinguishes it from sibling tools, which are domain-specific, making its unique role clear.

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

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

The description gives explicit guidance: 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' It also provides example queries and a list of supported domains. While it lacks explicit when-not or alternatives, the context is clear for a discovery tool.

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

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

With annotations already indicating readOnly, openWorld, idempotent, and non-destructive behavior, the description adds substantial behavioral context: it fans out across many named sources, returns structured sections, explains that empty sections are real 'no data' rather than bugs, describes graceful degradation (USPTO sunset soft-fail), and clarifies the resolved:false path for private companies. This goes well beyond the annotation hints.

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

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

The description is long, but it front-loads the most important usage examples and the core promise before enumerating output details. The dense semicolon-separated listing of return fields and source behaviors is justified given the tool's complexity and the absence of an output schema, though a more structured layout would improve scannability.

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

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

Given the tool's complexity, no output schema, and the rich annotations, the description is highly complete: it names all data sources, spells out each returned field, explains failure semantics, describes the private-company edge case, and gives exact accepted input forms. An agent has enough context to invoke the tool correctly and interpret its results.

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

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

The input schema already documents both parameters at 100% coverage, so the baseline is 3. The description adds meaningful value by providing concrete examples ('AAPL', '0000320193', 'Moderna'), explaining that 'company' and 'ticker' are interchangeable, and clarifying how names resolve via SEC EDGAR. This exceeds mere schema repetition without being essential to understand the parameters.

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

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

The description opens with concrete query examples and states a specific verb+resource: 'full cross-source profile of a US public company in ONE parallel call.' It clearly differentiates itself from single-pack SEC/XBRL/news lookups and from sibling tools like resolve_entity by emphasizing the holistic multi-source profile behavior.

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

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

The description gives explicit when-to-use guidance: whenever the user asks for a holistic view ('Tell me about X', 'research Acme', 'brief me on Tesla'), and explicitly says to prefer this over chaining single-pack lookups. It also specifies accepted input shapes (ticker, CIK, name) and what happens for private companies, leaving no ambiguity about invocation 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 destructiveHint=true and idempotentHint=true. Description confirms deletion but adds no behavioral context beyond what annotations provide.

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

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

Two concise sentences, front-loaded with action, no 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?

Simple tool with one parameter and no output schema; description fully covers purpose, usage, and parameter meaning.

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

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

Schema coverage is 100% with parameter 'key' described as 'Memory key to delete'. Description adds no additional 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?

Description states 'Delete a previously stored memory by key' with a specific verb and resource, and distinguishes from siblings by mentioning 'remember and recall'.

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

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

Explicitly states when to use it: 'when context is stale, the task is done, or you want to clear sensitive data'. Also mentions pairing with siblings for context.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds behavioral context: it fetches the page, extracts title/description/key links, and emits standard llms.txt markdown format. It also states the output is a single text blob ready for deployment. 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 two sentences with a bulleted list of use cases. It is front-loaded with the core action ('Generate a production-ready llms.txt file...') and provides all necessary information without redundancy. Every sentence contributes to understanding.

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

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

Given the tool's simplicity (2 params, no output schema, no nested objects), the description is fully complete. It covers purpose, usage, behavior, and output format. It does not need to describe return values since no output schema exists, and it clearly states the output is a markdown text blob.

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

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

Schema coverage is 100%, so parameters are fully documented in the schema. The description adds meaning by explaining that the 'url' parameter is the site to summarize and that the tool extracts title/description/key links. It does not explicitly mention 'max_links', but the schema covers it with a default and max value. The description adds value beyond the raw schema.

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

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

The description clearly states the tool generates a 'production-ready llms.txt file' for a given URL, specifically targeting AI crawlers like ChatGPT, Claude, and Perplexity. It uses specific verbs ('generate', 'fetches', 'extracts', 'emits') and a clear resource (llms.txt file). The tool is distinct from sibling tools, which focus on weather, betting, research, etc.

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

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

The description lists explicit use cases: getting a client's site indexed, drafting for own projects, auditing competitors. It provides clear context for when to use the tool. However, it does not explicitly state when not to use it or provide alternatives, though the uniqueness of the tool makes exclusions less necessary.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds return field details but no additional behavioral traits.

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

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

Two sentences, no redundant information, front-loaded with purpose and return details.

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 (1 optional param, no output schema, rich annotations), the description fully covers purpose, usage, and return fields.

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 boolean parameter. Description adds no extra meaning beyond what the schema provides.

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

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

Description clearly states verb 'List' and resource 'caller's active subscriptions', and specifies return fields. Distinguishes from sibling tools like subscribe/unsubscribe.

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

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

Explicitly advises when to use: 'review what you're monitoring before adding more or to find an id to cancel', providing context for usage vs alternatives.

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

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

Annotations are all false, so the description carries the full burden and excellently discloses behavior: claim_token return for anonymous filing, later retrieval by re-invoking with the token, rate limit (5/day/identifier), free-of-charge, and no quota impact. 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 a single dense paragraph but every sentence earns its place: purpose, use cases, exclusions, claim_token flow, rate limit, and cost. It's front-loaded with the primary action and quickly moves to actionable guidance. No filler or tautology.

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

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

Despite no output schema, the description fully explains return behavior: anonymous filing returns a claim_token, later invocation with that token returns status and resolution details. It also covers rate limiting, free access, and who reads the feedback. Complete for a feedback 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 has 100% parameter descriptions already, but the tool description adds crucial semantics beyond the schema: clarifies claim_token is for reading prior feedback responses, explains the 'no other arguments' condition when using it, and gives message content guidance ('don't paste the end-user's prompt'). This adds value above the structured 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?

Description states a clear verb and resource: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It enumerates specific use cases (bug, feature/data_gap, praise) which distinguishes it from sibling tools like ask_pipeworx or discover_tools, none of which serve feedback.

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

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

Explicit when-to-use guidance: 'Use when a tool returns wrong/stale data (bug), when a tool you wish existed isn't in the catalog (feature/data_gap), or when something worked surprisingly well (praise).' Also provides a clear exclusion for tools from other MCP servers and a disambiguation rule ('Not sure? Pipeworx tool names are the ones this connection lists').

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds unique behavioral insights: data source ('CF analytics-engine'), no PII, and caching behavior ('Cached 5min-1h depending on window'). No contradictions.

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

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

Three sentences: first defines the output, second lists use cases, third adds technical details. Information is front-loaded and every sentence earns its place with no fluff.

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

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

Given the tool's simplicity (1 optional param, no output schema, all safety annotations), the description fully covers input meaning, real-world use cases, data provenance, privacy, and caching. No gaps remain.

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

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

Schema coverage is 100% with one optional parameter (window) having a full enum. The description enriches the enum: 'Shorter windows surface what's hot right now; longer windows show steady-state demand.' This adds context beyond the enum labels.

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

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

The description uses a specific verb ('Returns') and identifies the exact resources ('top tools, top packs, and total call volume') over configurable windows. It clearly distinguishes itself from sibling tools like 'ask_pipeworx' or 'discover_tools' by focusing on agent call activity data.

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

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

Three explicit use cases are listed, covering discovery ('what data sources are hot'), verification ('confirming a popular tool'), and alignment ('whether your use case aligns'). Lacks explicit when-not-to-use or alternative tool mentions, but the guidance is clear and helpful.

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

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

Beyond the annotations (readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false), the description adds critical behavioral context: partition-check logic (sum of YES prices ≈1), semantic anchor (Jaccard similarity ≥0.30), partition filter (placeholder slugs), fill check against CLOB depth, and conditions where trades should not be executed. No contradictions with annotations.

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

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

The description is lengthy but well-organized with clear section headers (SEMANTIC ANCHOR, PARTITION FILTER, FILL CHECK). Every sentence adds value, though the density of information could be slightly reduced for skimmability without losing critical details.

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 fully specifies the response structure (opportunities[] with gap_pp, suggested_trade, etc., partition_check fields). It covers all modes, fill check, and error conditions (e.g., placeholder fraction >20% returns null). No gaps remain for agent understanding.

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

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

With 100% schema description coverage, both parameters already have descriptions. The tool description significantly enriches them by explaining the internal behavior of each mode (e.g., event mode walks child markets, topic mode searches related events) and providing specific examples of accepted values.

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

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

The description explicitly states the tool finds arbitrage opportunities via monotonicity violations and partition-sum checks. It clearly distinguishes three modes: no-args trending scan, event mode for specific markets, and topic mode for cross-event scanning. This provides precise purpose and differentiation from sibling tools.

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

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

The description offers detailed guidance on when to use each mode: no args for trending scan, event for a specific market (recommended), topic for cross-event scanning. It explains the limitations of single-event mode and when cross-event mode is needed. It also references polymarket_fill_risk for custom sizing, providing clear alternatives.

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

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

Annotations already indicate read-only and idempotent behavior. The description adds valuable behavioral details: 1-hour caching at the KV level, edge calculation net of slippage, per-segment response structure, and diagnostic information. No contradictions with annotations.

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

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

The description is well-structured with clear sections (model families, knobs, response details) and front-loaded with a concise purpose statement. However, it is quite long and could be slightly tightened without losing critical technical details.

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 the tool's complexity (9 parameters, no output schema), the description covers all essential aspects: return structure (by_segment with diagnostics), model family details, edge calculation methodology, parameter knobs, and caching policy. No gaps are apparent.

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

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

Schema coverage is 100% with good descriptions. The description further enhances parameter understanding by explaining the tradeable-edge knobs (min_liquidity, max_spread_pp, min_partition_leg_kelly) and their interaction with the edge calculation, adding context beyond the schema.

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

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

The description explicitly states the tool's purpose: 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price.' It is built for daily opportunity discovery ('what should I bet on today') and clearly distinguishes itself from sibling tools like polymarket_arbitrage by covering multiple model families.

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 context for usage (daily opportunity scanning, avoiding paging through hundreds of markets) but does not explicitly mention when to use alternatives or when not to use this tool. Sibling tools like polymarket_arbitrage or polymarket_edge_tracker exist for more specific tasks, but no guidance is given on when to prefer them.

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, so the description does not need to repeat safety. It adds useful behavioral details: how trends and decay are computed, that snapshots are daily with gaps, and the 60-day TTL limitation.

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

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

The description is dense and front-loaded with purpose, but it is verbose and could be more concise. It contains multiple clauses and details that, while informative, could be streamlined for quicker comprehension.

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 compensates for the lack of output schema by thoroughly explaining the response structure: tracked[], expired[], snapshot_dates[]. It also describes limitations and data sources, providing a complete picture for a data retrieval tool.

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

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

Schema coverage is 100%, and the description adds default values and explains the effect of 'days' (lookback) and 'window' (snapshot family). This provides marginal value beyond the schema, but does not significantly enhance understanding of parameter semantics.

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: providing edge persistence and decay telemetry from daily snapshots, answering 'how long has this edge existed and is it shrinking?'. It uses specific verbs like 'tracked', 'expired', and distinguishes from the sibling 'polymarket_edges' by focusing on time-series and decay.

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 the tool is for historical analysis of edge persistence but does not explicitly state when to use it versus alternatives or provide exclusions. The context is clear but lacks direct guidance on when-not-to-use or comparisons with siblings.

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

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

Annotations already indicate a safe, read-only, idempotent operation. The description adds significant behavioral context: explains ladder walking, return fields (top_of_book, vwap_fill_price, slippage_pp, etc.), partial fill risks, and forced directional risk. No contradiction with annotations.

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

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

Description is long but well-structured with clear sections for single-market and basket modes, using all-caps keywords for emphasis. Front-loaded with purpose. Could be slightly trimmed but appropriate for complexity.

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

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

No output schema, but description thoroughly lists return fields for both modes, explains failure modes (thin_legs, cannot_fill verdict), and provides risk warnings. Covers everything an agent needs to understand tool behavior and outputs.

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

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

Schema coverage is 100% so baseline is 3. Description adds value by explaining auto behavior for side in basket mode, details on size_usd interpretation for buys vs sells and settlement notional, and defaults. Goes beyond schema but schema already covers basics.

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

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

Description explicitly states it is a 'Realizable-vs-theoretical edge check against live CLOB order-book depth' and distinguishes between single-market and basket modes with specific inputs and outputs. It also differentiates itself from sibling tools like polymarket_arbitrage and polymarket_edges by stating when to use it before acting on those signals, making purpose very clear and unique.

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

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

Provides explicit guidance on when to use: before acting on polymarket_arbitrage signals or polymarket_edges trades above ~$500. It warns about partial basket fills converting arb to unhedged directional position, the dominant loss mode. This gives clear when/why/alternatives 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?

The description goes far beyond the readOnly/idempotent annotations: it discloses that spreads are gross (Kalshi fees not modeled), that compatibility_warning can be non-empty even when matched_pairs>0, that pairing_unverified is always set in either mode, that null temporal_alignment means 'could not be computed', and that legs with unknown metric_type or match_subtype are never paired. These non-obvious behaviors are essential for correct interpretation.

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

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

The description is dense and front-loaded with the core purpose and the two modes. Labeled sections (TWO MODES, RESPONSE, SAFETY FIELDS, Codes) help an agent navigate a long text. There is minor redundancy (e.g., 'same disclosures apply to both' is repeated in effect) and the description could be tightened with bullet points, but most of the length is justified by the absent output schema.

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

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

Since there is no output schema, the description carries the full burden of explaining return values and edge cases. It covers the response envelope (prices, top_spreads_pp, compatibility fields, temporal_alignment, fees_note, skipped counters), enumerates the compatibility codes, and clarifies ambiguous null semantics. An agent has sufficient information to invoke the tool and interpret its results correctly.

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

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

Schema coverage is 100% with descriptions and examples for each of the three parameters. The description adds critical value beyond the schema by clarifying the mode interaction: `topic` auto-fetches both sides, while `kalshi_event_ticker` and `polymarket_event_slug` override the respective topic-mapped side. This relationship is not inferable from the schema alone.

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

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

The opening line states a specific resource and scope: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' The RESPONSE section further specifies the concrete outputs (leg-by-leg prices and top_spreads_pp). This clearly differentiates it from sibling Polymarket-only tools like polymarket_arbitrage and polymarket_edges by its cross-venue, cross-exchange nature.

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 documents TWO MODES (topic shortcuts vs explicit ticker/slug), explains that explicit parameters override the topic-mapped side, and warns that pre-mapped topics often return compatibility warnings and are not necessarily tradeable. It does not explicitly name sibling alternatives or when-not-to-use conditions, but the mode selection and caveats provide clear practical 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 indicate readOnlyHint and idempotentHint. The description adds scoping detail (by identifier) and pairing behavior, providing useful context beyond annotations without contradiction.

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

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

The description is three sentences, each serving a purpose: action, usage scenario, and scoping. It is front-loaded with the primary function and is free of unnecessary words.

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

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

For a simple read-only tool with one optional parameter and no output schema, the description fully covers what the agent needs: behavior, scope, and pairing with siblings. 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 schema parameter description already explains the key's behavior. The tool description restates this but adds the listing behavior hint, which is helpful but not necessary given the schema.

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

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

The description clearly states the tool retrieves a saved value or lists all keys, with specific examples (ticker, address, research notes). It explicitly distinguishes from sibling tools 'remember' (save) and 'forget' (delete), making the purpose unmistakable.

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

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

The description provides clear usage context: 'look up context the agent stored earlier' and indicates when to omit key to list all. While it pairs with remember/forget, it lacks explicit exclusion guidance for alternatives.

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

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

Annotations provide readOnlyHint, idempotentHint, and destructiveHint, which are consistent with the description. The description adds valuable behavioral details such as the structure of returned events (source, citation_uri, raw payload), the effect of mark_read, and that polling works fine. No contradictions found.

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, which is reasonable but could be slightly tighter. The main action is front-loaded with clear verb and noun, and each sentence adds useful information. Minor verbosity in explaining mark_read and the alternative endpoint.

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

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

Given no output schema, the description sufficiently explains return structure (source, citation_uri, raw payload) and key behaviors. It covers all 5 parameters indirectly through examples and usage notes. Lacks explicit mention of pagination or error handling, but the tool's nature as a read-only fetch is well-covered.

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 each parameter already described. The description reinforces some parameters (e.g., type example 'sec_8k') but does not add significant new meaning beyond the schema. Baseline 3 is appropriate as the description adds minimal extra value.

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 pulls fired events from the subscription feed, specifying the resource and action. It provides specific fields returned (source, citation_uri, raw payload) and distinguishes from sibling tools like list_subscriptions by focusing on event retrieval rather than subscription management.

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 offers practical usage guidance, including how to filter by type and since timestamp, and how mark_read works to control subsequent calls. It also mentions an alternative HTTP endpoint for scripts. However, it does not explicitly contrast with other retrieval tools like search_within or recall, leaving some ambiguity about when to prefer this tool.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds valuable context about the fan-out logic, fallback between GDELT and GNews, and soft-failure for USPTO. 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 relatively long but efficiently packed with information. It fronts example queries and then details behavior. Minor redundancy but overall well-structured.

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

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

No output schema exists, but the description explicitly states the return structure (changes grouped by source, total_changes count, citation URIs). Combined with the detailed parameter guidance, the description is fully self-contained.

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

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

Schema coverage is 100%. The description adds examples and nuances for each parameter (e.g., 'since' format with examples, 'value' accepts ticker or CIK, 'type' only supports company), going beyond the schema descriptions.

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

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

The description clearly states it is a change feed fanning out to multiple sources (SEC EDGAR, GDELT/GNews, USPTO) and distinguishes itself from the sibling tool 'entity_profile' by specifying when to use that instead.

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 entity_profile instead and gives example queries that show typical usage. Does not compare with all siblings but the main alternative is covered.

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

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

Discloses persistence detail (24 hours for anonymous, persistent for authenticated) and scoping by identifier beyond annotations. 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?

Four concise sentences front-loading purpose, with no redundant or irrelevant information. Every sentence earns its place.

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

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

For a write tool without output schema, the description adequately explains storage behavior and usage context. Could mention overwriting semantics but idempotentHint covers safety.

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

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

Schema covers 100% with descriptions; the description adds value by providing example key names (e.g., 'subject_property') and hints at value content, enhancing 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 specifies 'Save data the agent will need to reuse later' with clear verb and resource, and distinguishes from sibling tools 'recall' and 'forget'.

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

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

Explicitly states when to use ('when you discover something worth carrying forward') and gives concrete examples. Also notes session vs persistent scoping and pairs with recall/forget.

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 establish readOnly, idempotent, and non-destructive behavior, and the description adds substantial detail beyond that: internal cascading across multiple lookup endpoints, graceful degradation when GLEIF/OpenFIGI are unavailable, explicit `unresolved` reporting instead of omission, and assertion-nothing behavior with `figi_candidates` on ambiguous matches. This is exactly the kind of runtime-context transparency an agent needs.

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 trigger phrases and purpose, and its later sections are mostly dense with useful caveats. However, several sentences are long and heavily parenthetical, making some details harder to scan at a glance. It earns its length overall, but a bit more structure would improve it.

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

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

For a complex multi-source tool with no output schema, the description covers the essential runtime contracts: what identifiers are returned, how sources are labelled, how unresolved identifiers are surfaced, how ambiguous security matches behave, and what happens when enrichment services fail. An agent has enough context to call the tool correctly and interpret its results.

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

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

Although schema coverage is 100%, the description enriches both parameters considerably: it explains what `type` values map to, lists accepted forms for `value` (ticker, CIK, ISIN, brand, generic name), gives real examples, and warns against passing full noun phrases for bonds because trailing security-class words fail the FIGI lookup. This guidance prevents realistic caller mistakes the schema alone would not.

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

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

The description opens with concrete user utterances ('What's the ticker for…', 'find the CIK for…') and states the core verb-plus-resource: resolve a user-spoken NAME to canonical identifiers other tools need. It also names the supported entity types and the sources of each identifier, making its purpose unmistakable and distinct from sibling tools like entity_profile or compare_entities.

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

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

The description gives an explicit trigger: 'Use FIRST whenever you have a name but need an ID.' It also clarifies input norms, such as passing the issuer exactly as printed for bond lookups. However, it does not explicitly say when not to use this tool or name alternative siblings, so the guidance is strong but not fully exclusionary.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false. The description adds valuable behavioral context: it probes each entity with ai_visibility_check, ranks by score, and returns a ranked list with score, confidence, and signal density. 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 three sentences: first states the primary action, second explains the internal process, third provides a use case and return format. No wasted words, front-loaded with the key purpose. Well-structured for quick comprehension.

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 (multi-entity comparison, no output schema), the description adequately explains the return format (ranked list with score/confidence/signal density) and the relationship to ai_visibility_check. It covers all necessary context for an agent to use the tool correctly.

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

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

Schema description coverage is 100%, so parameters are already well-documented. The description adds context that the first entity is treated as a 'subject' for narrative, but this is minor. It does not add significant new parameter-level meaning beyond the schema, so a baseline score of 3 is appropriate.

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

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

The description clearly states the tool compares AI visibility across multiple entities side-by-side, probing each with ai_visibility_check and ranking results. It explicitly distinguishes from siblings like ai_visibility_check (single entity) and compare_entities (general comparison) by specifying the competitive AI-marketing audit use case.

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

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

The description provides a clear use case example ('does Claude know about us as well as our competitors?') and implies usage for competitive audits. It does not explicitly state when not to use it or name alternative tools, but the context from sibling tools and the description itself offers sufficient guidance.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, destructiveHint. Description adds critical context: partial failures degrade gracefully, first bundlephobia measurement can take 5-30s, sources_failed list on timeout. 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?

Description is relatively long but each sentence adds value. It's front-loaded with purpose, then usage, ecosystem, and failure behavior. Minor redundancy could be trimmed but overall efficient.

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

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

No output schema, so description must explain return values. It does: summary block fields, per-advisory detail, links, alternative versions. Also covers ecosystem constraints and graceful degradation. Fully complete given tool complexity.

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

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

Schema coverage is 100% with descriptions for both parameters. Description adds extra context beyond schema: scoped packages accepted, version defaults to latest, and composite fan-out behavior.

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

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

Description clearly identifies it as a composite check for npm packages, fanning out to deps.dev and bundlephobia. It specifies the purpose ('should I add this npm package to my project') and distinguishes from siblings by being the only tool focusing on dependency scanning.

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

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

Explicitly states when to use: 'whenever an agent asks is X safe / popular / small or what does adding lodash cost me'. Also notes NPM-only in v1 and directs to deps.dev:version for other ecosystems.

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

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

Annotations already cover safety traits (readOnly, openWorld, idempotent). Description adds specific technical details: BGE-base-en embeddings, 500-char windows, 200K char cap with truncation flag. 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?

Description is somewhat long but every sentence adds value, with key information front-loaded. Could be slightly trimmed, but effective.

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

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

Given rich annotations and schema, the description fully covers behavior, limits, and usage context. No output schema needed for this simple search 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 has 100% coverage, so baseline 3 is appropriate. Description adds example queries and char limit clarification, but schema already handles parameter documentation adequately.

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

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

The description clearly states it performs semantic search inside a fetched record, with examples like SEC 10-K body. It distinguishes from siblings (e.g., ask_pipeworx_grounded) by explaining its role in the workflow.

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 ('record too big to cram into the prompt') and notes it pairs with ask_pipeworx_grounded. Provides clear context and alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, etc., covering safety. The description adds that it is 'Keyless' (no API key required) and details the product links included, providing additional context beyond annotations.

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

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

Two sentences with no wasted words. The purpose is front-loaded with the key verb and resource, followed by specifics and the keyless note.

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

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

For a tool with one parameter, full schema coverage, and comprehensive annotations, the description covers all necessary context: what it does, how to specify the storm, what data is returned, and authentication status.

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 description adds value by providing explicit examples ('al052026', 'Douglas') inline, clarifying the parameter format beyond the schema's short 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 uses a specific verb ('Full details for one active storm') and clearly identifies the resource (storm by id or name), with examples of id format and name. It distinguishes from sibling 'active_storms' which lists storms.

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

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

The description implies usage when complete details on a specific storm are needed, but does not explicitly state when not to use or mention alternatives beyond the implicit contrast with 'active_storms'. Still clear enough for effective selection.

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

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

Adds significant behavioral context: auth requirements, type-specific filters, delivery channels with limitations (e.g., SMS cap, phone verification). However, description implies non-idempotent creation, contradicting idempotentHint=true annotation.

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

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

Description is comprehensive but slightly verbose. Information is front-loaded with purpose and return value, then details. Could be more structured with bullet points.

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 (3 params, nested objects, no output schema), the description is thorough. It covers return value, auth, limitations, examples, and behavior for each type and delivery channel.

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

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

Schema coverage is 100%, and description adds substantial meaning: explanations for each subscription type with concrete examples, delivery channel details, and verification steps. This goes well beyond the schema.

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

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

Description clearly states the tool creates a subscription to a live-data event stream and returns a subscription ID. It differentiates 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?

Provides explicit context on when to use (proactive monitoring), required authentication (Pipeworx OAuth account), and limitations (anonymous/BYO cannot persist). Lacks explicit 'when not to use' or direct comparison to alternatives.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is clear. The description adds valuable behavioral context beyond annotations: it returns category-bucketed example questions with specific tool+argument shapes, and explains that it draws from a live 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 relatively long but front-loaded with the core purpose ('onboarding entry point'). Every sentence adds value—examples, clarifying contrast with siblings, and parameter guidance. Could be slightly more concise, but 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 no output schema, the description thoroughly explains what the tool returns (category-bucketed example questions with tool+argument shapes). It covers the tool's use case, parameter usage, and relationship to siblings. With annotations providing safety context, this is fully adequate for an agent to use the tool correctly.

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

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

Schema coverage is 100% for the single 'topic' parameter, with a description in the schema. The description provides examples of valid topic values (e.g., 'finance', 'pharma') and explains the effect of omitting it (full spread), but this is not essential beyond what the schema already conveys. 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 identifies the tool as an onboarding entry point for suggesting questions about Pipeworx, using multiple natural language examples and explaining the output (category-bucketed example questions with tool+argument shapes). It distinguishes itself from sibling tools like ask_pipeworx and entity_profile by being the first step when the agent doesn't know what Pipeworx can do.

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 to 'Use this FIRST when you do not yet know what Pipeworx can do for you'. It provides context on when to call with or without the topic parameter and references alternatives like ask_pipeworx, entity_profile, etc., giving clear guidance on usage.

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

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

Annotations show readOnlyHint=false and destructiveHint=false, but description adds critical info: ownership enforcement, row deactivation (not deletion), and historical data preservation. All neutral with annotations.

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

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

Two sentences totaling ~30 words, front-loaded with action. Every word adds value with no redundancy.

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

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

For single-parameter tool with no output schema, description covers ownership, side effect (deactivation), and historical data retention. Fully adequate for agent selection and 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 covers 100% of parameters with 'id' description. Description adds that the id comes from 'subscribe', providing useful lineage context beyond schema alone.

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

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

Description explicitly states 'Cancel a subscription by id' with clear verb-resource pairing. Distinguishes from sibling tools like 'subscribe' and 'list_subscriptions' by noting ownership enforcement and deactivation behavior.

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

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

Indicates when to use (cancel own subscription), ownership prerequisite, and what happens to historical events (available via 'recent_alerts'). Provides clear context with alternative reference.

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

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

Annotations provide readOnly/openWorld/idempotent/non-destructive hints. The description adds critical context beyond these: the meaning of 'could_not_verify' as a failure mode with verification_error, the distinction between 'unsupported' and 'could_not_verify', and the internal routing behavior. No contradiction with annotations.

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

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

The description is lengthy but dense; every sentence serves a purpose—examples, use cases, pipeline explanation, return values, and critical caveats. It front-loads with natural-language triggers and ends with important caller warnings. Slightly verbose but justified for 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?

With no output schema, the description fully covers return values: six verdicts, actual value with pipeworx:// citation, and reasoning. It also explains error semantics (could_not_verify) and unsupported cases. Combined with rich annotations and complete schema coverage, 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?

Schema coverage is 100% with detailed descriptions for both parameters (claim and tolerance_pct). The tool description does not add new parameter semantics beyond the schema; it only indirectly references the tolerance via 'exact percent-delta math.' 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 the tool's function: natural-language claim verification against authoritative sources, with a specific verb ('verify', 'fact check') and resource. It distinguishes itself from siblings by focusing on checking factual claims and describes a structured pipeline for company-financial claims versus a grounded fallback for all others.

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

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

Explicitly says 'Use whenever the agent needs to check whether something a user said is factually correct,' and explains when the structured vs. grounded path applies. It also notes it replaces 4–6 sequential calls, implying an efficiency motive. It does not explicitly name alternatives to avoid, but the guidance is strong.

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