Twitch

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

Annotations already declare readOnly, idempotent, and non-destructive traits. The description adds valuable context: default model is free, Anthropic requires a user-provided key with direct payment, and the key is passed through without hidden costs. It also explains the return structure (per-model fields).

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 the main purpose front-loaded. It uses four sentences covering purpose, default behavior, key handling, return format, and use cases. There is minimal redundancy, though it could be slightly tighter.

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

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

No output schema exists, so the description compensates by detailing return fields (score, confidence, signals, raw_response) and a combined view. It also addresses cost, authentication, and optional disambiguation, making it sufficiently complete for an agent to use the tool correctly.

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

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

Schema coverage is 100%, but the description enriches parameters beyond the schema: it explains why models array has 'anthropic' option, the _apiKey parameter's cost implications, and the context parameter's disambiguation role. This adds significant meaning for an AI agent.

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

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

The description clearly states the tool probes LLMs for knowledge about an entity and scores visibility (0-100). It distinguishes itself from sibling tools like ask_pipeworx or entity_profile by focusing on AI visibility scoring, and it mentions specific use cases (AI-marketing audits, pre-launch brand checks).

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

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

The description lists use cases but lacks explicit when-to-use vs. when-not-to-use guidance or direct comparison to alternatives like deep_research or entity_profile. The implied usage is clear, but no exclusions or alternative tool references are provided.

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

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

Annotations already convey readOnly, idempotent, open-world, and non-destructive behavior, so the bar is lower. The description adds useful behavioral context beyond annotations: it routes to one of 5,724 tools, fills arguments automatically, returns structured answers with stable pipeworx:// citations, and is described as a single fast call. 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 information-dense and front-loaded with the most important directive ('PREFER OVER WEB SEARCH'). Examples and routing guidance earn their place; there is little repetition, though it could be tightened around the 'START HERE' and 'Use whenever' sections.

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, six parameters that are all aliases, and no output schema, the description provides enough context to select and call it correctly. It covers return characteristics (structured answer with citations), scope, trigger phrases, alternatives, and tier/account notes. Nothing essential for invocation 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%, but the schema only documents 'question' and its aliases, so the description must add real meaning. It does so by explaining what kinds of natural-language questions are appropriate, giving examples, and stating the outcome (routed, executed, cited answer). This goes beyond the schema's alias-only 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 names a specific verb-plus-resource behavior: it routes questions to the right source tool and returns structured answers with citation URIs. It distinguishes itself from web search and from sibling tools like ask_pipeworx_grounded and deep_research. Concrete examples and a domain list 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?

It explicitly says 'PREFER OVER WEB SEARCH' and 'START HERE for most questions', lists trigger phrasings, and gives both examples and exclusions. It also names alternatives with exact conditions: use ask_pipeworx_grounded for hallucination-resistant evidence and deep_research for broad/multi-part fan-out. This gives an agent clear selection logic.

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

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

Annotations already provide readOnly, idempotent, openWorld, and non-destructive hints. The description adds valuable context: beta status, no active candidate as of 2026-07-26, current exact match to stable ask_pipeworx, live comparison for potential merges, and explicit statement that it 'falls back to nothing'. This goes beyond the structured fields by explaining the experimental lifecycle and current operational state.

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 concept ('Beta version of ask_pipeworx: identical universal router...') and each subsequent sentence adds distinct information: current state, usage instruction, and clarification of non-fallback status. Though there is slight emphasis repetition ('same', 'exactly'), every sentence earns its place and the structure moves from identity to behavior to usage.

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

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

As a complex router with 5,724 tools and no output schema, the description fully conveys its experimental nature, current equivalence to the stable router, and usage intent. It lacks an explicit description of the response shape (only 'same response shape' without detailing what that shape is) and does not warn about potential experimental degradation, but given that it currently matches ask_pipeworx and annotations cover safety, it is sufficiently complete for correct invocation.

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

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

The schema already covers all 6 parameters with 100% descriptive coverage, including the primary 'question' and its aliases. The description adds no parameter-specific detail, which is acceptable given the schema's completeness; the baseline of 3 applies because no additional meaning is required or provided.

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

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

The description clearly identifies this as a beta version of ask_pipeworx, a universal router that dispatches natural-language questions across 5,724 tools. It distinguishes itself from the stable ask_pipeworx by its experimental routing improvements and explicitly notes it currently matches ask_pipeworx exactly. This gives an agent a clear, non-tautological purpose.

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

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

It directly instructs to 'Use it exactly like ask_pipeworx when you want the newest routing' and contrasts with the stable router, implicitly naming the alternative. It also clarifies that this is not a fallback but a fully functional router, preventing misuse. This is explicit when-to-use guidance with a clear alternative.

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

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

Annotations already convey readOnly, idempotent, open-world, and non-destructive behavior, and the description builds on this by explaining the refusal behavior and output shape: success returns {answer, evidence, confidence, source, fetched_at}, while failure returns explicit refusal_reason values. It also discloses a key non-obvious trait: the answer is extracted only from tool results, never invented.

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

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

The description is information-dense with no filler: it leads with the core behavior, includes the exact return and refusal shapes, states use cases, and closes with the cost tradeoff. Every sentence contributes to correct selection and invocation.

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

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

Despite no output schema, the description fully specifies the success and failure return structures, making invocation behavior predictable. It also addresses routing, sibling differentiation, cost, and usage context, leaving no meaningful gap for an agent to call this tool correctly.

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

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

Schema description coverage is 100% and the single required parameter 'question' plus its five aliases are fully described in the schema. The tool description adds no parameter-level meaning, but none is needed because the schema already clarifies that aliases are accepted and natural language is expected.

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

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

The description states a specific verb and resource: it is a 'hallucination-resistant answer mode' that routes like ask_pipeworx, fetches data, and 'EXTRACTS the answer using ONLY what the tool result contains.' It explicitly distinguishes itself from ask_pipeworx by emphasizing grounded answers and explicit refusals rather than generation.

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

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

It gives explicit when-to-use guidance: 'Use whenever an answer will be quoted, cited, or acted on' and 'the agent must not invent facts.' It also gives a concrete when-not-to-use instruction: 'prefer ask_pipeworx for casual lookups,' and even names the cost tradeoff of one extra LLM call.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description goes far beyond: details fan-out logic, classifier list, response shapes, resolver contract, parent_event extractor, news fallback fields, safety short-circuits, illiquid spread handling, and resolution-rule risk. 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 very long but well-organized with clear sections, examples, and field definitions. Every sentence adds unique information, but it could be slightly more streamlined without losing essential details. It is functional rather than concise.

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

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

No output schema is provided, so the description must describe response shapes. It thoroughly explains result.market, result.analysis, result.evidence, resolver contract, parent_event, news fields, and safety behaviors. Covers edge cases like closed markets, wide spreads, and cancellation rules. Extremely 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%, baseline 3. The description adds substantial meaning: explains 'market' can be slug/URL/question text, 'depth' controls evidence sourcing (quick vs thorough), and 'include_raw' controls payload size with explicit use cases. Examples further clarify parameter usage.

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

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

The description clearly states the tool's purpose: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It details inputs (slug, URL, question text) and outputs (evidence packet, market-vs-model comparison), and implicitly distinguishes from sibling tools like 'polymarket_arbitrage' by focusing on single-bet research.

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

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

Provides explicit use cases ('Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z"'), fan-out examples per category, and guidance on inspecting market_match_confidence before trusting analysis. Also describes blocking conditions (low confidence, closed markets) and when to check cancellation rules.

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

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

Adds significant behavioral context beyond annotations: describes data sourced (SEC EDGAR/XBRL, FAERS), handling of off-calendar fiscal years, sorting by primary metric, and return format (paired data + citation URIs). No contradiction with readOnlyHint, idempotentHint, etc.

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

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

Description is well-structured with usage triggers at the start, functional details in the middle, and efficiency claims at the end. Some redundancy (e.g., mentions parallel call and replaces sequential lookups twice) but overall each sentence adds value.

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

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

For a tool with 2 parameters, no output schema, and rich annotations, the description covers input semantics, data sources, sorting, and return format. Could mention limitations (e.g., only public companies, only FDA drugs) but is otherwise thorough.

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

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

Schema coverage is 100%, and the description enriches parameters by explaining that 'type=company' pulls revenue/net income/cash/debt and 'type=drug' pulls FAERS counts, approval counts, trial counts. Also clarifies the 'values' array expects tickers/CIKs for companies and names for drugs.

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

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

The description clearly states it performs side-by-side comparisons of 2-5 companies or drugs, using specific verb 'compare' and resource 'entities'. It distinguishes from sibling tools like 'entity_profile' and 'validate_claim' by emphasizing parallel lookups vs sequential, and specifies data sources (SEC EDGAR for companies, FAERS for drugs).

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

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

Explicitly advises 'ALWAYS PREFER over sequential single-pack lookups when comparing entities', and provides natural language examples for invocation (e.g., 'X vs Y', 'rank these companies'). Implicitly guides against using when a single entity lookup suffides (use entity_profile instead).

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, and idempotentHint, and the description adds substantial non-obvious behavior beyond them: never-invented gaps[], contradiction scans, latency expectations, citation_uri fetchability guarantees, semantic excerpting of large records, and hop-based iteration. The 'NOT open-web search' claim clarifies, rather than contradicts, the openWorldHint annotation.

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

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

The description is front-loaded and information-dense, but it is quite long and somewhat redundant: contradictions[] are mentioned both in the main narrative and again in the depth explanation, and citation_uri details appear twice. A more structured layout with fewer repeated points would improve scannability without losing 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?

Despite having no output schema, the description fully explains the return packet: verbatim evidence, confidence, source, fetched_at, citation_uri, gaps[], contradictions[], and hop semantics. It covers latency, prerequisites, depth modes, and fallback routing, so an agent has everything needed to invoke the tool correctly.

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

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

The schema already covers both parameters (100% coverage), but the description adds meaning beyond the raw enum: it flags that depth:'thorough' requires a paid plan and explains the behavioral difference between quick, standard, and thorough hops. This is genuinely useful enrichment beyond the schema descriptions.

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

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

The description names a specific verb ('research') attached to a clearly defined resource: Pipeworx's structured data sources. It explicitly contrasts itself with open-web search and distinguishes from sibling tools like ask_pipeworx, so an agent can identify what this tool is and is not.

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

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

The description gives explicit when-to-use guidance: best for broad/multi-part questions over structured data, single lookups should use ask_pipeworx, and breaking/current-news topics should also prefer ask_pipeworx. It also states an account prerequisite and paid-tier requirement, leaving no ambiguity about readiness.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds that results include full input schemas with curated examples and are ready to call directly, which goes beyond 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?

The description is front-loaded with the key purpose, followed by domain list and behavior details. Slightly long but each sentence earns its place. Could be trimmed slightly but no major waste.

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

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

Given the simple parameter structure (6 params, 5 aliases) and no output schema, the description covers purpose, usage, result contents (top-N tools with schemas), and when to call. Lacks mention of pagination or error handling, but not critical for this 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 all parameters described. The description adds value by clarifying that 'query' accepts aliases (task, q, etc.) and provides natural language examples, improving usability beyond 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 starts with a specific verb+resource ('Find tools by describing the data or task') and provides a comprehensive list of domains (SEC filings, FDA drugs, etc.), distinguishing it from sibling tools. It explicitly states the primary use case: call first to discover options.

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

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

Explicitly says 'Use when you need to browse, search, look up, or discover what tools exist' and 'Call this FIRST when you have many tools'. Lacks explicit instructions on when not to use (e.g., when the needed tool is already known), but the 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 indicate readOnly, openWorld, idempotent. Description adds details: fans out across multiple sources, specifies returned fields, notes patents API sunset and soft-fail behavior. No contradiction.

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

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

Description is detailed and informative, but somewhat lengthy. Every sentence adds value, front-loads with examples. Slightly verbose but still effective.

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

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

No output schema, but description fully explains return values (cik, company_name, recent_filings with URIs, fundamentals, patents, news, LEI) and covers limitations and fallbacks. Complete for a profile tool.

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

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

Schema coverage is 100% but description adds context: explains that type only supports 'company', value can be ticker or CIK, explicitly excludes names and suggests resolve_entity. Adds meaning beyond schema.

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

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

Clearly states it creates a 'full cross-source profile of a US public company' with examples like 'Tell me about X' and 'company profile for Microsoft'. Distinguishes from siblings by advising to prefer this over chaining single-source lookups and mentioning resolve_entity for names.

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

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

Explicitly says to use for holistic view, 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups'. Gives when-not-to-use: names unsupported, direct to use resolve_entity first. Provides clear input examples.

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. The description adds value by explaining the purpose of deletion (clearing sensitive data, stale context) and reinforcing that it is a deletion operation. 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 very concise: two sentences that front-load the action and follow with usage context. Every word earns its place with no redundancy.

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

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

For a simple 1-parameter delete operation, the description covers all essential aspects: what it does, when to use, and related tools. No output schema is needed as the behavior is straightforward.

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

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

The input schema covers 100% of parameters and provides a description for 'key'. The tool description mentions 'by key' but adds no new semantic detail 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 uses a specific verb ('Delete') and resource ('memory by key'), making the purpose immediately clear. It also distinguishes itself from sibling tools 'remember' and 'recall' by explicitly mentioning them as related but different operations.

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

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

The description explicitly states when to use the tool: when context is stale, task is done, or to clear sensitive data. It also provides guidance by directing to pair with remember and recall, covering usage context thoroughly.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds process details (fetch page, extract title/links) but no behavioral traits beyond what annotations imply.

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

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

Three sentences: first states core action, second describes process, third lists use cases. Concise, front-loaded, no redundant words.

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

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

With 2 simple parameters, clear annotations, no output schema needed (output described as text blob), and explicit use cases, the description is fully adequate for agent invocation.

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

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

Schema coverage is 100% so the schema documents both parameters fully. The description adds no extra meaning beyond the schema descriptions; it only restates the URL parameter's purpose.

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

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

The description states the specific verb 'Generate' and resource 'llms.txt file', and distinguishes it from 38 sibling tools by focusing on a unique purpose of creating an AI crawler index file.

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?

Lists three explicit use cases (client site indexing, own project, competitor auditing) but does not specify when not to use or name alternatives; however, no sibling tool overlaps in functionality.

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

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

Annotations already indicate read-only, idempotent nature. Description adds that it returns specific fields (streamer name, title, viewer count, thumbnail) and that game name is auto-resolved to ID, providing useful behavioral detail beyond annotations.

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

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

Two sentences plus an example. Every part adds value with no redundancy. Highly efficient and front-loaded with the core action.

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

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

Covers main purpose, filtering, and output fields. Lacks pagination details beyond the 'first' parameter, but given annotations and schema, it is sufficient for an agent to use correctly.

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

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

Schema coverage is 100%, so description's added value for individual parameters is limited. The example and note about omitting game provide some contextual meaning, but do not significantly enhance what the schema already conveys.

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

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

Clearly states it gets live Twitch streams with optional game and language filters. Purpose is specific and actionable, but does not explicitly differentiate from sibling tools like top_games or search_channels.

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 context: omit game for overall top streams, and includes an example. However, it does not specify when to use this tool over alternatives or when not to use it.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, etc. The description adds value by listing the exact profile fields returned (id, display name, view count, etc.) and showing the expected input structure with an example. This helps the agent understand what to expect beyond the annotations, though it does not discuss rate limits or authentication details already implied by the _apiKey parameter.

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

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

The description is two sentences plus a useful example. It is front-loaded with the purpose, immediately tells what the tool does, and the example shows concrete usage. Every sentence is necessary and there is 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 simple lookup tool with high schema coverage and no output schema, the description covers the key inputs and outputs. It lists the return fields and provides an example. Minor missing details: error handling if user not found, or clarification that the lookup is by exact login only. Overall, sufficient for an agent to use the tool correctly in most scenarios.

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?

Input schema coverage is 100% with descriptions for both login and _apiKey. The description's mention of 'login (username)' and the example adds minor context but does not provide significant new semantics beyond what is already in the schema per-property descriptions. With full coverage, the baseline is 3.

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

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

The description clearly states the tool looks up a Twitch user by login (username) and lists the profile fields returned. This distinguishes it from sibling tools like search_channels which likely do fuzzy searches. The verb 'Look up' and the resource 'Twitch user/channel' are specific, and the example reinforces the exact match intent.

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 does not explicitly state when to use this tool versus alternatives like search_channels or entity_profile. It implies exact lookup by login, but provides no guidance on when to choose different tools or what preconditions exist (e.g., must have known username). This is adequate but lacks proactive direction.

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

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

Annotations already declare safe read-only behavior. Description adds context on returned fields but does not mention any additional traits like pagination or rate limits. Since annotations cover safety, a minor gap is acceptable.

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

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

Two concise sentences, front-loaded with purpose, no wasted words.

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

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

No output schema exists, but description enumerates return fields. Tool is simple (one optional param), so description fully covers needed context.

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

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

Schema coverage is 100% with clear description for the single optional parameter. Description does not repeat parameter info, which is acceptable as 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 'List the caller's active subscriptions' and specifies returned fields (id, type, params, etc.). Distinguishes from sibling tools like subscribe/unsubscribe.

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

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

Provides explicit guidance: 'Use this to review what you're monitoring before adding more or to find an id to cancel.' Implies when not to use (modification tasks) by mentioning alternative actions.

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

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

Annotations are all false, so the description must carry the full transparency burden. It does so by disclosing rate limits (5/day), the claim_token round-trip behavior, that it's free and doesn't count against quota, and that the team reads digests daily. 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 appropriately sized for its complexity; it front-loads the purpose and then efficiently covers exclusions, token behavior, rate limits, and quota impact without repetition. Every sentence contributes unique operational 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?

Despite having no output schema, the description fully explains what feedback filing returns (claim_token) and how to retrieve status/fixes later. It also covers scope constraints (Pipeworx-only tools), rate limiting, and prompt hygiene, making it complete for an agent to handle 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?

Input schema already has 100% coverage with descriptions for all four parameters, so baseline is 3. The description adds practical semantics: mapping type enum values to concrete situations, clarifying the claim_token usage pattern ('pass it back later as...'), and instructing that message should not include end-user prompts.

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

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

The description clearly states that the tool sends feedback to the Pipeworx team about broken, missing, or desired functionality. It enumerates specific categories (bug, feature/data_gap, praise), distinguishing it from sibling ask_* tools which are for querying, not submitting feedback.

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

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

Provides explicit when-to-use conditions (bug, feature/data_gap, praise) and an explicit exclusion for tools from other MCP servers. It also tells users what to include (Pipeworx tool/pack names) and what not to include (end-user prompts), plus how to follow up using a claim_token.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false. The description adds valuable context: data derived from CF analytics engine, no PII, cached 5min-1h depending on window. No contradictions.

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

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

The description is concise with no filler. It uses bullet points for use cases and a clear sentence structure. Every sentence adds value.

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

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

Given the tool's simplicity (one optional parameter, read-only, no output schema), the description covers purpose, behavioral details (caching, data source), and use cases comprehensively.

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

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

The schema has 100% coverage for the single parameter (window). The description adds meaning beyond the enum values by explaining the trade-offs between shorter and longer windows, guiding selection.

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 top tools, top packs, and total call volume over recent windows. It distinguishes itself from siblings (e.g., discover_tools) by focusing on trending data derived from other agents' usage.

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

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

The description lists three specific use cases (discovering hot data sources, confirming canonical tool choice, checking alignment) and explains window trade-offs. It does not explicitly mention when not to use, but the use cases provide clear guidance.

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

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

Annotations declare readOnlyHint=true and destructiveHint=false, which the description does not contradict. The description adds rich behavioral context: walking child markets, checking monotonicity, partition_sum computation, Jaccard threshold, placeholders filter, and fill check against live CLOB depth. No annotation contradiction.

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

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

The description is lengthy (over 300 words) and could be more concise. However, it is well-structured with clear sections and front-loaded with the core purpose and modes. Some details about fill check and Jaccard similarity could be condensed without losing meaning.

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

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

Despite no output schema, the description specifies the response structure: opportunities[] with gap_pp, suggested_trade, reasoning, and partition_check fields in event mode. It covers edge cases (placeholders, low similarity, fill check) and gives complete guidance for an agent to invoke the tool correctly.

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

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

Schema coverage is 100%, with both parameters described. The description adds meaning beyond schema by explaining the difference between `event` mode (single event slug) and `topic` mode (cross-event scanning with seed question), including examples and behavioral details like Jaccard similarity and partition filter.

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: 'Find arbitrage opportunities on Polymarket via monotonicity violations + partition-sum checks.' It distinguishes three modes (no args, event, topic) and provides specific guidance, effectively differentiating from sibling tools like polymarket_edges and polymarket_fill_risk.

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

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

Explicit guidance is given: call with NO args for trending scan; pass `event` for a specific market (recommended); pass `topic` for cross-event scanning. It also tells when not to use it (e.g., for custom sizing use polymarket_fill_risk), providing clear when-to and when-not-to instructions.

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 readOnlyHint, idempotentHint, and non-destructive behavior. The description adds substantial behavioral context: caching behavior ('Cached 1h at the KV level'), explanation of model families, edge calculation, slippage handling, and diagnostics. 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 quite lengthy (multiple paragraphs) but well-structured with sections, bullet points, and clear details. While it provides comprehensive information, it could be more concise without sacrificing clarity.

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

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

Despite lacking an output schema, the description thoroughly explains the response structure (by_segment, fed_candidates, diagnostics) and includes details on edge_pp_net, kelly_fraction, and tradeable-edge knobs. It is complete for a tool with 9 parameters.

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

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

With 100% schema coverage, the baseline is 3. The description adds meaningful context beyond the schema, such as explanations for slippage_pp (execution slippage) and min_partition_leg_kelly (differentiating from min_kelly). It also clarifies defaults and behavior for several parameters.

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

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

The description clearly states the tool scans Polymarket markets for opportunities where Pipeworx data disagrees with market price, with a specific use case 'what should I bet on today.' It is specific about the resource and action, though it does not explicitly differentiate from sibling tools like polymarket_arbitrage, but the context makes its unique purpose apparent.

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

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

The description provides clear context for when to use this tool ('discover opportunities without paging hundreds of markets') and includes knobs for filtering. However, it does not explicitly state when not to use it or mention alternatives among siblings.

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

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

Description adds extensive behavioral details beyond annotations, including data structure, trend computation, handling of expired opportunities, and limitations like snapshot TTL and caching gaps. 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?

Description is well-structured with clear sections for purpose, parameters, response format, and limitations. It is front-loaded with the core purpose and uses no wasted sentences.

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

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

Despite the absence of an output schema, the description fully documents the response structure and computed fields, leaving no ambiguity about what the tool returns.

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?

Description supplements schema with default values, clamping behavior, and explanation of window parameter options, adding meaningful usage guidance beyond the schema's type and 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?

Description clearly states the tool provides edge persistence and decay telemetry from daily snapshots, and distinguishes itself from the sibling 'polymarket_edges' by focusing on time series and trend analysis.

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

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

Description provides context for when to use (e.g., to answer how long an edge has existed and if it is shrinking), but does not explicitly exclude alternatives or mention 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?

The description discloses detailed behavioral traits beyond annotations: ladder walking, return fields (top_of_book, vwap_fill_price, slippage_pp, etc.), basket-mode per-leg details, warning about partial fills converting arb to directional position. No contradiction with annotations (readOnly, idempotent).

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

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

The description is well-structured with clear sections for single-market and basket modes, front-loaded purpose. Every sentence adds necessary detail for the tool's complexity; no wasted words.

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

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

Given the tool's complexity (two modes, 4 parameters, no output schema), the description fully covers parameter usage, behavioral details, return fields, and risk warnings. Annotations cover safety and idempotency. 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%, so baseline is 3. Description adds meaning by explaining mode context (single-market vs basket) and size_usd interpretation (max spend vs target proceeds, settlement notional). Provides usage defaults and constraints beyond schema descriptions.

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

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

The description clearly states the tool checks realizable versus theoretical edge against live order book depth, and distinguishes two modes (single-market and basket). It explicitly differentiates from sibling tools like polymarket_arbitrage and polymarket_edges by stating when to use it.

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

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

The description provides explicit when-to-use guidance: before acting on polymarket_arbitrage signals or polymarket_edges trades above ~$500. It explains why (theoretical overround not capturable on thin books, partial fills create directional 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 already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructiveHint. The description goes far beyond this, explaining matching logic, compatibility codes, skipped pair classifications, temporal alignment caveats, fee treatment, and why returned spreads are gross not net. This is exemplary behavioral disclosure for a complex analytical tool.

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

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

The description is long but highly structured, using labeled sections, explicit code identifiers, and a logical flow from purpose to modes to outputs to caveats. Almost every sentence carries operational value. It is slightly redundant in a few places, such as repeating the meaning of temporal_alignment_unknown and reiterating that flags can be non-empty, but overall it is dense and purposeful.

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 carry the full burden of explaining response behavior. It does so thoroughly: leg-by-leg prices, top_spreads_pp, compatibility_warning, compatibility_codes[], skipped_unclassified, low_confidence_pairs[], temporal_alignment, fees_note, and skipped comparison counters are all explained. An agent calling this tool has enough context to interpret results correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful context beyond the schema: it explains how topic auto-fetches the matching event on each venue, how explicit parameters override the topic-mapped side, and that both modes run the identical token-overlap matcher. This is useful added semantics rather than mere repetition.

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

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

The description clearly states a specific function: computing cross-venue spreads between Kalshi and Polymarket for matching resolving questions. It explains two modes and the response shape. However, it does not explicitly differentiate itself from closely related siblings like polymarket_arbitrage or polymarket_edges, so it is clear but lacks sibling 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 gives strong context on when to use each mode: topic shortcuts for pre-mapped macro events and explicit ticker/slug pairs for custom comparisons. It also warns that most pre-mapped topics currently return compatibility warnings and that pre-mapped does not mean tradeable. It does not explicitly compare against alternative sibling tools, but it does guide usage within this tool well.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. Description adds valuable detail on scoping by identifier (anonymous IP, BYO key hash, or account ID) and pairing with siblings, going 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 concise, with three sentences that are front-loaded and each sentence adds distinct value: purpose, usage context, and pairing.

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

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

For a simple read-only tool with one optional parameter and no output schema, the description fully covers behavior, scope, and relationship to siblings, leaving no ambiguity.

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

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

Schema has 100% coverage with one optional 'key' parameter and description. The description adds the crucial behavior that omitting the key lists all saved keys, which is not explicit in the schema.

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

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

The description clearly states the tool retrieves a previously saved value or lists keys, using specific verbs 'retrieve' and 'list', and distinguishes from siblings 'remember' and 'forget'.

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

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

The description explicitly says to use it for looking up previously stored context without re-deriving it, and pairs it with remember and forget. It lacks explicit 'when not to use' but provides 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?

The description discloses the key behavioral trait of optionally marking events as read via mark_read, which is a state change. However, this contradicts the annotation readOnlyHint=true, which implies no state modification. The description adds important context that annotations fail to capture, hence a 4 but with an annotation contradiction flagged.

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

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

The description is four sentences, front-loaded with the core action, and each sentence adds value. No redundancy or filler. Perfectly concise for the information provided.

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 return fields (source, citation_uri, raw event payload). It covers all parameters, provides use-case guidance (polling, alternative endpoint), and gives sufficient context for an agent to use the tool correctly. 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%, baseline 3. The description adds meaning by explaining that type and since are filters, limit controls max events, mark_read flags events as read, and unread_only is implied. It provides use-case context beyond the schema, such as 'Polls work fine' and the alternative endpoint, justifying a 4.

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

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

The description clearly states 'Pull fired events from your subscription feed' and details the returned fields (source, citation_uri, raw event payload). It distinguishes itself from sibling tools by providing a specific verb and resource, though no direct sibling for alerts exists. The description is specific and unambiguous.

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

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

The description provides explicit guidance on when to use the tool: filter by type and/or since ISO timestamp, use mark_read to acknowledge events, and notes that polling works fine. It also mentions an alternative GET endpoint for scripts/dashboards, giving clear usage context and exclusions.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description adds performance (parallel call), data source fallback details, PatentsView API sunset limitation, and return structure (grouped changes, counts, citation URIs). No contradictions.

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

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

Single paragraph packs purpose, examples, data sources, parameter guidance, and sibling distinction. Front-loaded with example queries. Slightly dense but efficient; no wasted words. Could benefit from bullet points but remains 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?

High complexity with multiple sources and fallbacks; no output schema. Description covers purpose, usage context, parameter semantics, behavioral traits (parallel, fallback, soft-fail), and return structure. Complete for an agent to invoke correctly.

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

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

Schema coverage is 100% with descriptions for all 3 parameters. The description adds value by providing example values ('7d', '30d', '3m', '1y'), recommended defaults ('Use "30d" or "1m"'), and accepting both ticker and CIK for 'value'. Enhances clarity beyond the schema.

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

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

Description starts with example queries, clearly states it's a 'change feed for a company' in a given window, and lists specific data sources (SEC EDGAR, GDELT→GNews, USPTO). It distinguishes from the sibling tool 'entity_profile' which provides static profiles.

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

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

Provides explicit guidance: use entity_profile for static profiles instead. Includes example query patterns and suggests default 'since' values like '30d'. Also describes fallback behavior (GDELT→GNews) and soft-fail for USPTO, helping the agent decide when to use or avoid.

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

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

The description adds behavioral context beyond annotations: key-value scoping by identifier, persistence for authenticated users, and 24-hour retention for anonymous sessions. This complements the idempotentHint and destructiveHint annotations without contradiction, providing a complete behavioral profile.

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 with no wasted words. It is front-loaded with the core purpose, followed by usage guidelines and behavioral details. Every sentence earns its place.

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

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

Given the tool's simplicity (two required string params, no output schema), the description covers purpose, usage, storage behavior, lifetime, and sibling tools. It is complete for an agent to select and invoke correctly, even without additional structured information.

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

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

Schema coverage is 100%, so the baseline is 3. The description's examples (e.g., 'subject_property') add minor context but do not significantly enhance understanding beyond the schema descriptions. The value is adequate but not exceptional.

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

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

The description uses a specific verb ('Save') and resource ('data') and clearly states the purpose ('reuse later across conversations or sessions'). It distinguishes from sibling tools by mentioning 'recall' and 'forget', making it clear what this tool does versus others.

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

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

The description explicitly says 'Use when you discover something worth carrying forward' and provides examples (ticker, address, preference). It also recommends pairing with recall and forget. While it doesn't explicitly state when not to use, the guidance is clear and sufficient for an AI agent.

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

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

The description richly discloses behavior beyond the annotations: it explains the cross-source identity spine, non-equity instrument resolution, multi-candidate ambiguity via `figi_candidates`, explicit `unresolved` reporting, graceful degradation when GLEIF/OpenFIGI is unavailable, and the internal cascade that replaces 2-3 lookups. This is far more than the readOnly/openWorld/idempotent annotations provide, and nothing contradicts 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 essential guidance is front-loaded with examples and a clear "Use FIRST" directive, but the description quickly becomes a dense, sprawling paragraph with lengthy parentheticals and nested clauses. It would benefit from structured bullets for entity types, input formats, and failure modes; as written it sacrifices readability for exhaustiveness.

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, the absence of an output schema, and the high-stakes ambiguity of entity resolution, the description covers the critical contexts: supported types, accepted input forms, multi-match behavior, unresolved identifiers, source labeling, ISIN-to-LEI coverage, and degraded availability. An agent can safely decide when to invoke it and what to do with ambiguous or unresolved 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 already 100%, but the description goes much further by giving concrete examples for both `type` and `value`, explaining ticker/CIK/ISIN/company-name input forms, and warning against passing full noun phrases like "NEW YORK ST DORM AUTH revenue bonds." This adds operational meaning that the schema alone would not convey.

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

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

The description uses a precise verb phrase — "resolve a user-spoken NAME to the canonical/official identifiers" — and names the supported entity types with their concrete identifier outputs (CIK, LEI, FIGI, RxCUI). It clearly differentiates resolve_entity from identifier-consuming tools by stating it is the first step when a name but no ID is available.

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

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

The description gives explicit guidance with the underlined-and-capitalized "Use FIRST whenever you have a name but need an ID," along with many example phrasings. However, it does not explicitly name sibling tools as alternatives or give when-not-to-use conditions, so the exclusion guidance is limited despite strong positive usage direction.

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

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

Annotations already provide readOnlyHint, openWorldHint, etc. Description adds that it probes each entity with ai_visibility_check and returns ranked list with score, confidence, signal density. Also explains models parameter auth requirements, adding 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?

Three sentences, front-loaded with main purpose. No wasted words. Each sentence serves a purpose: what it does, how it works, and when to use.

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 purpose, usage context, parameter roles, and return type (ranked list). Given no output schema and good annotations, description provides sufficient detail. Could mention any rate limits but not essential.

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

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

Schema has 100% description coverage, but description adds value: explains first entity is treated as subject, models parameter details (default vs Anthropic key), and role of context parameter. Goes beyond schema descriptions.

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

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

Clearly states the tool compares AI visibility across multiple entities, ranks them, and identifies most/least recognized. Distinguishes from sibling tools like ai_visibility_check (single entity) and compare_entities (more general). Verbs and resource are 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?

Explicitly suggests competitive AI-marketing audits and gives an example question. Implies usage context but does not explicitly state when not to use or name alternatives. Still clear enough for an agent to decide.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds behavioral details like partial failures, bundlephobia timing (5-30s), and sources_failed list, providing context beyond annotations.

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

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

The description is front-loaded with the core purpose and usage, then details limitations. It is longer but every sentence is informative. Minor conciseness could be achieved by merging some points, but overall it is well-structured.

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

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

Given the tool has two parameters and no output schema, the description covers the return structure (summary block, per-advisory details, links, alternatives) and partial failure behavior. It is fully adequate for the complexity.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by noting that scoped packages (e.g., '@types/node') are accepted, which is not in the schema. However, it does not add significant syntax details beyond what the schema provides.

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

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

The description clearly defines the tool as a composite check for npm packages using deps.dev and bundlephobia, answering questions about safety, popularity, and size. It uses specific verbs and resources, distinguishing it from any sibling tools.

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

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

The description explicitly states when to use: 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me".' It also notes the NPM-only limitation and directs to an alternative for other ecosystems.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds return fields and an example, but does not discuss pagination, rate limits, or behavior with empty queries.

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 and an example: no wasted words. Front-loaded with verb and resource, then example. Excellent conciseness.

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

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

Given no output schema, the description explains return fields well. It could mention pagination (first param) and error handling for no results, but overall it is sufficiently complete for a simple search tool.

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

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

Schema coverage is 100%, so each parameter is documented. The description adds an example demonstrating query and live_only usage, but does not provide additional semantics beyond the schema.

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

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

The description clearly states it searches Twitch channels/streamers by name or keyword, and lists returned fields (display name, game, live status, title, thumbnail). This distinguishes it from sibling tools like get_user (single user) or get_streams (streams not channels).

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

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

The description implies usage for finding channels but does not explicitly state when to use this tool vs alternatives like get_user or get_streams. No guidance on when not to use or prerequisites.

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

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

Annotations already indicate read-only, open-world, idempotent, non-destructive. Description adds details about embeddings (BGE-base-en), window size (500-char), char cap (200K), and that 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?

Description is focused and well-organized: purpose, usage, internal details, pairing, constraints. Every sentence adds value; 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 no output schema, description fully explains what is returned (passages with offsets and similarity scores). Covers all input constraints and pairs with a sibling for grounding context.

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

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

Schema coverage is 100%, so baseline 3. Description adds examples for query, explains text is the document, and states limit default (5). Provides meaningful context 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?

Clearly states it performs semantic search inside a fetched record, returning relevant passages with offsets and scores. Distinguishes from siblings by mentioning pairing with ask_pipeworx_grounded and the use case of large records.

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

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

Explicitly advises when to use: 'when the record is too big to cram into the prompt.' Also explains pairing with ask_pipeworx_grounded and notes the 200K char cap with truncation.

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

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

Annotations already provide idempotentHint=true, readOnlyHint=false, destructiveHint=false. The description adds rich behavioral details: returns subscription id, requires authentication, explains delivery channels with limitations (10/day SMS cap, webhook auto-disable after 10 failures), and required verification steps.

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

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

The description is comprehensive but slightly lengthy. However, it is well-structured with front-loaded purpose, clear sections for types and delivery, and uses examples effectively. Every sentence adds value, though some internal repetition could be tightened.

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 (3 params, nested objects, many sibling tools, no output schema), the description is fully complete. It explains all subscription types, delivery options, constraints, and required prerequisites. The absence of an output schema is compensated by stating returns subscription id.

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?

Input schema covers parameters with 100% description coverage. The description adds extra meaning by providing type-specific examples and constraints (e.g., phone must be verified, webhook restrictions, signing secret). It clarifies the nested param and delivery objects with concrete usage patterns.

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

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

The description clearly states the tool creates a proactive monitoring subscription to a live-data event stream, with specific verb ('Create') and resource ('subscription'). It distinguishes itself from siblings like list_subscriptions and unsubscribe by focusing on creation of persistent subscriptions.

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

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

The description explains when to use (proactive monitoring) and includes important prerequisites (Pipeworx OAuth, not anonymous/BYO). It does not explicitly state when not to use or name alternatives, but the context of siblings implies the scope.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds that it returns 'category-bucketed example questions' with 'exact tool + argument shape' and specifies behavior when topic is provided versus omitted, enriching transparency beyond annotations.

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

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

The description is appropriately sized for an onboarding tool, front-loaded with synonyms and usage examples. It is slightly verbose but 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 simple interface (one optional param, no output schema), the description fully covers the purpose, usage, return content, and context (e.g., meta-tools). It is complete for an agent to understand when and how to call it.

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

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

Schema coverage is 100% with one optional parameter. The description adds meaning by listing example topic values ('finance', 'pharma', etc.) and explains the behavior when topic is omitted versus provided, which goes beyond the schema description.

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

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

The description explicitly states it is the 'onboarding entry point' for an agent that just connected, listing multiple synonyms like 'what can I ask Pipeworx?' and clearly states it returns category-bucketed example questions. It distinguishes from siblings by being the first-use discovery 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 says 'Use this FIRST when you do not yet know what Pipeworx can do for you, or to learn how to call the meta-tools.' It also explains how to narrow by topic. While it does not explicitly mention when not to use it or detail all sibling alternatives, the guidance is clear for an onboarding 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 this as read-only, idempotent, open-world, and non-destructive. The description adds that results are ranked by viewers and return specific fields, but it does not disclose additional behavioral traits like rate limits, caching, or authentication behavior beyond what the schema covers. Given the rich annotations, the description provides adequate but not extra transparency.

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

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

The description is a single concise sentence followed by a clear example. Every word is necessary and front-loaded with the core purpose. No redundancy or extraneous 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 no output schema, the description adequately specifies the return fields (game id, name, box art) and ranking method. It could mention the default value of 'first' or the authentication trade-off, but these are covered in the schema. Overall, it is sufficiently complete for a straightforward read-only tool.

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

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

The input schema has 100% coverage, describing both 'first' (number, default 20, max 100) and '_apiKey' (optional string for custom credentials). The description's example ('{ first: 20 }') demonstrates usage but adds no semantic meaning beyond the schema. The baseline 3 is appropriate as the description does not enhance parameter understanding.

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

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

The description clearly states the verb 'Get', the resource 'top games currently being streamed on Twitch', the ranking criterion 'by number of viewers', and the return fields (game id, name, box art). This fully distinguishes it from sibling tools like get_streams which returns streams rather than aggregated game data.

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

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

The description provides no guidance on when to use this tool versus alternatives like get_streams or search_channels. It does not specify prerequisites, such as needing a Twitch API key for higher limits, nor does it explain when the tool should be avoided. The example shows usage but does not clarify scenarios.

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 (non-destructive, mutable), the description adds critical detail: ownership enforcement, deactivation (not deletion), and retention of historical data in 'recent_alerts'. This significantly aids agent 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?

Three sentences with no wasted words. First sentence states purpose, second adds constraint, third explains effect. Efficient and front-loaded.

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

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

Fully adequate for a simple one-parameter tool with no output schema. Covers action, constraint, and side effects with sufficient detail for correct invocation.

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

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

Schema provides 100% coverage for the single 'id' parameter. Description adds the note that the id comes from 'subscribe', giving agent useful source context beyond the schema.

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

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

The description states 'Cancel a subscription by id' with specifics on ownership and behavior (deactivation vs deletion), clearly distinguishing from siblings like 'subscribe' and 'list_subscriptions'.

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

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

Describes ownership enforcement and deactivation behavior, providing clear context for when to use. Lacks explicit when-not or alternatives, but tool purpose is well-separated from siblings.

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

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

Annotations indicate a read-only, open-world, idempotent operation. The description adds crucial behavioral nuance: the distinction between 'could_not_verify' (check did not happen, must not be treated as evidence) and 'unsupported' (no source covers it), plus the verification_error structure. This goes well beyond the annotations and is essential for correct interpretation of results.

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

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

Although the description is lengthy, every sentence carries substantive information: query examples, routing logic, return verdicts, and critical caller caveats. The structure front-loads purpose and usage, then details behaviors and dependencies, with no filler.

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

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

With no output schema, the description carries the full burden of explaining return values, which it does thoroughly by listing all possible verdicts and their meanings, the citation format, and reasoning field. It also covers error handling (verification_error) and the two-tier routing, making it complete for a tool of this complexity.

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

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

Schema already covers both parameters with descriptions (100% coverage), so baseline is 3. The description adds meaningful context for 'tolerance_pct' by explaining it overrides the claim's implied tolerance and how it's used for hallucination detection, and provides concrete examples for 'claim'. This elevates it above 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 identifies the tool as a natural-language claim verification tool with a specific verb ('validate') and resource ('claim'). It lists example query phrases and explicitly distinguishes its function from siblings by focusing on fact-checking 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 states 'Use whenever the agent needs to check whether something a user said is factually correct' and explains the two distinct execution paths (structured SEC EDGAR for company-financial claims, grounded pipeline for other claims). It also notes it replaces multiple sequential calls, giving clear when-to-use context and efficiency rationale.

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