Cnb Cz

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false. Description adds that it makes external API calls (to Anthropic) and requires BYO key, implying cost and external dependency—beyond the annotations. 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, front-loaded with action ('Probe...'), and no wasted words. Each sentence adds essential information: action, defaults, optional extension, returns, and use cases.

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

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

No output schema, but description summarizes return fields (per-model {score, confidence, signals, raw_response} + combined view). Covers key aspects for a multi-model probing tool. Could mention rate limits or pagination but not critical.

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

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

Schema description coverage is 100%, so baseline is 3. Description adds context about default model and API key usage but does not provide meaning beyond what the schema already offers for each parameter.

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 probes LLMs about a business/topic and scores visibility per model. The verb 'probe' and resource 'LLMs' are specific, and it distinguishes from sibling tools like 'scan_competitor_ai_presence' by focusing on visibility scoring across models.

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 mentions default model (Workers AI Llama-3.3-70b), optional Anthropic probing with API key, and example use cases (AI-marketing audits, pre-launch checks, competitive monitoring). Does not explicitly state when not to use or list alternatives, 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 already cover the safety profile (readOnly, openWorld, idempotent, non-destructive). The description adds meaningful behavioral context beyond that: it fills arguments automatically, returns stable pipeworx:// citation URIs, works on every tier, and routes live news via news packs. There is no contradiction with annotations. A small gap is that it doesn't mention behavior for unmatched questions or possible follow-up clarifications.

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: the primary purpose and 'prefer over web search' directive come first, followed by examples and escalation paths. Some sentences lean promotional ('works on every tier, one fast call') and could be trimmed, but the structure moves logically from purpose to usage to alternatives, and every section adds useful guidance.

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

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

No output schema is provided, so the description earns credit for stating the return format: 'structured answer with stable pipeworx:// citation URIs.' It covers how to use it, when to step up to alternatives, and that it handles a wide range of factual queries. It doesn't address edge cases like ambiguous questions or failure behavior, but for a broad router tool this is sufficiently complete.

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

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

Schema coverage is 100% and the schema already documents the required 'question' parameter and its aliases (q, text, input, query, prompt) with clear descriptions. The description adds example phrasings but doesn't introduce substantive parameter semantics beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description is explicit: it routes factual questions to one of 5,724 tools across 1,497 verified sources and returns structured answers with citation URIs. It clearly positions itself as the default entry point and distinguishes itself from siblings like ask_pipeworx_grounded and deep_research. The resource and verb are concrete ('routes', 'returns structured answer'), leaving no ambiguity about what the tool does.

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

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

Provides explicit when-to-use guidance: 'PREFER OVER WEB SEARCH' for specific data categories, trigger phrases like 'what is', 'look up', 'find', and concrete examples. It also gives step-up rules for alternatives (ask_pipeworx_grounded for hallucination-resistant verbatim evidence, deep_research for broad/multi-part questions) and clarifies that breaking news is already covered. This is model guidance for tool selection.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, covering safety. The description adds valuable context beyond that: it explains the beta nature, that routing behavior may change whenever a candidate is under test, and that currently it matches the stable router. This is a meaningful disclosure of volatility that annotations cannot capture.

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 and front-loaded with the core information: the beta relationship to ask_pipeworx and its identical behavior. Each sentence contributes distinct value—purpose, current state, usage instruction, and a reassurance that it is fully functional. While slightly verbose, nothing is redundant.

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 required parameter and no output schema, the description is sufficient. It covers the tool's role, its relationship to the stable version, when to use it, and that the response shape matches ask_pipeworx. This is complete given the complexity and the existing annotations.

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% — all six parameters are documented in the schema, including aliases and the required 'question' field. The description adds no additional parameter information, but the schema already fully explains them, so a baseline of 3 is appropriate. No extra semantics are 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 explicitly identifies the tool as a beta version of ask_pipeworx, a universal router with 5,724 tools, and distinguishes it from its stable sibling. It is not a tautology; it adds the beta context and clearly states the resource and action (ask a router). The specificity allows an agent to differentiate it from ask_pipeworx and ask_pipeworx_grounded without deeper inspection.

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 condition: use it exactly like ask_pipeworx when you want the newest routing. This implies the alternative (use ask_pipeworx for stable) and clarifies that this tool is fully functional, not a placeholder. Exclusions are not explicit but are strongly implied by the 'beta' label and the comparison against the stable router.

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

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

Adds rich behavioral detail beyond the read-only/idempotent annotations: it discloses the extraction constraint, successful return shape with specific fields, refusal semantics with exact refusal_reason enum values, and the extra cost versus ask_pipeworx. This fully prepares an agent for both success and failure paths.

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?

Every clause earns its place: the core differentiation is front-loaded, return and refusal shapes are compact, usage guidance follows, and cost/tradeoff closes the loop. Despite covering a lot, it remains tight and readable.

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

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

Even though there is no output schema, the description fully spells out the return contract and refusal cases. For a single-required-param tool with high schema coverage and strong annotations, no essential calling information 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% and the schema already documents all aliases and the natural-language question parameter. The description does not add parameter-specific meaning beyond the schema, so the baseline of 3 applies.

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

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

Clearly identifies a distinct mode ('Hallucination-resistant answer mode') with a specific verb and resource, and explicitly contrasts itself with ask_pipeworx by describing what grounded mode does differently: it extracts answers only from tool results. This makes it easy for an agent to distinguish this tool even among 30+ siblings.

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 ('whenever an answer will be quoted, cited, or acted on... must not invent facts') and when-not-to-use guidance ('prefer ask_pipeworx for casual lookups'), with a named alternative. It even gives cost context (one extra LLM call) to inform the tradeoff.

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

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

The annotations already declare safe, read-only, idempotent behavior. The description goes far beyond by detailing edge cases: low-confidence resolution short-circuit, closed market handling, wide-spread tradeability warnings, resolution-rule risk, parent event extraction, and news fallback fields. This level of transparency is exceptional and adds high value beyond annotations.

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

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

The description is long but well-structured with labeled sections (CLASSIFIERS, FAN-OUT EXAMPLES, RESPONSE SHAPES, etc.). Every sentence earns its place by adding distinct value. The first sentence captures the core purpose immediately, and the rest is organized logically for quick scanning.

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

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

Given the tool's complexity (multiple data sources, parallel fan-outs, market resolution logic, safety guards), the description covers all critical aspects: input formats, classifier list, fan-out examples per category, response shapes with key fields, match confidence levels, parent event extraction, news error handling, closed/short-circuited markets, spread warnings, and resolution-rule parsing. No output schema exists, but the description compensates thoroughly.

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

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

Schema coverage is 100%, but the description adds meaningful context: the `market` parameter supports three input formats (slug, URL, question text), `depth` explains quick vs thorough fan-out, and `include_raw` clarifies summarized vs full payloads and when to use each. These details directly help an agent invoke the tool correctly.

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

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

The description starts with a clear verb+resource: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies three input formats (slug, URL, question text) and gives example use cases like 'should I bet on X'. While it doesn't explicitly differentiate from sibling tools like polymarket_edges, the detailed behavior and examples make 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 includes explicit usage contexts ('Use for "should I bet on X"...') and provides classifiers and fan-out examples that guide appropriate use. However, it does not state when not to use the tool or how it compares to alternatives like polymarket_edges or polymarket_arbitrage. The guidance is clear but lacks exclusions.

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

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

Adds behavioral context beyond annotations: specifies returned fields (validFor, rate, volume) and data freshness (verified live). No contradictions with annotations (readOnlyHint, idempotentHint). Weekend/holiday behavior is in schema, not description, but description still adds value.

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

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

Three concise sentences: defines the acronym, lists return fields, and provides usage tip. Front-loaded with the most important information; every sentence earns its place without redundancy.

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

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

Adequately covers tool purpose, input usage, and key outputs despite lacking an output schema. Could be slightly improved by noting the format of the returned rate or volume, but sufficient for a simple one-parameter lookup tool.

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

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

Schema coverage is 100% with detailed parameter description (date format, omission for latest, weekend/holiday handling). Description merely restates 'Omit date for the latest', adding no new semantic value beyond the schema.

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

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

Clearly states the tool returns CZEONIA (Czech Overnight Index Average) for a given day with specific outputs (validFor, rate, volume). Distinguishes from sibling tools by naming the exact index and contrasting with other CNB tools like exchange rates or PRIBOR.

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 omit the date parameter (for latest). Does not explicitly state when to use this tool versus alternatives like cnb_pribor or cnb_exchange_rates, leaving the agent to infer based on the specific rate name.

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

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

Beyond annotations (readOnlyHint, idempotentHint), the description adds that the tool returns ~30 currencies per entry with specific fields and explains the rate meaning. It also notes that weekends/holidays return last valid rates.

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

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

The description is three sentences, front-loaded with the main purpose, and includes necessary details without redundancy. It is appropriately sized.

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

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

With no output schema, the description adequately explains return structure (one entry per currency with fields) and date behavior. It covers the key aspects, though missing details about error handling or pagination (likely unnecessary for simple data).

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

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

Schema coverage is 100%, so the schema already documents both parameters. The description restates the optional nature of date and the default lang, adding minimal extra context like 'Verified live.'

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

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

The description clearly states the tool provides ČNB official daily exchange rates against CZK, specifying the source, target currency, and frequency. It distinguishes from siblings like cnb_exchange_rates_currency_month and cnb_monthly_averages by focusing on daily rates.

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

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

The description explains how to use the date parameter (omit for latest, weekends/holidays return last valid), but does not explicitly guide when to choose this tool over sibling CNB tools for different periods or currencies.

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

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

Annotations already indicate readOnlyHint, idempotentHint, and non-destructive behavior. The description adds that data is for working days only and 'Verified live,' which provides additional context about data freshness and availability without contradicting annotations.

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

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

The description consists of three short, informative sentences with no wasted words. It front-loads the core purpose and output fields, then adds usage guidance and a credibility statement ('Verified live').

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

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

For a tool with no output schema, the description sufficiently explains return values (currencyCode, amount, validFor, rate). It also notes the data covers working days only and is verified live, covering potential concerns about data completeness and timeliness 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 descriptions for all three parameters (lang, currency, yearMonth). The description does not add meaningful information beyond what the schema already provides, 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 returns 'Daily ČNB exchange rates for ONE currency across a whole month — a per-currency time series against CZK' and lists specific output fields (currencyCode, amount, validFor, rate). This distinguishes it from sibling tools like cnb_exchange_rates (likely for current rates or multiple currencies) and cnb_monthly_averages (monthly averages).

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

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

The description explicitly says 'Use this to chart or compare a single currency over time,' providing a clear use case. While it doesn't mention when not to use or list alternatives, the context is sufficient for an agent to infer its purpose relative to similar CNB tools.

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

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

Annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint) already cover safety and idempotency. Description adds 'Verified live' which is vague and does not disclose rate limits, data freshness, or other traits. No contradiction, but minimal extra behavioral context beyond annotations.

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

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

Four short sentences, front-loaded with purpose and output format. The sentence 'Verified live.' is somewhat extraneous but not harmful. Could be slightly more compact, but overall efficient.

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

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

Given the simple tool (2 parameters, no output schema, no nested objects), description covers purpose, input, output structure, and use case. Missing details like date range limits or pagination, but acceptable for a straightforward lookup tool.

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

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

Schema coverage is 100% with clear descriptions for lang and currency. Description emphasizes 'ONE currency' but does not add new meaning beyond the schema. Baseline score of 3 is appropriate as schema carries the weight.

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 specifies verb ('returns'), resource ('monthly average exchange rates for ONE currency against CZK'), and scope ('across all available years'). It clearly differentiates from siblings like cnb_exchange_rates (likely daily) and cnb_exchange_rates_currency_month (single month) by emphasizing 'monthly averages' and 'ONE currency' over all years.

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

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

States usefulness for 'historical trend/year-over-year comparisons', providing clear context. However, it does not explicitly mention when not to use or name alternative tools, leaving some ambiguity compared to highest bar.

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 safe, idempotent read operation. The description adds behavioral details: returns data per tenor, rates in percent, 'verified live', and handling of weekends/holidays. No contradictions.

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

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

Two concise sentences with no fluff. Key information front-loaded: what it returns, tenors, omission option, and verification status.

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

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

For a simple tool with one optional parameter and no output schema, the description covers input behavior, output structure (per tenor), and verification. Could potentially include which fields are returned, but it's sufficient.

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

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

Schema covers the 'date' parameter well. The description adds meaning by reiterating omission for latest and explaining weekend behavior, going beyond the schema's description.

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

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

The description clearly states it returns PRIBOR rates for a given day, with specific tenors. It is distinct from sibling tools like cnb_czeonia or cnb_exchange_rates, which cover different rates.

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

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

The description implies when to use via 'Omit date for latest' and weekends fallback, but does not explicitly state when not to use or compare with alternatives like cnb_czeonia.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds behavioral details: handles off-calendar fiscal years, returns sorted data, provides citation URIs, and replaces many sequential lookups. No contradiction with annotations.

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

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

The description is a single paragraph but is dense and front-loaded with key purpose and triggers. It could be split into sentences for readability, but every sentence earns its place without excessive length.

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

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

Given the tool's complexity (2 entity types, multiple data sources, max 5 items) and no output schema, the description covers main behaviors, return format (paired data + citation URIs), and sorting. Mostly complete, though output schema would further enhance completeness.

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

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

Schema coverage is 100%, but the description adds meaning beyond the schema: for 'type' it specifies what data is pulled for each enum value, and for 'values' it gives examples and constraints (tickers/CIKs for company, drug names). This goes beyond the schema's baseline.

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

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

The description clearly states the tool performs side-by-side comparisons of 2-5 companies or drugs, with specific trigger phrases and data sources (SEC EDGAR for companies, FAERS for drugs). It distinguishes itself from siblings like entity_profile by emphasizing it replaces 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?

Explicitly states 'ALWAYS PREFER over sequential single-pack lookups when comparing entities,' providing clear when-to-use guidance. Also explains how results are sorted to match queries like 'largest' or 'most'.

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

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

Annotations only supply readOnly/openWorld/idempotent hints, so the description carries the behavioral burden and exceeds it: it discloses account/auth requirements, paid tiers, internal decomposition into facets with parallel routing, output structure (verbatim evidence, confidence, source, fetched_at, citation_uri, gaps[], contradictions[]), semantic excerpting, and expected latency. No contradiction with annotations.

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

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

The description is long but dense and front-loaded with the account requirement, and the core purpose appears early. There is minor redundancy in the repeated ask_pipeworx comparisons and the citation_uri mention, but each sentence contributes a distinct behavioral or usage fact.

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 defines return semantics: findings packet components, gaps[] behavior, contradictions[], hop field, and citation_uri resolvability. It also covers failure modes, latency, and account prerequisites, giving an agent everything necessary to select and invoke the tool correctly.

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

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

Schema coverage is 100%, so the parameters are already documented. The description adds value by mapping depth values to facet counts, hops, gap recovery, and contradictions scan, and by clarifying that 'question' is natural language that can be broad/multi-part. This exceeds schema detail but is not essential for basic invocation, so a 4 rather than 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: it 'conducts grounded multi-source research' across '1497 STRUCTURED data sources' and decomposes questions into facets. Explicitly says 'this is NOT open-web search' and distinguishes itself from ask_pipeworx, so an agent can tell it apart from siblings without opening schemas.

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 and when-not-to-use guidance: 'Best for broad/multi-part questions over structured data', 'For a single lookup use ask_pipeworx', and 'For BREAKING or colloquial CURRENT-NEWS / "what's the world saying about X" topics, prefer ask_pipeworx'. Also names the sign-in fallback and tier requirement, giving an agent clear 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 already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context: it returns 'top-N most relevant tools with names, descriptions, and full input schemas (with curated examples) — each result is ready to call directly.' This goes beyond annotations and clearly explains the output behavior.

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

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

The description is concise for the amount of information it conveys. It front-loads the purpose, lists domains, and clearly states output. Every sentence adds value without redundancy.

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

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

Given the tool's complexity (6 parameters, no output schema), the description fully explains what it does and what it returns. It states the output format and that results are ready to call directly. 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 description coverage is 100%, so the schema already documents all parameters including aliases. The description does not add meaning beyond listing example queries and mentioning the limit parameter. Baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Find tools by describing the data or task.' It lists specific domains (SEC filings, FDA drugs, etc.) and distinguishes it from sibling tools by advising 'Call this FIRST when you have many tools available.' This provides a specific verb+resource and differentiates from alternatives.

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

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

The description explicitly tells when to use: 'Use when you need to browse, search, look up, or discover what tools exist for...' and 'Call this FIRST when you have many tools available.' It implies not to use when you already know the specific tool, giving clear context.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive. The description adds behavioral details beyond these: it fans out across multiple sources in one parallel call, mentions the patent sunset and soft-fail behavior, and explains the news fallback (GDELT→GNews). This enriches the agent's understanding.

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

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

The description is fairly long but well-structured: it opens with example queries, states usage preference, then systematically lists what is returned. Every sentence adds value, though it could be slightly more concise by grouping some details. Overall, it earns its length.

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

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

Given the tool's complexity (multiple data sources, various return fields) and the absence of an output schema, the description is remarkably comprehensive. It details every returned component (cik, filings, fundamentals, patents, news, LEI) and notes important caveats like the patent sunset. This fully prepares the agent for the tool's output.

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 value by providing concrete examples ('AAPL', '0000320193'), clarifying that names are not supported, and explaining the type parameter's current limitation to 'company'. This goes beyond the schema's brief descriptions.

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

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

The description clearly states the tool's purpose: 'full cross-source profile of a US public company in ONE parallel call'. It lists example queries ('Tell me about X', 'research Acme') and distinguishes it from chaining individual lookups, making the purpose immediately obvious.

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

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

Explicit guidance is provided on when to use this tool: 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view'. It also specifies when not to use it (if only a name is available, use resolve_entity first) and explains limitations like names not supported.

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 destructiveHint=true and idempotentHint=true, covering safety. The description adds behavioral context about clearing sensitive data and use cases, but does not provide deeper details like data retention or side effects.

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

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

The description consists of two concise sentences. The first states the purpose, the second provides usage guidelines. No redundant information; every sentence serves a purpose.

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

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

Given the tool's simplicity (1 required parameter, no output schema, and annotations covering destructive hint), the description is complete. It explains what the tool does, when to use it, and related tools.

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

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

Schema coverage is 100% with a single parameter 'key' described as 'Memory key to delete.' The tool description adds no additional meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states 'Delete a previously stored memory by key,' specifying a verb (delete) and resource (memory). It distinguishes itself from sibling tools like 'remember' and 'recall'.

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

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

The description explicitly provides when-to-use guidance: 'when context is stale, the task is done, or you want to clear sensitive data.' It also suggests pairing with 'remember' and 'recall,' offering clear context for usage.

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

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

Annotations already declare it safe, idempotent, non-destructive. Description adds behavior like fetching page and extracting title/description/links, which is helpful 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?

Two sentences, front-loaded with purpose and key details. Every word serves a purpose; no redundancy.

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

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

Given two simple parameters, no output schema, and rich annotations, the description fully covers input and output format. It explains what is extracted and the final output (single 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 covers 100% of parameters with descriptions. Description only restates them (URL and max_links). No additional meaning beyond schema, so baseline 3.

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

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

Description clearly states it generates a production-ready llms.txt file for any URL, with specific actions (fetches, extracts, emits). No sibling tool performs this exact function, so it is well-differentiated.

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 (client indexing, personal drafting, competitor auditing). Does not include when-not-to-use or alternatives, but context is clear enough for the specialized 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, destructiveHint. The description adds value by detailing the output fields and the effect of the include_inactive parameter. No contradiction with annotations.

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

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

Two sentences, no wasted words. Front-loaded with the main purpose, then additional details. Efficient and clear.

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

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

Description lists the return fields, explains the optional parameter, and provides usage context. No output schema exists, so the description adequately covers what the agent needs to know.

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

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

Schema coverage is 100%, baseline 3. The description adds meaning by explaining the optional parameter include_inactive as 'Include cancelled subscriptions in the response (default false).' This clarifies its purpose beyond the schema.

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

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

The description clearly states the action ('List the caller's active subscriptions') and specifies the return fields (id, type, params, created_at, last_fired_at, fire_count). It differentiates from sibling tools like subscribe and unsubscribe.

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

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

The description provides explicit use cases: 'review what you're monitoring before adding more' and 'find an id to cancel'. However, it does not explicitly state when not to use this tool or mention alternatives.

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

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

The description discloses several behavioral traits beyond the sparse annotations: the claim_token workflow for following up on reports, the 5-per-day rate limit, free-of-quota status, and the fact that feedback signals the roadmap. These are exactly the kind of contextual behaviors an agent needs to know.

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

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

Though dense, every sentence adds essential information: purpose, use cases, exclusions, token semantics, rate limits, and roadmap impact. There is no redundancy or filler; the long paragraph is justified by the tool's complexity.

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

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

For a tool with no output schema and four parameters (one nested object), the description fully covers invocation workflow, return behavior (claim_token), constraints, and follow-up usage. It leaves no critical gaps for an agent to misuse the tool.

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

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

Schema coverage is 100% and each parameter has a rich description, so the baseline is 3. The tool description adds further value by instructing what to include in the message ('in terms of Pipeworx tools/packs') and explicitly saying not to paste the end-user's prompt, which complements the schema's message field.

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

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

The description opens with a specific verb+resource: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It clearly distinguishes from sibling tools by focusing on feedback about Pipeworx tools themselves, not on using tools to answer questions or research.

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

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

Explicit when-to-use guidance with concrete examples: bug, feature/data_gap, praise. It also gives an exclusion rule for tools from other MCP servers and suggests how to resolve ambiguity ('Not sure? Pipeworx tool names are the ones this connection lists'). This fully addresses usage relative 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 and destructiveHint=false. The description adds useful behavioral context: data source (CF analytics-engine), no PII, caching behavior (5min-1h), and that it's a self-aggregating signal. 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 front-loaded with the core purpose, followed by bullet-style use cases and additional context. It is slightly verbose but each sentence adds value; no redundancy.

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

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

For a tool with one optional parameter and no output schema, the description fully explains what returns (top tools, packs, volume, (pack, tool, count)), caching, and data source. No gaps given the complexity.

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

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

Schema coverage is 100% with a well-described enum parameter. The description adds meaning beyond the schema by explaining the trade-off between shorter and longer windows ('hot right now' vs 'steady-state demand').

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

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

The description clearly states 'Returns the top tools, top packs, and total call volume' with a specific scope (what other AI agents are calling on Pipeworx). This distinguishes it from sibling tools like ask_pipeworx (direct question) and discover_tools (tool discovery).

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

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

Three explicit use cases are listed, helping the agent decide when to use this tool (e.g., for trend discovery or canonical tool confirmation). It does not explicitly state when not to use it or name alternatives, but the context is strong enough for decision-making.

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, openWorldHint: true, idempotentHint: true, destructiveHint: false. The description adds extensive behavioral details: monotonicity checks, partition_sum, similarity thresholds, placeholder filtering, fill check with depth book. 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 detailed but well-structured with sections for modes, semantic anchor, partition filter, response, and fill check. Every sentence is informative, though slightly lengthy. Could be tightened, but the complexity justifies the length.

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

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

No output schema, but the description covers response fields: opportunities[], partition_check with fields, and fill_check details including conditions for not trading. Also explains when null arb signal is returned. No gaps for a complex tool.

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

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

Schema coverage is 100% (both parameters documented), baseline 3. The description adds meaning beyond schema: explains event slug/URL, topic seed question, and provides examples like 'fed-may-2026' or 'Strait of Hormuz traffic returns to normal'. However, no enum values 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 states the tool finds arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It distinguishes three modes: no-arg trending scan, event mode for a specific market, and topic mode for cross-event scanning, which differentiates it from sibling tools like polymarket_edges.

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

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

Explicitly says when to use each mode: 'event (recommended for a specific market)', 'topic for cross-event scanning', and 'Call with NO args for a trending_scan'. Also warns when not to trade: 'do not trade it' if realizable_edge_pp ≤ 0. Mentions alternative tool: 'For custom sizing use polymarket_fill_risk'.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive. The description adds extensive behavioral context: explains three model families, response structure, caching (1h KV), diagnostics, and edge calculation details. 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 well-structured with sections and front-loads purpose. However, it is very long (over 600 words) and includes highly technical details that could be condensed while retaining clarity.

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

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

Despite no output schema, the description thoroughly explains response top-level fields, segments, diagnostics, and knobs. It also covers caching and edge cases like Fed bets, making the tool very complete for an agent to use.

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

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

Schema coverage is 100% with all 9 parameters described. The description adds significant value beyond schema, e.g., for slippage_pp: 'Subtracted from raw |edge| before ranking and Kelly sizing' and practical advice on adjusting for thin partitions.

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

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

The description clearly states the tool scans Polymarket markets and returns opportunities where Pipeworx data disagrees with market price. It distinguishes from siblings by specifying its role for 'what should I bet on today' and detailing three model families, making the purpose highly specific.

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

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

The description explicitly says 'Built for "what should I bet on today"' and provides usage context via knobs like min_liquidity and max_spread_pp. However, it does not explicitly state when not to use this tool versus siblings like polymarket_arbitrage.

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

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

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint), the description adds behavioral details: history depth bounded by 60-day TTL, snapshots on cache-miss, gaps meaning no scan, decay from daily closes, and response structure. 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 structured logically: purpose, response breakdown, limits. Every sentence adds value; no unnecessary verbiage. It is dense but not verbose.

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

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

Though no output schema, the description thoroughly explains response fields (tracked, expired, snapshot_dates) and limitations. Complete for a read-only query 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 schema descriptions already include defaults and clamp values. The description adds little beyond glossing the meaning of 'window' as snapshot family. Baseline 3 is appropriate.

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

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

The description clearly states the purpose: providing edge persistence and decay telemetry from daily snapshots. It answers a specific question about edge age and trend, and distinguishes itself from the sibling 'polymarket_edges' which likely provides current edges only.

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 after obtaining a current edge from polymarket_edges, but does not explicitly state when to use this tool versus alternatives. The context is clear but lacks explicit when-not or alternative references.

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 aligns with annotations (readOnlyHint, idempotentHint, etc.) and adds behavioral details: walks the order book ladder, returns specific fields (top_of_book, vwap_fill_price, slippage_pp, shares_filled, max_fillable_usd, verdict), and explains the consequences of partial fills in basket mode. 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 somewhat lengthy but front-loaded with key distinctions (REQUIRES one of market/event) and uses capitalization for emphasis. Every sentence contributes to understanding or usage guidance, with minimal redundancy.

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

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

Given the tool's complexity (two modes, multiple return fields), the description is thorough. It lists output fields for both modes, explains verdict categories (clean|degraded|cannot_fill), and highlights risks (forced_directional_risk). Though no output schema exists, the description compensates fully.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds significant value beyond schema by explaining mode-specific semantics, default behaviors (e.g., side auto-detection in basket mode), constraints (size_usd clamp 10–1,000,000), and interpretation of size_usd as settlement notional in basket mode.

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

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

The description explicitly states the tool performs a 'realizable-vs-theoretical edge check against live CLOB order-book depth' and distinguishes two distinct modes (single-market and basket). It clearly differentiates from siblings like polymarket_arbitrage and polymarket_edges by specifying when to use this tool.

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

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

The description includes explicit usage guidance: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500'. It also explains why (theoretical overround on thin books is not capturable, partial basket fills convert arb into directional position), providing clear context for when to use this tool versus alternatives.

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

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

Annotations already declare read-only, idempotent, non-destructive behavior, so the description's burden is to add operational context — and it does extensively: compatibility codes, skipped legs, temporal-alignment null semantics, fee disclosure, and gross-vs-net spreads. This directly supports the annotations without contradicting them.

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

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

The description is long, but it is front-loaded with the core purpose and organized into labeled sections (TWO MODES, RESPONSE, SAFETY FIELDS, fees, skipped counters). Every sentence carries genuine operational content; the only deduction is that the density of codes, flags, and caveats makes it a heavy read despite the clear structure.

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

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

There is no output schema, so the description must explain return semantics itself, and it does thoroughly: leg-by-leg prices, top_spreads_pp with flags, skipped_unclassified, low_confidence_pairs, temporal_alignment, and fees_note. It even clarifies edge semantics like null meaning 'could not be computed' rather than aligned. Nothing needed to invoke the tool 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 coverage is 100%, so the baseline is 3, but the description adds substantial semantic weight: topic is a pre-mapped shortcut that auto-fetches matching events, explicit params override the mapped side, and both modes run the identical token-overlap matcher. It also explains the meaning of the topic values and the override behavior beyond what the schema states.

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 names a specific resource — the cross-venue spread between Kalshi and Polymarket for the same resolving question — and explains what the tool does with it: matches equivalent bet shapes and reports the price delta. It clearly differentiates from same-venue siblings like polymarket_arbitrage by emphasizing cross-venue comparison and same-question matching.

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

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

The description explicitly frames TWO MODES and tells when to use pre-mapped topics versus explicit kalshi_event_ticker/polymarket_event_slug pairings. It also sets expectations with the warning that most pre-mapped topics currently return compatibility_warning and that 'pre-mapped ≠ tradeable.' It stops short of a 5 because it never names a sibling tool as the alternative for other cases.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. Description adds behavioral details: scoping to identifier, pairing with remember and forget, and ability to list all keys. No contradiction. Adds value beyond annotations.

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

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

Three sentences, front-loaded with the main action, then use case, then scoping and pairing. Every sentence adds distinct value. No fluff.

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

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

For a retrieval tool with strong annotations and one optional parameter, the description covers usage, scoping, relationship to siblings, and edge case (omitting key). No gaps.

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

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

Schema coverage is 100% with description for key parameter. The description adds context: explaining that omitting key lists all keys, and that key is used to retrieve a specific memory. This aligns with and slightly enriches 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 retrieves a value saved via remember, or lists all keys if key is omitted. It uses specific verbs ('Retrieve', 'list') and identifies the resource ('a value', 'saved keys'). It distinguishes from siblings remember and forget by naming them explicitly.

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

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

Explicit usage guidance: 'look up context the agent stored earlier... without re-deriving it from scratch'. Also gives scoping context (anonymous IP, BYO key hash, account ID) and recommends pairing with remember and forget. Provides clear when-to-use and what alternatives exist.

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

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

Description reveals that mark_read:true flags events as read, modifying state, which contradicts the annotation readOnlyHint=true. Per rules, score is 1 when description contradicts annotations.

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

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

Four sentences, front-loaded with purpose. Each sentence adds value: return fields, filtering, mark_read, alternative endpoint. No extraneous content.

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

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

Covers all key aspects: what it returns (source, citation_uri, payload), filtering options, mark_read effect, polling behavior, and an alternative non-interactive endpoint. Complete for a read-only list tool with no output schema.

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

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

Schema coverage is 100%, baseline 3. Description adds meaning with examples (e.g., 'sec_8k'), clarifies ISO timestamps, and explains mark_read behavior. Provides practical usage context.

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

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

The description clearly states 'Pull fired events from your subscription feed', specifying a concrete verb (pull) and resource (fired events). It distinguishes from siblings by providing a direct alternative endpoint for scripts/dashboards.

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?

Guidelines are explicit: filter by type and ISO timestamp, use mark_read to manage read state, and poll safely. It also mentions an alternative GET endpoint for scripts/dashboards. Lacks explicit 'when not to use', but provides enough 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 include readOnlyHint, idempotentHint, and openWorldHint, and the description adds valuable behavioral context: it fans out to multiple sources, has a fallback mechanism from GDELT to GNews on rate limits or errors, and soft-fails on USPTO. This goes well beyond what annotations provide and does not contradict them.

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

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

The description is a single paragraph that efficiently packs all necessary information. It is front-loaded with example queries. While it is concise and well-organized, minor improvements could be made (e.g., using bullet points for sources), but overall it is effective and not verbose.

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

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

Given no output schema, the description adequately describes the return structure: 'Returns structured changes[] grouped by source + total_changes count + pipeworx:// citation URIs.' It also provides context for when to use this tool versus 'entity_profile' and addresses all aspects of the tool's behavior, including fallbacks and limitations. This is complete for the intended use.

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

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

Schema description coverage is 100%, but the description adds significant additional meaning. It explains the 'since' parameter's accepted formats (ISO date or relative shorthand like '7d', '30d') and recommends '30d' or '1m' for typical monitoring. For 'value', it clarifies it can be a ticker or zero-padded CIK, which is not obvious 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 description uses specific verbs like 'change feed' and clearly states the tool returns structured changes from SEC EDGAR, GDELT/GNews, and USPTO. It explicitly distinguishes from the sibling 'entity_profile' by noting when to use that tool instead, e.g., 'Use entity_profile instead when you want the static profile...' This provides excellent clarity and differentiation.

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 example queries ('What's new with X', 'latest on Y') and explains when to use the tool versus the sibling 'entity_profile'. It also details internal fallback behavior (GDELT→GNews) and notes that USPTO soft-fails until reactivated, giving clear guidance on tool behavior.

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 idempotentHint=true and destructiveHint=false. The description adds valuable context: persistence across sessions for authenticated users, 24-hour retention for anonymous, and scoping by agent identifier. No contradictions with annotations.

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

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

The description is concise, front-loads the core purpose, then provides usage context and behavioral details. Every sentence adds value with no superfluous 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?

Given the tool's simplicity (2 required params, no output schema) and comprehensive annotations, the description covers all necessary aspects: purpose, when to use, behavioral persistence, and sibling relationships. It is complete for an agent to correctly invoke the tool.

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

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

The input schema has 100% coverage with clear parameter descriptions. The description reiterates scoping and persistence but does not add significant new meaning beyond what the schema already provides. 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 verb 'save data' and resource 'key-value memory store'. It distinguishes itself from sibling tools like 'recall' and 'forget' by specifying the action of storing for later reuse. The purpose is specific and actionable.

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

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

The description provides explicit when-to-use guidance with examples (resolved ticker, target address, user preference) and mentions pairing with recall and forget. It explains scoping and persistence, but does not include explicit when-not-to-use scenarios, which would elevate to a 5.

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

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

Goes well beyond the readOnly/openWorld/idempotent annotations by disclosing graceful degradation ('LEI/FIGI enrichment degrades gracefully'), ambiguity handling (returns figi_candidates rather than asserting on multi-match), explicit unresolved identifiers, source labeling, and internal cascading lookups. This adds significant behavioral context.

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

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

Front-loaded with user-phrase examples and the 'Use FIRST' guidance, and the SUPPORTED TYPES section is well labeled. However, the description is a dense single paragraph with some redundancy, such as explaining twice that ambiguous matches return candidates, which makes it slightly harder to scan.

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

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

Despite having no output schema, the description covers both supported types, accepted input forms, return expectations (identifiers, unresolved list, figi_candidates), source systems, and failure modes. This is complete enough for an agent to select and invoke the tool correctly without additional context.

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

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

Although schema coverage is 100%, the description adds major semantic value: accepted input forms (ticker, CIK, ISIN, name, brand/generic), concrete examples, and a critical usage warning to pass only the entity name, not the full noun phrase, for bond issuance lookups. This materially improves correct invocation.

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: 'resolve a user-spoken NAME to the canonical/official identifiers other tools require as input.' It also gives multiple realistic user-phrase examples (ticker, CIK, LEI, RxCUI) and clearly differentiates itself from sibling tools by being the name-to-ID conversion tool.

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

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

Explicitly directs the agent: 'Use FIRST whenever you have a name but need an ID.' It also communicates that the tool replaces 2-3 manual lookups, giving strong contextual guidance. It does not explicitly enumerate when not to use it or name alternative tools, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds valuable behavioral context: that it probes with ai_visibility_check, ranks, and returns score, confidence, signal density per entity. No contradiction.

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

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

Two sentences, front-loaded with the main action and output, 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?

Despite lacking an output schema, the description explains the return format (ranked list with score, confidence, signal density per entity). All major aspects are covered given the tool's complexity and context signals.

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 each parameter is already described. The description adds that the first entity in 'entities' array is treated as the 'subject' for narrative and the rest as competitors, which adds useful semantic nuance beyond schema.

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

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

Description clearly states it compares AI visibility across multiple entities, probes each with ai_visibility_check, ranks by score, and surfaces most/least recognized. This distinguishes it from siblings like ai_visibility_check (single entity) and compare_entities (likely different scope).

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

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

Explicitly notes usefulness for competitive AI-marketing audits and gives an example question. While it doesn't explicitly state when not to use, the context is clear and sufficient for an agent to infer usage boundaries.

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 partial failure behavior with timing (5-30s) and graceful degradation via sources_failed. Mentions return structure. Annotations already provide safe/idempotent hints, and description adds valuable context beyond annotations.

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

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

Well-structured with key info upfront, but slightly dense single paragraph. Could be broken into bullet points for easier parsing, but still 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?

Given complexity (two external services, no output schema), the description thoroughly covers inputs, outputs, behavior, and limitations. Complete for agent decision-making.

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

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

Adds context beyond schema: scoped packages accepted, default version behavior. Schema already covers all parameters, so this is extra helpful detail.

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?

Explicitly states it is a composite check for npm packages aggregating data from deps.dev and bundlephobia. Clear verb+resource with differentiation from sibling tools like deps.dev:version.

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

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

Explicitly says when to use (safety, popularity, size questions) and when not to use (non-NPM ecosystems) with alternative mentioned.

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

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

Annotations already indicate readOnly, idempotent, and non-destructive. The description adds valuable behavioral details: 'BGE-base-en embeddings + cosine over 500-char overlapping windows; cap is 200K chars (longer inputs are truncated and flagged).' 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 front-loaded with the core purpose, each sentence adds unique value, and there is no redundancy. Efficient and well-structured.

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

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

Despite no output schema, the description clearly states return format: 'get back the top-N passages with character offsets and similarity scores.' It covers input constraints, embedding details, and use cases fully for a simple 3-parameter tool.

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

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

Schema coverage is 100%, but the description adds meaning: text max ~200K, query described as natural-language with examples, limit default 5. This extra context improves understanding beyond the schema.

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

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

The description clearly states 'Semantic search INSIDE a fetched record' with a specific verb and resource. It distinguishes from siblings by explaining how it pairs with ask_pipeworx_grounded, saying 'fetch with the gateway, ground over the relevant passages instead of the whole document.'

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

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

Explicitly says when to use: 'Use when the record is too big to cram into the prompt — search_within saves context.' It also provides an alternative pair tool, giving clear guidance on choosing between tools.

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

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

The description discloses behavioral traits beyond annotations: OAuth requirement, SMS phone verification, 10/day SMS cap, webhook HMAC signing and auto-disable after 10 failures. It also notes that the subscription is persistent and the feed is always on. 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 fairly long but every sentence adds value. Critical info (purpose, requirement, types, delivery) is front-loaded. Minor repetition across delivery channels could be trimmed, but overall it's 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?

For a subscription creation tool with 3 parameters (2 required), the description covers all inputs with examples, constraints, and delivery details. It also mentions the return of subscription ID. No output schema is needed given the straightforward return value.

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 rich context: for each type (e.g., sec_8k with items codes, polymarket_edge with min_spread_bps) and delivery channels (e.g., webhook includes HMAC signing and auto-disable). This significantly supplements 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: 'Create a proactive monitoring subscription to a live-data event stream' and mentions the return value 'Returns the new subscription id.' This distinguishes it from sibling tools like list_subscriptions and recent_alerts.

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

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

The description explicitly states a prerequisite: 'Requires a Pipeworx OAuth account (anonymous + BYO cannot persist subscriptions).' It also provides type-specific examples and delivery options, but does not explicitly state when to avoid this tool in favor of 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 readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds that the tool returns example questions with exact tool calls and that calling without arguments gives full spread or with topic focuses. 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 slightly long but front-loads the purpose and includes useful examples. It is efficient without redundant words. Could be more concise 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?

Despite no output schema, the description explains the return format (category-bucketed example questions with tool and argument shape). It covers usage scenarios and parameter behavior adequately given the tool's complexity.

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

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

Schema coverage is 100%, but the description enhances the parameter meaning by listing example topics and clarifying that omitting the topic yields a cross-category spread. This adds semantic value beyond the schema.

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

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

The description uses specific verbs like 'returns category-bucketed example questions' and clearly identifies the tool as the onboarding entry point. It distinguishes itself from siblings by being the first tool to use when unfamiliar with Pipeworx's capabilities.

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

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

The description explicitly states to use this tool first when uncertain about Pipeworx's capabilities or to learn meta-tool usage. It doesn't explicitly name alternative tools, but the context signals a clear primary use case.

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 key behaviors beyond annotations: ownership enforcement, deactivation vs deletion, and impact on historical data. No contradiction with annotations.

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

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

Two concise, front-loaded sentences. First sentence states action, second adds essential constraints. 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?

Fully covers purpose, constraints, behavior, and side effects for a simple one-parameter tool with no output schema.

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

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

Schema coverage is 100% with clear parameter description. Description adds context (use with subscribe's id) but does not significantly surpass 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?

Clearly states 'Cancel a subscription by id' with specific verb and resource. Differentiates from siblings like subscribe and list_subscriptions by focusing on cancellation.

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

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

Explicitly says ownership is enforced (only cancel own subscriptions) and links to recent_alerts for historical events, providing when and when not to use.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive hints. The description adds critical behavioral context beyond those hints: the exact meaning of 'could_not_verify' (not evidence), the distinction between 'unsupported' and 'could_not_verify', and the two routing paths. This prevents serious misuse and is exactly the kind of disclosure needed.

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 longer than average, but nearly every sentence earns its place: trigger, pipeline routing, verdicts, caller warnings, and efficiency claim. It is front-loaded with the core purpose and uses quoted example phrases effectively. A small amount of redundancy (e.g., restating 'natural-language' while quoting examples) prevents a perfect score.

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

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

With no output schema, the description thoroughly explains return verdicts, includes a citation format, and covers error semantics. It also distinguishes between financial and non-financial paths and addresses ambiguous outcomes like 'could_not_verify' and 'unsupported'. For a complex tool, this is remarkably complete.

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

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

Schema description coverage is 100% with rich detail for both 'claim' and 'tolerance_pct', including examples, ranges, and defaults. The description adds contextual value by referring to 'exact percent-delta math' and the tolerance implications of claim wording, but the schema already carries most of the parameter burden, so a slightly above-baseline score 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 a natural-language claim verification tool with a specific verb ('validate') and resource ('claim'), and immediately differentiates it from general Q&A siblings by framing it as fact-checking user statements against authoritative sources.

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 whenever the agent needs to check whether something a user said is factually correct') and explains the routing for company-financial vs other claims. However, it does not explicitly name alternative tools to prefer or state when not to use it, so it falls just short of full guidance.

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