Tiingo

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

The description adds valuable behavioral details beyond the annotations: the default model (Workers AI Llama-3.3-70b) is free, passing '_apiKey' enables Anthropic with direct billing to the user, and the return format is per-model {score, confidence, signals, raw_response} plus a combined view. The annotations already declare read-only/idempotent, so these cost and output details enhance transparency without redundancy.

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 redundancy. It front-loads the core action, then packs in default behavior, cost notes, return structure, and use cases efficiently. 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 moderate complexity and lack of an output schema, the description adequately covers the return structure, use cases, and billing nuances. Misses explicit error-handling or limitation notes, but for a read-only visibility probe, the description is sufficient for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3. However, the description adds meaning beyond the schema by clarifying the '_apiKey' parameter's cost implication ('you pay Anthropic directly') and explaining the default model behavior, which enriches the semantic understanding of the 'models' parameter.

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

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

The description states a specific verb ('Probe') and target resource ('LLMs'), and clearly defines the output as a visibility score (0-100) per model. This distinguishes it from sibling tools focused on search, research, or comparison, and scopes the subject to business/brand/product/topic.

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 concrete use cases: 'AI-marketing audits, pre-launch brand checks, competitive monitoring.' This gives clear context for when to use the tool, but it does not explicitly name alternative tools or state when not to use it, so it falls short of a full exclusionary guideline.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false. The description adds meaningful behavior beyond these: routes the question to one of 5,529 tools, fills arguments, returns a structured answer with stable citation URIs, and works on every tier. It does not contradict annotations; this context enriches the safety profile already provided.

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 directive 'PREFER OVER WEB SEARCH' and then efficiently explains routing, usage triggers, examples, and when to use alternatives. It is somewhat long, but every sentence adds relevant guidance for a default tool, making it appropriately sized rather than wasteful.

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

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

Given the tool's complexity as a router across thousands of sources and the absence of an output schema, the description sufficiently covers the return behavior (structured answer with pipeworx:// citation URIs) and context (works on every tier, fast call). It omits details like rate limits or failure modes, but for a default entry point the coverage is strong.

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, documenting all six properties including the required 'question' and its five aliases. The description adds examples of valid questions but no additional parameter-level semantics beyond what the schema already provides, so the baseline score of 3 applies.

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

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

The description clearly identifies the tool as a question-answering router for factual data, listing specific domains like SEC filings, FDA data, and economic statistics. It distinguishes itself from siblings by naming ask_pipeworx_grounded and deep_research as alternatives for different needs, making the purpose unambiguous.

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

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

The description provides explicit when-to-use guidance: 'PREFER OVER WEB SEARCH', 'Use whenever the user asks...', and 'START HERE for most questions'. It also explains when to step up to alternatives, such as ask_pipeworx_grounded for hallucination-resistant answers and deep_research for broad multi-part questions, giving clear contrast.

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 declare readOnly, openWorld, and idempotent hints, and the description adds beta-specific context: candidate routing improvements may be live, currently no candidate active so it matches ask_pipeworx exactly, and it 'falls back to nothing' meaning it's a full router. This goes beyond annotations without contradicting them.

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

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

The description is four sentences, front-loaded with the beta identity, and each sentence adds meaningful context—beta status, identical router, current state, usage instruction, and experimental nature. Slightly verbose but no 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 complexity (5,529 tools) and no output schema, the description explains the current routing state, usage, and safety profile. It could be more explicit about potential behavioral differences when a candidate is active, but it covers the essential selection criteria.

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 aliases documented. The description only says 'same arguments' without adding details, so it doesn't augment the structured schema information.

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 identifies the tool as a 'Beta version of ask_pipeworx' and a 'universal router' with the same 5,529 tools and response shape, which clearly distinguishes it from siblings like ask_pipeworx and ask_pipeworx_grounded. However, it relies on prior knowledge of ask_pipeworx to understand what the router returns, so it's not fully self-contained.

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

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

It explicitly states 'Use it exactly like ask_pipeworx when you want the newest routing' and notes that results are compared against the stable router. This gives a clear usage condition and names an alternative, but it doesn't explicitly state when not to use it (e.g., for guaranteed stable behavior), though 'beta' and 'experimental edge' imply caution.

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 refusal behavior with specific refusal_reason values, evidence as verbatim quote, confidence, source, fetched_at, and extra cost. These go well beyond the annotations (readOnly, idempotent, openWorld) and do not contradict them.

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

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

The description is 4 sentences but each adds essential value: purpose, mechanism, output/refusal format, usage guidance, and cost trade-off. It is front-loaded with the core concept and has no redundant 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?

Given no output schema, the description thoroughly specifies return structure and failure modes, including exact fields and refusal reasons. It also explains routing scope and cost, making it fully 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 all parameters documented as aliases for 'question.' The description reinforces the natural language question role but adds no new parameter semantics beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly identifies this as a hallucination-resistant answer mode that routes through Pipeworx and extracts answers only from tool results. It explicitly distinguishes itself from sibling ask_pipeworx by emphasizing grounded extraction and refusal behavior.

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

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

It gives explicit when-to-use ('whenever an answer will be quoted, cited, or acted on') and when-not-to-use ('prefer ask_pipeworx for casual lookups'), including the cost trade-off of an extra LLM call. This is comprehensive guidance that names the 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 declare read-only/open-world/idempotent, and this description adds extensive context: GDELT 429 fallbacks, low-confidence short-circuit suppressing analysis, market_closed_or_inactive status, wide-spread tradeability warnings, and cancellation-rule risk with flat-50¢ settlement. This goes well beyond the safety profile of the annotations.

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

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

The description is front-loaded with the core action, but it is extremely long and dense, with capital-letter labels (CLASSIFIERS, FAN-OUT EXAMPLES, RESPONSE SHAPES) embedded in a single paragraph. Many sentences earn their place, but the exhaustive fan-out examples and return-shape details make it over-specified for an opening description.

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 self-sufficiently covers all major response shapes (result.market, analysis, evidence), the resolver contract (match_confidence, alternatives, suggestions), parent_event extraction, news fallback flags, blocking statuses, and resolution-rule risk. This is a complete guide for a complex tool.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real semantic value: it explains how the `market` parameter resolves to candidates, the fan-out depth choices, and the trade-offs for `include_raw` (summarized vs 50KB-500KB payloads). It enriches rather than merely repeats the schema.

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

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

The description opens with a specific verb + resource: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It then details the resolution, classification, fan-out, and market-vs-model comparison flow, and the 'Use for' list clarifies its distinct role among research and betting 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?

Explicit when-to-use guidance is provided: 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z".' It also gives fan-out examples and identifies blocking edge cases, but it never names alternative sibling tools or states when not to use this tool, stopping short of a 5.

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

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

Annotations already declare readOnly/idempotent/non-destructive, but the description adds substantial behavioral context: it identifies the exact data pulled for companies (10-K revenue, net income, cash, long-term debt from SEC EDGAR/XBRL) and drugs (FAERS adverse-event counts, FDA approval counts, active trial counts), notes correct handling of off-calendar fiscal years, explains sorting by primary metric, and mentions the return format with citation URIs.

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

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

Though dense, every sentence contributes unique value: trigger phrases, command preference, data sources, fiscal-year handling, type-specific behavior, sorting, return format, and efficiency claim. The structure front-loads the core call to action and then expands with necessary detail without repetition.

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

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

For a two-parameter tool with no output schema, the description is exceptionally complete. It covers what data will be returned, how results are ordered, that paired data and citation URIs are included, and why this should be used instead of multiple lookups. The behavior for both company and drug types is fully disclosed.

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 documents both parameters with 100% coverage, but the description adds meaning beyond the schema: it maps type='company' to specific financial data fields, type='drug' to specific regulatory/adverse-event counts, and provides concrete examples for values (['AAPL','MSFT'], ['ozempic','mounjaro']) with mention of tickers/CIKs. This enriches parameter understanding significantly.

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

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

The description opens with concrete trigger query examples and explicitly states 'side-by-side comparison of 2–5 companies or drugs in ONE parallel call.' It clearly identifies the resource (companies/drugs) and the action (comparison), and distinguishes itself from sequential single-pack lookups by saying 'ALWAYS PREFER over sequential single-pack lookups when comparing entities.'

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

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

The description gives explicit when-to-use guidance: whenever a user is comparing entities ('Compare X and Y', 'rank these companies'), and explicitly calls out the alternative approach it should replace ('ALWAYS PREFER over sequential single-pack lookups'). It also differentiates behavior for company vs drug types, making the appropriate use case very clear.

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

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

Annotations already declare read-only and idempotent behavior, and the description adds that the tool returns OHLCV data and supports resampling frequencies. It does not cover rate limits or API key behavior beyond the schema, but with strong annotations the bar is lower and the added output context is valuable.

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

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

The description is two sentences with an illustrative example, front-loaded with the core action and resource. Every word contributes to understanding, with no fluff or 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?

The description includes the key output fields and a usage example, which is sufficient for a low-complexity read-only tool with rich annotations and fully described schema. No output schema exists, but the description covers the essential return 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 description coverage is 100%, so the baseline is 3. The description's example helps illustrate parameter usage but does not add technical semantics beyond what the schema already provides. It is consistent with the schema and adds marginal convenience.

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 with a specific verb ('Get'), a specific resource ('crypto prices'), and the exact data fields (open, high, low, close, volume). It distinguishes itself from sibling tools like stock_prices by focusing on cryptocurrencies and resample frequency.

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

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

The description gives clear context that this tool is for retrieving crypto price data, with an example showing typical usage. It does not explicitly mention alternatives or exclusions, but the crypto focus and example make the intended use case unambiguous.

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

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

Even though annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive, the description adds substantial context: account and paid-plan requirements, latency estimates, gap reporting with never-invented behavior, contradiction detection, citation_uri fetchability guarantees, and semantic excerpting. 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?

It is a single dense paragraph, front-loaded with account prerequisite and purpose, and every sentence adds a distinct fact about use cases, output format, or behavior. The length is justified for a complex tool with no output schema, but the formatting could be more scannable.

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

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

With no output schema, the description compensates by enumerating the findings packet fields, gaps[], contradictions[], hop, citation_uri, semantic excerpting, and latency. It also covers authentication, depth semantics, and alternatives, leaving little ambiguity about what the call will do and return.

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), including a detailed depth enum. The description adds useful extra semantics such as thorough requiring a paid plan and standard/thorough being framed as gap-recovery and lead-chasing behavior, which is more than the baseline but largely reinforces 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 identifies a grounded multi-source research tool: it states it researches Pipeworx's structured data sources in one call, decomposes questions into facets, routes them in parallel, and returns a findings packet. It explicitly distinguishes itself from open-web search and from the ask_pipeworx sibling.

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 direct when-to-use guidance: best for broad/multi-part structured-data questions, and explicitly says to use ask_pipeworx instead for single lookups, breaking/current news, or when not signed in. This is concrete and names the alternative tools.

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

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

Annotations already establish that the tool is read-only, idempotent, and non-destructive. The description adds valuable behavioral context: it returns top-N most relevant tools with names, descriptions, and full input schemas with curated examples, and states that results are ready to call with no second schema lookup needed. This goes beyond the annotations and helps set expectations about the response.

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 bit long but every sentence provides useful information: purpose, use cases, domain examples, return format, and a strong first-use directive. It is front-loaded with the core purpose and structured to lead the reader through value proposition and usage. Slightly verbose due to the domain list, but not wasteful.

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

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

Given the tool's complexity as a discovery mechanism and the absence of an output schema, the description adequately explains return values (top-N tools with names, descriptions, schemas, examples) and emphasizes direct usability. It does not cover every edge case like pagination or error handling, but for the stated use cases it is sufficiently complete.

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

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

Schema description coverage is 100%, with each parameter (query, q, task, limit, search, description) clearly documented, including aliases and defaults. The description does not add parameter-specific semantics beyond the schema, which is expected given the high coverage. The baseline of 3 is appropriate as the schema carries the burden.

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

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

The description clearly states the tool's purpose: 'Find tools by describing the data or task.' It uses a specific verb and resource, and distinguishes itself from sibling tools by focusing on discovery rather than direct domain queries. The list of covered domains and the promise of ready-to-call results further clarifies its unique role.

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 this tool: 'Use when you need to browse, search, look up, or discover what tools exist...' and 'Call this FIRST when you have many tools available and want to see the option set.' This provides clear context and effectively differentiates it from calling a specific tool directly.

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

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

Beyond the readOnly/idempotent annotations, the description discloses parallel fan-out across SEC, XBRL, USPTO, news, and GLEIF, the specific return fields, sorting order, a sunsetting API that soft-fails, and a GDELT→GNews fallback. This richly details behavior without contradicting annotations.

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

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

The description is dense but every sentence contributes: examples, purpose, alternatives, return fields, limitations, and input constraints. It is front-loaded with the most important usage cues. Slight length is justified by the tool's complexity, though it reads as one large block.

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 fully enumerates the return payload (cik, company_name, recent_filings with URI format, fundamentals fields, patents, news, LEI) and data sources. It also notes limitations and fallbacks, making the tool's behavior and output well-understood.

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

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

Schema coverage is 100%, providing baseline 3. The description adds value with concrete examples ('AAPL', '0000320193'), reinforces the zero-padding requirement for CIKs, and clarifies that names are not accepted — details beyond the schema's own descriptions.

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

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

The description clearly states the tool's purpose: building a full cross-source profile of a US public company. It uses specific verbs like 'profile,' 'research,' and 'brief me,' and explicitly distinguishes itself from siblings by instructing to prefer it over chaining single-purpose lookups.

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

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

Provides explicit when-to-use guidance ('ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view') and when-not-to-use ('names not supported — use resolve_entity first'). It also lists supported input types and fallback behavior clearly.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, so the description doesn't need to repeat that. It adds the use-case context about clearing sensitive data, but doesn't disclose additional behavioral traits like what happens if the key doesn't exist or whether deletion is reversible. This is adequate but not rich beyond what annotations provide.

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

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

The description is two sentences, with the primary action front-loaded in the first sentence and usage guidance in the second. No wasted words; every phrase contributes to understanding the tool.

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

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

For a simple tool with one parameter, no output schema, and clear annotations, the description covers the essential context: purpose, when to use, and relationship to sibling tools. It omits error behavior, but that is not critical for a basic delete operation. Overall, it is sufficiently complete for the tool's simplicity.

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

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

Schema description coverage is 100% for the 'key' parameter, and the description also references 'by key' but adds no extra meaning about formatting, constraints, or value semantics. The baseline 3 applies when the schema is sufficient, and this is the case here.

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

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

The description clearly states the tool's function: 'Delete a previously stored memory by key.' The verb 'Delete' plus the resource 'memory' makes the action explicit. It also distinguishes from siblings by contrasting with remember and recall, which store and retrieve memories.

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

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

The description provides explicit use cases: 'Use when context is stale, the task is done, or you want to clear sensitive data the agent saved earlier.' It also references related tools ('Pair with remember and recall'), giving clear guidance on when this tool fits relative to alternatives.

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

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

The description adds behavioral context beyond the annotations by explaining that it 'fetches the page, extracts title/description/key links, and emits the standard llms.txt markdown format' and that output is a 'single text blob ready to drop at site-root/llms.txt.' This clarifies the tool's read-only, idempotent nature, consistent with the annotations. It does not cover edge cases like authentication or rate limits, but the annotations already signal safety.

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

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

The description is concise (three sentences), front-loaded with the primary purpose, followed by process details and use cases. Every sentence adds value without unnecessary fluff, making it well-structured and easy to digest.

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

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

The description is complete for this tool's simplicity. It covers the purpose, process, output format, and practical use cases. With good annotations and a fully described schema, the description provides all needed context for an AI agent to select and invoke the tool correctly. No output schema exists, but the description explicitly states the return is a text blob, which is sufficient.

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

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

The input schema already describes both parameters (url and max_links) with clear descriptions, so coverage is 100%. The tool description does not add extra meaning to the parameters; it only implies the url by 'any URL' and mentions 'key links' without discussing max_links. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states the tool's function: generating a production-ready llms.txt file for any URL. It uses a specific verb ('Generate') and resource ('llms.txt'), and details the process (fetches the page, extracts title/description/key links, emits standard markdown), making its purpose unambiguous and distinct from sibling tools.

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

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

The description provides explicit usage scenarios: 'getting a client's site indexed by AI, drafting llms.txt for your own project, or auditing how an AI crawler would see a competitor.' This gives clear when-to-use context, though it does not explicitly mention alternatives or exclusions, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint as safe. The description adds value by detailing the return fields (id, type, params, timestamps, fire_count) and clarifies that it lists active subscriptions by default, which is not directly in the annotations. 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 two concise sentences, front-loading the core purpose and returning fields. Every word earns its place, with no fluff or redundancy.

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

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

Given the tool's simplicity (one optional parameter, no output schema, strong annotations), the description fully covers what the tool does, what it returns, and when to use it. It is sufficiently complete for an agent to select and 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?

The single parameter include_inactive is fully described in the schema (100% coverage), so the description doesn't need to add parameter details. Baseline 3 applies because the schema carries the explanatory burden.

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

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

The description clearly states the action ('List'), the resource ('the caller's active subscriptions'), and specifies the return fields. This distinguishes it from sibling tools like subscribe and unsubscribe, which perform 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 provides explicit use cases ('review what you're monitoring before adding more' and 'find an id to cancel'), which signals when to use this tool. While it doesn't name alternative tools explicitly, the context strongly implies differentiation from subscribe/unsubscribe.

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

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

Annotations already declare read-only/idempotent, and the description adds return field details and an example. It does not disclose rate limits or API key specifics beyond the schema, so it adds moderate value.

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

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

Two focused sentences—purpose/filters and return/example—with no redundancy or unnecessary words.

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

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

The description covers what the tool does, what it returns, and provides an example. Given no output schema and simple nature, it is sufficiently complete, though it could mention rate limits or shared key nuances.

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

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

The schema covers all parameters with descriptions, and the description's example clarifies usage but does not add significant meaning beyond the schema. Baseline 3 is appropriate.

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

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

Clearly states it retrieves recent financial news articles with optional ticker/tag filters. The description also lists the returned fields, distinguishing it from price or other data siblings.

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

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

Provides clear context that this is for news retrieval with optional ticker/tag filters. Does not explicitly exclude other tools, but the purpose is unambiguous.

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

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

Annotations are all false, so the description carries the full burden. It discloses the claim_token flow, rate limit (5/day), no quota impact, and what happens to feedback (daily digests, roadmap impact). 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?

Every sentence contributes: primary purpose, usage scenarios, exclusion, claim_token workflow, rate limit, and quota note. It is front-loaded with the core action and remains well-structured despite length.

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

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

For a feedback tool with 4 params, a nested object, no output schema, and a nuanced workflow, the description covers all necessary contexts: what to file, what not to file, how the claim token works, rate limits, and roadmap impact. Nothing essential is missing.

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

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

Schema coverage is 100%, so the bar is baseline 3. The description adds unique value for the claim_token parameter by explaining the round-trip mechanism ('pass it back later... to read whether it was fixed') and clarifies context expectations by telling users to describe issues in terms of Pipeworx tools/packs, which enriches the schema-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 opens with a specific verb and resource: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It clearly distinguishes this from sibling tools by framing it as feedback about the Pipeworx catalog itself, not a research or query 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?

Provides explicit when-to-use cases (bug, feature/data_gap, praise) and a direct when-not-to-use instruction: tools from other MCP servers should be reported elsewhere. This prevents misrouting and gives clear decision criteria.

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 extra behavioral context: the data source ('CF analytics-engine'), privacy guarantee ('no PII'), and caching behavior ('Cached 5min-1h depending on window'). This goes beyond the annotations and helps set expectations for freshness.

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, with a clear lead, a compact 'Useful for' bullet list, and a brief technical note. Every sentence adds value, though the three use cases could be seen as slightly overlapping. Overall it is well-structured and not bloated.

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 single-parameter read-only tool with no output schema, the description covers what the tool returns, the available windows, the intended use cases, and data freshness/caching. It is adequate for an agent to invoke correctly, though it doesn't specify the exact shape of the returned top tools/packs list.

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's window parameter already has a full description including '24h (default) | 7d | 30d' and the trade-off between hot and steady-state demand. The tool description's reference to 'recent window (24h, 7d, or 30d)' adds no new semantic meaning beyond repeating the schema. With 100% schema coverage, baseline 3 is appropriate.

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

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

Description starts with a clear statement—'What other AI agents are calling on Pipeworx right now'—and explicitly names the outputs (top tools, top packs, total call volume) and the window options. This distinguishes it from siblings like discover_tools by emphasizing real-time agent usage rather than general discovery.

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

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

The 'Useful for' section lists three specific scenarios (hot data sources, confirming canonical tools, alignment with agent needs), giving concrete context for when to use it. It doesn't mention exclusions or alternative tools by name, but the scenarios are actionable enough to guide selection.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, and the description adds extensive behavioral context: no-arg behavior (top ~200 markets), semantic Jaccard threshold 0.30, placeholder partition filtering (>20% returns null), and fill check comparing theoretical vs realizable edge with explicit 'do not trade it' guidance. This goes far beyond the annotations' safety 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 long but information-dense, with every section earning its place: modes, semantic anchor, partition filter, response format, fill check, and cross-tool reference. It is front-loaded with the core purpose and logically organized, though a bit verbose.

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

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

There is no output schema, so the description correctly specifies return values ('opportunities[] (gap_pp, suggested_trade, reasoning...)' and 'partition_check{...}'). It also covers edge cases (placeholder fraction >20% yields null), explains how to interpret fill-check results, and points to an alternative tool for custom sizing. Comprehensive for the tool's complexity.

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

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

Schema descriptions already cover both params with mode explanations (100% coverage). The description adds value beyond the schema with concrete examples like 'fed-decision-may-2026', clarifies that full URLs are accepted, and explains behavioral implications for each mode. However, the schema already carries the primary semantic load, so a 4 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?

States 'Find arbitrage opportunities on Polymarket via monotonicity violations + partition-sum checks' – specific verb, resource, and method. This clearly differentiates from sibling tools like polymarket_edges by naming the unique detection approach and its scope.

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

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

Provides explicit mode guidance: 'Call with NO args for a trending_scan', 'pass event for...', 'topic for...'. Also directs 'For custom sizing use polymarket_fill_risk' as an alternative. This is explicit when-to-use guidance plus an explicit alternative tool.

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

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

The description adds substantial behavioral context beyond the annotations: it discloses 1h KV-level caching, explains why segments might be empty via _diagnostics, details the model families and their thresholds, and explicitly notes that partition arbs always return parent-level kelly_fraction_half=0 and that min_kelly does not filter them. This goes far beyond the simple read-only and idempotent hints.

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

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

The description is long and dense, but the opening sentence is a clear front-loaded purpose statement. Every section (model families, tradeable-edge knobs, response structure) carries important information given the tool's complexity, though a single wall of text could be improved with paragraph breaks. It earns a solid 4.

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

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

With no output schema, the description fully documents the response top-level (by_segment, fed_candidates/fed_note, _diagnostics) and per-opportunity fields (edge_pp_net, kelly_fraction, market.liquidity, etc.). It also covers edge cases like the Fed signal caveat and caching behavior, making the tool's behavior and output expectations clear.

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 schema already provides rich explanations for all 9 parameters, including nuanced behavior like min_partition_leg_kelly applying to per-leg Kelly. The description summarizes the knobs (e.g., 'TRADEABLE-EDGE KNOBS') but does not add new parameter meaning beyond what the schema already states, so it stays at the baseline.

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

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

The first sentence states a specific verb ('Scan'), resource ('top Polymarket markets'), and outcome ('return opportunities where Pipeworx data disagrees with market price'). It clearly frames the tool for 'what should I bet on today' and distinguishes it from paging through hundreds of markets, separating it from sibling Polymarket 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 clearly indicates when to use the tool ('what should I bet on today') and explains it avoids exhaustive market paging. It also notes exclusions (Fed bets) and provides context on knob usage, but it does not explicitly name alternative tools or give when-not-to-use scenarios, so it lacks the explicit alternative guidance that would earn a 5.

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

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

Beyond the annotations (readOnlyHint=true, idempotentHint=true, destructiveHint=false), the description provides rich behavioral details: snapshot TTL limits, the meaning of gaps in snapshot_dates, the fact that decay is computed from daily closes rather than intraday, and the distinction between tracked and expired opportunities. This significantly exceeds the annotation baseline.

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 long, every sentence serves a purpose: explaining the core question, response structure, and limitations. It is front-loaded with the primary purpose and uses caps and line breaks for readability. No fluff or 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 there is no output schema, the description thoroughly explains the response fields (tracked[], expired[], snapshot_dates[]) and their semantics, along with data limitations. This gives the agent enough context to interpret results correctly and set expectations.

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 both parameters (days, window) are already documented with defaults and allowed values. The description repeats these details and adds minor nuance (e.g., 'snapshot family'), but does not substantially increase understanding beyond the schema.

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

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

The description clearly states the tool's specific purpose: 'Edge persistence and decay telemetry built from daily polymarket_edges snapshots.' It answers a distinct question ('how long has this edge existed and is it shrinking?') and differentiates from the sibling polymarket_edges by emphasizing historical snapshot analysis rather than current edge extraction.

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 for when to use the tool by framing it around persistence and decay questions, noting that a fresh wide edge and a 3-week-old wide edge are different trades. It does not explicitly state when not to use it or name alternative tools, but the differentiation from polymarket_edges is implicit and clear.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so safety is covered. The description adds substantive behavioral detail beyond annotations: it walks the order-book ladder, returns specific metrics (top_of_book, vwap_fill_price, slippage_pp), and warns about partial fills converting an arb into unhedged directional position. This is rich context that complements the annotation-provided safety 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 long (~200 words) but every sentence earns its place, covering two distinct modes, required vs optional parameters, return fields, and risk warnings. It is front-loaded with purpose and then structured around modes, making it scannable. However, it could be split into shorter paragraphs or bullet points for even easier parsing, so it's not perfect on 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?

The tool has no output schema, so the description carries the full burden of explaining return values. It does this thoroughly: listing both single-market and basket outputs, including field names like `capture_ratio`, `thin_legs[]`, and `forced_directional_risk`. It also provides temporal context (when to use) and the failure mode ('partial basket fills convert an arb into an unhedged directional position'). Given the tool's complexity, this is very 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%, so baseline is 3. But the description adds significant meaning beyond the schema: it explains how `size_usd` is interpreted differently in single-market ('max spend on buys, target proceeds on sells') vs basket ('settlement notional S — shares per leg, each paying $1'), and how `side` auto-selects in basket mode. These semantics are not evident from the parameter descriptions 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 opens with a specific verb+resource: 'Realizable-vs-theoretical edge check against live CLOB order-book depth.' It immediately distinguishes itself from sibling tools like polymarket_arbitrage and polymarket_edges by focusing on fill risk and book depth, not signal generation. The two modes (single-market and basket) are clearly named and described.

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

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

Explicit when-to-use guidance is given: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500.' It also explains the rationale ('theoretical overround on thin books is not capturable') and distinguishes between single-market and basket modes, providing clear decision 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?

Beyond the readOnly/openWorld/idempotent annotations, the description discloses response structure (leg-by-leg prices, matched spread), safety fields (compatibility_warning, temporal_alignment, skipped_cross_type counters), and detailed conditions for when spreads are meaningful. This is rich behavioral context that annotations alone do not provide.

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

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

The description is long but well-structured with ALL-CAPS section markers and every sentence conveys a distinct fact. It is front-loaded with the core purpose, then modes, response, and safety fields. While verbose, the density of useful information justifies the length; a slightly tighter edit could earn a 5.

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

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

Despite having no output schema, the description explains the response fields (raw probabilities, matched spread, top_spreads_pp) and safety fields. It also covers parameter modes and caveats. For a complex cross-venue tool with 0 required params and 100% schema coverage, the description is fully self-sufficient.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds significant meaning: explains the 10 pre-mapped topic shortcuts ('fed', 'btc', etc.), how explicit tickers/slugs override topic mapping, and provides concrete examples. This goes beyond the schema's field descriptions by clarifying behavioral semantics.

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

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

The description clearly states the tool's function: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' It names the two resources (Kalshi and Polymarket) and the specific deliverable (spread). It distinguishes itself from sibling tools like 'polymarket_arbitrage' by focusing on cross-venue comparison with explicit safety fields.

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 thoroughly explains when to use the two modes ('topic' pre-mapped shortcuts vs explicit ticker/slug pairing) and provides usage warnings like 'pre-mapped ≠ tradeable' and cases where compatibility_warning fires. It does not explicitly name alternative tools or exclusion criteria, but the context is 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 readOnly, idempotent, and non-destructive behavior. The description adds valuable context beyond annotations by explaining the scoping mechanism (anonymous IP, BYO key hash, or account ID) and the behavior of omitting the key (list all keys). This enriches the agent's understanding of side effects and scope without contradicting annotations.

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

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

The description is three sentences, front-loaded with the primary action. Every sentence earns its place: functionality, use cases, and pairing instructions. No redundancy or 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?

This is a simple tool with one optional parameter and no output schema. The description covers purpose, usage, scoping, and relationships to sibling tools, which is sufficient given the low complexity. Annotations cover safety, so nothing critical is missing.

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

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

The schema already covers the 'key' parameter with 100% description coverage, explaining that omitting it lists all keys. The description reinforces this behavior and adds context about the storage scope, going slightly beyond the schema. This additive value justifies 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 the tool retrieves a previously saved value or lists all saved keys, with a specific verb ('Retrieve') and resource (memory stored via remember). It also distinguishes itself from siblings by explicitly referencing remember and forget, making its role in the memory workflow 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 clear context on when to use this tool ('to look up context the agent stored earlier') and offers examples (ticker, address, research notes). It also mentions pairing with remember and forget, which implies alternatives, but does not explicitly state when not to use it or contrast with search tools.

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

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

Beyond the annotations (readOnly, idempotent), the description discloses key behaviors: return payload structure (source, citation_uri, raw event payload), the mark_read side effect that affects subsequent calls, and the persistent feed nature. 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 front-loaded with the core purpose, then systematically covers return payload, filtering, mark_read, and an alternative access method. Each sentence provides distinct, valuable information without redundancy or fluff.

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

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

With five optional parameters and no output schema, the description covers essential return payload and core filtering, plus an external endpoint for scripts. It does not detail limit/unread_only semantics, but those are in the schema. Overall sufficient 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 describes all five parameters (100% coverage), but the description adds context: an example type ('sec_8k'), clarifies that mark_read flags events so next call shows newer ones, and explains the since parameter with ISO timestamp. This adds meaningful usage nuance 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 a specific verb and resource: 'Pull fired events from your subscription feed.' It also describes what is returned (most recent alerts with source, citation_uri, and raw payload), which distinguishes it from sibling tools like list_subscriptions.

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

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

The description provides clear usage context: it explains filtering by type and since, mentions that polling works fine, and offers an alternative access method (GET registry.pipeworx.io/alerts.json). It does not explicitly contrast with sibling tools, but the guidance is adequate.

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

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

Beyond the readOnly/idempotent annotations, the description discloses the multi-source fan-out, fallback logic, rate-limit behavior, API sunset issue, and output structure (changes[] grouped by source + total_changes + citation URIs). This adds valuable context that annotations alone do not provide.

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

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

The description is dense but efficiently structured: starts with example queries, then sources, then parameter details, then return format, then alternative tool. Every sentence carries useful information without redundancy or fluff.

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

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

Despite lacking an output schema, the description fully explains return values (changes[], total_changes, citation URIs), parameter formats, source fallbacks, and failure modes. It is complete for a complex read-only aggregation tool with no output schema.

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

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

Even with 100% schema coverage, the description enriches all three parameters: `since` examples and relative shorthand guidance, `value` ticker/CIK examples, and `type` restriction to 'company'. It also recommends '30d' or '1m' for typical monitoring, adding practical value beyond the schema.

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

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

The description clearly states the tool provides a 'change feed for a company in the last N days/weeks/months' with specific sources (SEC EDGAR, GDELT→GNews, USPTO). It distinguishes from the sibling entity_profile by explicitly naming when to use that instead, making the purpose unambiguous.

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

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

The description gives concrete example queries ('What's new with X', 'updates on Acme') and explicitly directs users to entity_profile for static profiles. It also explains fallback behavior (GDELT preferred, GNews when rate-limited) and notes the USPTO soft-fail, giving clear context for when to use this tool versus alternatives.

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

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

Annotations already indicate idempotent and non-destructive behavior, but the description adds valuable context: memory is scoped by identifier, authenticated users get persistent memory, and anonymous sessions retain data for 24 hours. This goes beyond the annotations without contradicting them.

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

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

The description is three sentences, front-loaded with the primary purpose, and every sentence adds value: it defines behavior, gives usage examples, and mentions retention and companion tools. No filler or 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 two-parameter write tool with no output schema, the description covers storage semantics, authentication-based persistence, anonymous retention limits, and companion tools. Overwrite behavior is not mentioned but is non-essential for basic usage, so the description is sufficiently complete.

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

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

The schema provides 100% coverage of the two required parameters, including examples for the key and a description for the value. The description reinforces semantics with use-case examples but does not add new parameter format or syntax details, so the baseline 3 is appropriate.

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

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

The description opens with a specific action, 'Save data the agent will need to reuse later,' and clearly identifies the resource as a key-value memory store. It distinguishes itself from siblings by explicitly naming recall and forget as complementary tools, and by emphasizing cross-session persistence.

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

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

It provides explicit usage triggers with examples such as a resolved ticker, target address, or user preference, and directs the agent to pair with recall and forget for retrieval and deletion. However, it does not explicitly state when not to use this tool or contrast it with other storage/retrieval alternatives.

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

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

The annotations already declare the tool read-only, idempotent, open-world, and non-destructive. The description goes far beyond this by disclosing graceful degradation (LEI/FIGI enrichment fails but EDGAR identifiers still return), explicit handling of unresolved identifiers via an 'unresolved' field, source labeling, and internal cascading lookups. 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 longer than average but well-structured: it starts with user-phrasing examples, then states the core purpose, then details supported types. Each section adds value, but the initial list of example phrasings could be trimmed. It is appropriately front-loaded with the main purpose in the second sentence.

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

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

For a tool with no output schema, the description thoroughly covers return behavior: it lists identifiers returned, source provenance, the unresolved field, and graceful degradation. It also explains input formats for each type. This is comprehensive for the tool's complexity and the lack of an output schema.

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

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

The input schema provides 100% coverage with descriptions for both parameters, so the baseline is 3. The description adds richness by explaining what each 'type' value entails (e.g., 'company' returns a cross-source identity spine with specific identifier sources; 'drug' returns RxCUI, ingredient, brand, and a citation). This goes beyond the schema's minimal enum and value 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 resolves a user-spoken NAME to canonical/official identifiers needed by other tools. It uses specific verbs and resources (e.g., 'resolve a user-spoken NAME to the canonical/official identifiers') and distinguishes itself from siblings by positioning it as the preliminary lookup step other tools depend on. The example phrasings reinforce the purpose.

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

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

The description provides an explicit when-to-use directive: 'Use FIRST whenever you have a name but need an ID.' It also notes that it replaces 2-3 manual lookups, implying efficiency gains. However, it does not explicitly name alternative tools or state when not to use it, so it falls short of a 5.

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

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

The description goes beyond the readOnly/idempotent hints by disclosing that it 'Probes each entity with ai_visibility_check, ranks by score, surfaces which is most/least recognized' and returns 'score, confidence, signal density per entity.' This adds orchestration and output behavior not present in annotations. No contradiction detected.

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

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

The description is front-loaded with the core purpose, followed by behavior, use-case, and return details. Each sentence contributes value and the length is appropriate for a 4-parameter tool with no output schema. It is not overly terse or verbose.

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

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

Given the tool orchestrates multiple probes and has no output schema, the description adequately covers what it does, how it works, when to use it, and what it returns. It does not explain edge cases like fewer than two entities or API failures, but the schema already specifies the 2-8 constraint, so this is reasonably complete.

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

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

The input schema already provides 100% coverage with detailed parameter descriptions for models, _apiKey, context, and entities. The description adds only a light conceptual framing (e.g., 'your brand + N competitors') but does not materially improve understanding beyond the schema, so the baseline of 3 is appropriate.

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

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

The description opens with a specific action: 'Compare AI visibility across multiple entities side-by-side.' It clearly distinguishes itself from the sibling ai_visibility_check by focusing on multi-entity comparison and ranking, and from generic compare_entities by framing it as a competitive AI-marketing audit 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?

Provides clear context: 'Useful for competitive AI-marketing audits' and explicitly illustrates the question, 'does Claude know about us as well as our competitors?' It implies a multi-entity scenario but does not explicitly state when to prefer this over ai_visibility_check or compare_entities, nor does it list 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?

The description discloses several behavioral traits beyond annotations: composite fan-out, partial failures degrade gracefully, bundlephobia's first measurement can take 5-30s, and sources_failed lists timeouts. This adds significant value over the readOnlyHint/idempotentHint annotations.

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

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

The description is dense but well-structured, front-loaded with the primary purpose, then usage, then return fields, limitations, and failure behavior. Every sentence adds relevant information 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?

With no output schema, the description fully explains the return summary block fields, per-advisory detail, links, alternative versions, and error handling. It also covers latency and ecosystem scope, making it sufficiently complete for a composite 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 description coverage is 100%: both 'package' and 'version' are already fully documented in the input schema. The description adds no additional parameter-level detail beyond what the schema provides, so it does not raise the baseline.

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

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

The description clearly states the tool's purpose: a composite 'should I add this npm package to my project' check. It names the data sources (deps.dev and bundlephobia) and the specific aspects covered (license, advisories, bundle size, etc.), distinguishing it from sibling tools like scan_competitor_ai_presence.

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

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

Explicit usage guidance is given: 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me".' It also provides an exclusion/alternative for non-NPM ecosystems: 'PyPI / Maven / Cargo / Go fall under deps.dev:version directly'.

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

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

Beyond the readOnly/idempotent annotations, the description reveals important behavior: BGE-base-en embeddings, cosine over 500-char overlapping windows, and a 200K char cap with truncation flag. It also pre-announces output structure (offsets and similarity scores), adding context annotations don't capture.

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

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

Three dense sentences cover purpose, use case, output format, pairing, and algorithm details without redundancy. The structure front-loads the core action ('Semantic search INSIDE a fetched record') and then layers usage and technical behavior.

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

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

For a tool with no output schema, the description adequately covers return values (passages with offsets and scores) and edge cases (truncation flag). It also situates the tool within a broader workflow, making it self-sufficient 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?

Input schema already thoroughly describes all three parameters (text, query, limit) with ranges and examples, so description adds limited new semantic detail. It does reinforce the 'text you already pulled' context, but that's more of a usage hint than additional parameter semantics.

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

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

The description clearly states 'Semantic search INSIDE a fetched record' with concrete examples of text inputs and output ('top-N passages with character offsets and similarity scores'). This distinguishes it from broader search tools like ask_pipeworx by specifying the input is already fetched text.

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

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

It provides explicit when-to-use guidance: 'Use when the record is too big to cram into the prompt' and names the complementary tool ask_pipeworx_grounded with a clear workflow: 'fetch with the gateway, ground over the relevant passages instead of the whole document.' This gives the agent solid decision-making criteria.

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

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

Annotations already declare readOnlyHint and idempotentHint, which the description does not contradict. The description adds valuable context by specifying what metadata is returned, including the date range of EOD price data, and offers an example invocation. This enriches the agent's understanding beyond annotation flags.

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, information-dense sentence followed by a relevant example. It is front-loaded with the primary action and resource, and every word 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?

The tool has a simple purpose with a clear parameter schema and strong annotations. The description covers the core return fields, and the example demonstrates usage. No output schema exists, but the description sufficiently sets expectations for return content. The sibling stock_prices tool doesn't undermine completeness because the metadata vs. prices distinction is obvious.

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

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

The input schema already documents both parameters thoroughly (ticker and optional _apiKey) with 100% coverage. The description adds little beyond the schema, but the inline example clarifies the expected format for the ticker parameter. Per guidelines, baseline 3 is appropriate when schema coverage is high.

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

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

The description clearly states the tool's function: 'Get metadata for a stock ticker' and enumerates the specific metadata fields (company name, description, exchange code, date range). The verb+resource pattern is specific and distinguishes it from the sibling stock_prices tool, which focuses on price data rather than metadata.

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 implicitly conveys when to use this tool: whenever you need metadata for a ticker rather than price data. It provides a concrete example, but does not explicitly contrast with alternatives like stock_prices or mention when not to use it. The guidance is clear enough for typical use.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, which convey the safe, read-only nature. The description adds useful behavioral context: the start_date omission behavior and the list of returned fields. However, it doesn't disclose rate limits, pagination, or error handling. This matches the pattern of a moderately transparent description with good annotation support.

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 exceptionally concise: two sentences plus a compact example. It front-loads the purpose, provides a key behavioral note, and then gives an invocation example. No wasted words or redundant 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?

Despite having no output schema, the description explicitly lists the return fields (open, high, low, close, volume, adjClose) and the default latest-day behavior. With full schema coverage and clear annotations, nothing critical is missing for an agent to invoke this tool correctly.

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

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

The input schema covers all 5 parameters with detailed descriptions (100% coverage). The description's example is helpful but largely duplicates the schema examples, and the start_date omission rule is already present in the schema's parameter description. Thus the description adds marginal meaning beyond the structured schema, landing at the baseline for high schema coverage.

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

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

The description clearly states the function with a specific verb and resource: 'Get EOD historical stock prices for a ticker' and lists the exact data fields (open, high, low, close, volume, adjClose). This distinguishes it from sibling tools like crypto_prices (crypto vs stock) and stock_metadata (metadata vs price history).

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 usage by explaining the behavior when start_date is omitted ('returns just the latest trading day') and includes a concrete example. It does not explicitly name alternatives or when-not-to-use conditions, but the resource scope is obvious enough from the sibling context.

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

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

The description substantially extends the annotations by disclosing account requirements ('Requires a Pipeworx OAuth account'), return value ('Returns the new subscription id'), SMS verification and cap ('phone must be verified at /account first; 10/day cap'), and webhook auto-disabling after 10 consecutive failing runs. It also explains the always-on feed channel. No contradiction with annotations exists; the write operation aligns with readOnlyHint=false.

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

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

The description is dense but every sentence serves a purpose. It is front-loaded with the core action, then prerequisites, then type-specific details, then delivery channels. No unnecessary repetition or filler. The structure is logical and scannable, with examples inline to clarify complex options.

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 (nested objects, multiple types, delivery channels, account requirements, and return value), the description is remarkably complete. It covers prerequisites, return value, all supported types with examples, channel behavior, verification steps, rate limits, and webhook security. The absence of an output schema is mitigated by explicitly stating the returned subscription ID. It is sufficient for an agent to invoke the tool correctly without further documentation.

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 provides full descriptive coverage (100%), so the baseline is 3. However, the description adds significant semantic value by giving concrete examples for each subscription type (e.g., items:["5.02"] = officer change, topic:"fed", series_id:"UNRATE") and explaining delivery options in depth, including the webhook HMAC signing and verification requirements. This greatly exceeds the schema's built-in descriptions.

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

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

The description clearly states the tool's function with a specific verb and resource: 'Create a proactive monitoring subscription to a live-data event stream.' It also lists supported subscription types with examples, which distinguishes it from siblings like list_subscriptions, unsubscribe, and recent_alerts. The purpose is unambiguous and differentiated.

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

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

The description gives clear context for when to use the tool, including the OAuth account prerequisite and the always-on feed vs optional email/SMS/webhook. It does not explicitly name alternatives or when-not-to-use conditions, but it implies that this is the creation tool while siblings handle listing, unsubscribing, and reading alerts. The absence of explicit 'use instead of X' language prevents a 5.

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

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

Annotations already signal safe read-only, open-world, idempotent behavior. The description adds substantial context: it draws from the live catalog of thousands of tools and returns category-bucketed example questions with exact tool+argument shape, plus the option to focus by topic. This goes well beyond the annotations.

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

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

The description is longer but every sentence contributes: example queries, output contents, parameter behavior, and usage guidance. It is front-loaded with natural-language examples and avoids redundancy with schema fields.

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

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

For a tool with no output schema and one optional parameter, the description fully covers what it returns, how to invoke it, and when to use it, including naming related meta-tools. Nothing essential is missing.

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

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

The schema already documents 'topic' with 100% coverage, establishing a baseline of 3. The description adds semantic richness by listing example values ('finance', 'pharma', 'betting') and explaining that omitting it gives a cross-category spread, which helps choose appropriate inputs.

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 the onboarding entry point for learning what Pipeworx offers, returning category-bucketed example questions with exact tool and argument shapes. It uses a specific verb (returns) and resource (example questions from live catalog), and distinguishes itself from siblings by being the 'FIRST' tool to use when unfamiliar.

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 instructs to '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 focus with a topic parameter and when to call with no arguments. This provides clear when-to-use guidance relative to alternatives.

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

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

The description explains important behavioral details beyond the annotations: ownership enforcement and that the row is deactivated rather than deleted, preserving historical events via recent_alerts. This aligns with destructiveHint=false and adds meaningful context.

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

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

The description is two sentences, front-loaded with the core action, and every sentence adds value. It is concise and well-structured.

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

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

For a simple single-parameter mutation tool with useful annotations, the description fully covers the effect (deactivation), ownership restrictions, and downstream impact on recent_alerts. No output schema is needed, and the description is complete.

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

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

The input schema already fully describes the 'id' parameter as a subscription uuid returned by subscribe (100% coverage). The description merely reiterates 'by id' without adding new semantic details, so it meets the baseline for schema coverage.

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

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

The description clearly states the tool's action: 'Cancel a subscription by id.' It uses a specific verb and resource, and distinguishes it from siblings like 'subscribe' and 'list_subscriptions' by emphasizing cancellation and ownership.

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

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

The description implies when to use the tool (when you want to cancel a subscription) and includes a clear usage constraint ('you can only cancel your own subscriptions'). It does not explicitly name alternatives, but the context of sibling tools makes the intended use obvious.

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

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

Discloses far beyond annotations: explains the two source-routing paths, the verdict taxonomy, and the crucial semantic distinction between could_not_verify (check did not happen) and unsupported (no source exists). The warning that could_not_verify 'must not be shown as evidence' is a valuable behavioral guardrail that annotations do not cover. No contradiction with readOnly/idempotent hints.

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

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

The description is front-loaded with purpose and usage, followed by technical routing details and a critical warning. It is long (~200 words) but each sentence contributes meaningful information, including example phrases and the could_not_verify caveat. Could be trimmed slightly (e.g., 'Replaces 4–6 sequential calls'), but overall well-structured for the complexity.

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

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

Despite lacking an output schema, the description fully covers return values: verdict list, actual value with citation, and reasoning. It also explains error/edge states (could_not_verify vs unsupported) and the routing logic. For a tool of this complexity (two paths, multiple verdicts), the description is complete and leaves no critical gaps.

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

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

Schema coverage is 100%, and the schema already documents both parameters with examples and defaults (claim, tolerance_pct). The description adds contextual detail like 'exact percent-delta math' for financial claims, but this does not materially enhance parameter understanding beyond the schema. Baseline of 3 is appropriate.

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

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

The description is explicit: 'natural-language claim verification against authoritative sources' with concrete example phrases. It clearly distinguishes itself from siblings by returning a verdict and replacing 4–6 sequential calls, positioning it as a specialized fact-checking tool rather than a generic Q&A. The verb 'validate' and resource 'claim' are specific and unambiguous.

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

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

It explicitly states when to use: 'Use whenever the agent needs to check whether something a user said is factually correct.' It also describes two routing paths (SEC EDGAR for company-financial, grounded pipeline for everything else), which implies broad applicability. However, it does not name alternative tools or provide explicit exclusions, though the 'replaces 4–6 sequential calls' phrasing suggests it is the preferred one-stop fact-check tool.

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