Weatherapi

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

Annotations already indicate readOnlyHint, openWorldHint, and idempotentHint. The description adds behavioral details: default model is free, BYO key for Anthropic (cost implications), and return structure. It does not contradict annotations.

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

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

The description is concise, consisting of three sentences that efficiently convey the tool's purpose, default behavior, and return values. It is front-loaded with the main action.

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

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

The description covers input (entity, models, optional fields), output (per-model object with score, confidence, signals, raw_response, combined view), and use cases. No output schema exists, so the description adequately explains return values.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining the default model and the optional API key for Anthropic, which is beyond the schema descriptions. It also clarifies the purpose of the context 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 provides a specific verb-resource combination: 'Probe one or more LLMs' and 'score visibility'. It clearly states the tool's function and distinguishes it from siblings by mentioning use cases like AI-marketing audits and brand checks, which are not covered by other 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 gives explicit use contexts: 'AI-marketing audits, pre-launch brand checks, competitive monitoring.' However, it does not specify when not to use the tool or mention alternative tools for similar tasks, though the sibling list provides potential alternatives.

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

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

Annotations already declare read-only, open-world, idempotent, and non-destructive behavior, and the description adds useful behavior beyond that: routing to one of many tools, filling arguments, returning stable citation URIs, and being a single fast call that works on every tier. It does not describe failure modes or exact response structure, but the added context is strong given the annotation coverage.

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: it front-loads the most important instruction ('PREFER OVER WEB SEARCH'), then moves through behavior, usage triggers, examples, and alternative tools. The source list and examples take space, but for a broad default entry point they earn their place by disambiguating a very wide 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 broad tool with one real parameter, no output schema, and many siblings, the description covers what it does, when to use it, when to choose alternatives, and what kind of answer to expect ('structured answer with stable pipeworx:// citation URIs'). It could be more explicit about uncertainty or failure behavior, but an agent has enough context to select and invoke it correctly.

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

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

Schema coverage is 100%, so the parameter itself is already documented as a natural-language question with aliases. The description adds semantic meaning by giving specific question categories and concrete examples such as 'current US unemployment rate', 'Apple's latest 10-K', and '5-day forecast for Tokyo', which directly help an agent form valid input values.

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

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

The description states a clear purpose: route a natural-language question to the right one of 5,706 verified-source tools, fill arguments, and return structured answers with stable pipeworx:// citation URIs. It explicitly distinguishes itself from web search and from siblings such as ask_pipeworx_grounded and deep_research, making its role immediately identifiable.

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

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

The description explicitly says to 'PREFER OVER WEB SEARCH' for factual, current, or historical data, and lists concrete trigger phrases like 'what is', 'look up', 'find', 'get the latest', 'how much', and 'current'. It also gives when-not-to-use guidance by naming ask_pipeworx_grounded for verbatim evidence plus confidence and deep_research for broad multi-part questions.

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

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

Beyond annotations (read-only, idempotent, open-world), the description adds important behavioral context: no candidate is currently active, therefore it currently matches ask_pipeworx exactly, and it explicitly states 'falls back to nothing'—it is a full working router, not a wrapper that might fail. This preempts misconceptions about beta status.

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 front-load the identity, differentiation, and usage rule before adding the current-state and fallback details. Every sentence earns its place; the transient candidate-state note is directly relevant to how the tool behaves right now.

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 router-style tool with no output schema, the description covers purpose, usage condition, current experimental state, and fallback behavior, and it promises the same response shape as ask_pipeworx. It is complete enough for invocation, though the actual response format is only reachable indirectly through the stable sibling's definition.

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 all six parameters with 100% description coverage, including the alias relationships and the natural-language question semantics, so the baseline of 3 applies. The description merely repeats 'same arguments' and contributes no new parameter-level meaning.

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 frames the tool as a beta version of ask_pipeworx and explicitly calls it a full working universal router over 5,706 tools with identical arguments and response shape. It differentiates from the stable sibling by its experimental routing edge, though it relies on knowing what ask_pipeworx does to fully pin down the exact action.

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 a concrete selection rule: use it exactly like ask_pipeworx when you want the newest routing, and notes results are compared against the stable router. It stops short of stating explicit when-not cases or covering the grounded sibling, so the alternative-routing guidance is good but not exhaustive.

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 well beyond annotations by explaining the extraction-only behavior, success response shape, refusal reasons, and cost tradeoff. It is consistent with readOnly/openWorld/idempotent annotations and adds substantial behavioral detail.

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 densely informative but every sentence earns its place: purpose, mechanism, return contract, refusal contract, use cases, and cost comparison. It is front-loaded with the core thesis and structured clearly.

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

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

With no output schema, the description fully covers return values and refusal semantics. It also provides routing context, cost implications, and usage scenarios, making it complete for an agent to decide 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?

Schema description coverage is 100%, with all six parameters documented as aliases for the natural-language question. The description adds no extra parameter-level meaning, 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 a specific purpose: a hallucination-resistant answer mode that routes like ask_pipeworx but extracts answers only from tool results. It distinguishes itself from the sibling ask_pipeworx by grounding behavior and refusal mechanics.

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

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

Explicitly states when to use: when answers will be quoted, cited, or acted on and facts must not be invented. It also gives a clear alternative and exclusion: prefer ask_pipeworx for casual lookups because this costs an extra LLM call.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds useful behavioral context by enumerating the specific data fields returned and including an example invocation. This goes beyond what annotations alone convey, though it does not address rate limits or error behavior.

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

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

The description is two sentences: one functional summary and one example. It is front-loaded with the key purpose and wastes no words. Every sentence earns its place.

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

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

For a simple lookup tool with three parameters, good annotations, and no output schema, the description is complete enough. It tells the user exactly what data will be returned and gives a usable example. Minor gaps like default date behavior are already covered by the schema, not the description.

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 includes a usage example showing q and dt, which reinforces the schema. However, the schema already thoroughly explains all three parameters, including the nuanced IATA code note for q. The description does not add meaning beyond the schema.

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

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

The description uses a specific verb ('Get') and clearly identifies the resource ('astronomy data') along with the key output fields (sunrise, sunset, moonrise, moonset, moon phase, moon illumination). This distinguishes it from sibling tools like current, forecast, and marine, which cover other weather domains.

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

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

The description states exactly when to use the tool: to retrieve astronomy data for a given location and date. It provides a concrete example with parameters, making the context clear. It does not explicitly mention when not to use it or name alternative tools, but the purpose is distinct enough that no exclusions are needed.

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 indicate readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. Beyond these, the description adds rich behavioral context: low-confidence resolutions short-circuit with status 'low_confidence_match', closed markets return 'market_closed_or_inactive', wide spreads get tradeability note, cancellation rules are parsed, and fallback mechanisms for news fields are explained. 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 well-structured with clear sections (CLASSIFIERS, FAN-OUT EXAMPLES, RESPONSE SHAPES, etc.) and front-loads the main purpose. However, it is very long (over 1000 words). While the detail is valuable, a more concise version could improve clarity without sacrificing essential information.

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

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

Given the tool's complexity (3 parameters, no output schema), the description is exceptionally complete. It covers response shapes (market, analysis, evidence), resolver contract (confidence, alternatives, suggestions), parent event extraction, news field fallbacks, safety behaviors, and resolution-rule risk. Every aspect is addressed thoroughly.

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

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

The schema coverage is 100%, but the description adds significant meaning: it explains the 'market' parameter accepts slug, URL, or question text with examples; 'depth' describes quick vs thorough behavior; 'include_raw' explains the trade-off between summary size and full payloads for post-processing. This adds valuable context beyond the schema definitions.

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

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

The description clearly states the tool's purpose: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies the verb (Research) and resource (Polymarket bet with Pipeworx data), and distinguishes from sibling tools like polymarket_arbitrage by detailing its unique functionality (resolving markets, classifying, fanning out to data packs).

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

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

The description explicitly provides use cases: 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z".' It also offers guidance on inspecting the resolver contract (market_match_confidence) before trusting analysis, and explains when to consult alternative tools (e.g., low-confidence matches short-circuit). This is comprehensive usage guidance.

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

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

Annotations already show readOnlyHint, openWorldHint, idempotentHint. The description adds specific data sources (SEC EDGAR/XBRL, FAERS), explains handling of off-calendar fiscal years, sorting by primary metric, and return format (paired data + citation URIs). No contradictions with annotations.

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

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

The description is a single dense paragraph but every sentence adds value. It could be slightly more structured with bullet points for clarity, but it is not overly long. Minor deduction for lack of visual structure.

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

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

Given the complexity of a comparison tool with two entity types, multiple data sources, and sorting, the description covers what the tool does, how it works, and what to expect. It explains return format despite no output schema. Complete enough for an agent to use correctly.

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

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

Schema coverage is 100% (both parameters described), baseline 3. The description adds significant value by explaining each enum value ('company' pulls 10-K data, 'drug' pulls FAERS counts) and providing concrete examples for the values array (tickers/CIKs for companies, drug names). This goes far 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 performs side-by-side comparison of 2-5 companies or drugs. It differentiates from siblings by explicitly preferring over sequential single-pack lookups and claims to replace 8-15 lookups. Natural language triggers like 'compare X and Y' make the purpose unmistakable.

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

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

Provides explicit when-to-use guidance ('ALWAYS PREFER over sequential single-pack lookups'), natural language triggers, and details on what each entity type returns (SEC data for companies, FAERS data for drugs). It contrasts with the sibling entity_profile tool by emphasizing parallel vs. sequential calls.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe, read-only operation. The description adds the real-time scope and return-field list, but it does not disclose behaviors like API key requirements, response format, or data source beyond the schema's param note about IATA/ICAO.

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

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

The description is three sentences, front-loaded with the core purpose and inputs, and includes a concrete example. There is no redundant or filler 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?

With no output schema, the description lists the returned data fields, which is helpful for an agent to know what it will receive. Combined with robust schema coverage and safety annotations, the description is adequate for selecting and calling the tool, though units and response structure are not specified.

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 detailed parameter docs and an example already present. The description adds a condensed summary of location formats and a call example, but this is marginal beyond the schema's structured 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 uses a specific verb/resource ('Get current/real-time weather') and enumerates the data fields (temperature, condition, humidity, wind, UV, AQI), making it clear what the tool does. The 'current/real-time' qualifier distinguishes it from sibling tools like forecast or astronomy.

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 states this is for current/real-time weather and provides supported location formats plus an example. It implicitly conveys when to use it versus forecast tools, but it does not explicitly name alternatives or state exclusions, so it falls just short of a top score.

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

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

Beyond the annotations, the description discloses auth requirements and paid-tier constraints, parallel decomposition into 5,706 tools, the findings-packet shape, gaps[] and contradictions[] behavior, semantic excerpting, citation_uri resolvability, and expected latency. No contradiction with the readOnly/idempotent/openWorld annotations is present.

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

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

The description is dense and front-loaded with the highest-value decision facts: account requirement, not-open-web scope, and the ask_pipeworx alternatives. It is long but each section supplies information relevant to correct selection and invocation; only minor repetition keeps it from 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?

With no output schema, the description carries the full burden of explaining return values, and it does so thoroughly: findings packet composition, gaps[], contradictions[], hop field, citation_uri behavior, latency, auth, and scope limitations. Nothing critical for calling the tool correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful guidance by clarifying that broad/multi-part question wording is fine and by explaining what each depth value does in workflow terms — gap recovery for 'standard' and additional lead-chasing for 'thorough'.

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

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

The description names a specific verb (researches), a bounded resource (1493 structured data sources across SEC, FRED, FDA, USPTO, etc.), and explicitly contrasts itself with open-web search and ask_pipeworx. An agent can distinguish deep_research from its sibling tools without opening any schema.

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

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

The description explicitly says when to use it ('best for broad/multi-part questions over structured data'), when not to ('For a single lookup use ask_pipeworx'), and which sibling to prefer for breaking/current-news topics. It even provides an account-gated fallback, making selection guidance unusually complete.

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

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

The description adds significant value beyond annotations: it reveals that the tool returns 'top-N most relevant tools with names, descriptions, and full input schemas (with curated examples)' and that each result is 'ready to call directly, no second schema lookup needed.' Annotations already mark it read-only and idempotent, and the description aligns with those while adding behavioral details.

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 moderately concise and front-loaded with purpose and usage. It contains two substantial sentences covering key points without fluff. Slightly verbose due to listing examples, but overall efficient.

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

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

Given the tool's complexity (6 parameters, no output schema), the description adequately explains the return value (top-N tools with schemas and examples). It does not detail every output field, but the output is self-explanatory. The description provides enough context for an agent to understand what to expect.

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

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

Schema description coverage is 100%, so baseline is 3. The description mentions query aliases but the schema already documents them. No additional semantic meaning beyond what the schema provides for parameters. The description focuses on overall behavior rather than parameter-specific guidance.

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 specifies the verb 'find' and the resource 'tools', and effectively distinguishes from sibling tools by explaining it is for browsing/discovering available tools, not for a specific domain like stocks or news.

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 advises when to use: 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' It also lists examples of tasks (SEC filings, FDA drugs, etc.) where discovery is appropriate, providing clear usage context without needing exclusions.

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

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

Annotations already indicate read-only, idempotent, non-destructive. The description deepens transparency by detailing data sources, return fields, parallel fan-out, and known limitations (patent soft-fail, name restriction). 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 examples and key directives. While dense, every sentence provides value (sources, return fields, limitations). Could be slightly shortened without loss of clarity.

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

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

For a complex profile tool with no output schema, the description covers main return fields (cik, filings, fundamentals, etc.) and parallel execution. Lacks details on error handling or pagination, but is sufficient for typical use.

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

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

Input schema provides 100% coverage with descriptions for both parameters. The description adds crucial context: value can be ticker or CIK, names not supported (requires resolve_entity). This extends beyond schema detail, though not fully comprehensive for edge cases.

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

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

The description clearly defines the tool as a full cross-source profile for US public companies with specific examples (e.g., 'Tell me about X', 'research Acme'). It distinguishes itself from sibling tools like resolve_entity and chaining single-pack lookups, providing clear purpose and 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?

Explicit guidance: 'ALWAYS PREFER over chaining single-pack...when the user asks for a holistic view.' Also advises to use resolve_entity first if only a name is available. Mentions patents may soft-fail after May 2025, setting expectations.

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, non-destructive), the description adds what data is returned and the 10-day limit. It does not mention rate limits or API key nuances, but the key behavioral context is present. No contradiction with annotations.

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

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

Two concise sentences, front-loaded with purpose, followed by a relevant example. Every word earns its place; 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?

With no output schema, the description appropriately lists return fields (high/low, condition, rain chance, precipitation, sunrise/sunset) and the 10-day maximum. Combined with rich schema and annotations, the tool is fully understandable for a read-only forecast operation.

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

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

Schema coverage is 100%, with detailed descriptions for all three parameters. The main description adds no extra parameter semantics beyond the example call, which merely mirrors the schema example. Baseline 3 is appropriate since 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 'Get a multi-day weather forecast for a location' and lists specific data (daily high/low, condition, chance of rain, precipitation, sunrise/sunset). This distinguishes it from sibling tools like 'current' or 'astronomy' by focusing on multi-day forecast details.

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

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

The description implies usage for multi-day forecasts via the example and the word 'multi-day', but it does not explicitly contrast with sibling tools (e.g., 'for current conditions use current') or state exclusions. No when-not-to-use guidance is given.

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's mention of 'delete' and 'clear' reinforces but doesn't add major new behavioral info. The description adds some safety context ('sensitive data'), but overall the behavioral profile is well-covered by annotations.

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

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

The description is two sentences, front-loaded with the core action, and contains no extraneous words. Every sentence serves a purpose: stating the action, providing usage guidance, and linking to sibling tools.

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 delete tool with one parameter, no output schema, and clear annotations, the description is complete. It explains when to use, what the parameter is, and how it relates to other tools, leaving no gaps.

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

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

Schema coverage is 100%, so the schema already describes the parameter 'key' as 'Memory key to delete'. The description adds no additional semantic meaning beyond what's in the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool deletes a previously stored memory by key. It distinguishes itself from sibling tools 'remember' (store) and 'recall' (retrieve), making the purpose unambiguous.

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

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

The description explicitly states when to use: when context is stale, task is done, or to clear sensitive data. It also mentions pairing with 'remember' and 'recall', providing clear context and alternatives.

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

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

Description adds detail beyond annotations: 'Fetches the page, extracts title/description/key links, emits standard llms.txt markdown format' and 'Output is a single text blob ready to drop at site-root/llms.txt'. No contradiction with annotations (readOnlyHint, destructiveHint 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?

Four sentences, no waste. First sentence states purpose, second explains process, third gives output format, fourth lists use cases. Front-loaded with key information.

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

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

Given simple tool with 2 params, good annotations, and no output schema, description fully covers purpose, behavior, output, and use cases. No gaps.

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

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

Schema covers 100% of parameters. Description adds value by specifying default (25) and max (50) for max_links, and explains output includes key links, supplementing schema.

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

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

The description states clear action ('Generate a production-ready llms.txt file for any URL') and resource (llms.txt for a URL). It distinguishes from diverse sibling tools by focusing on a specific output format and use case.

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

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

Description explicitly lists use cases (getting a client's site indexed, drafting for own project, auditing competitors). However, it doesn't mention when not to use or alternative tools, though no direct siblings exist.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. Description adds details about return fields and optional inclusion of inactive subscriptions. No contradictions.

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

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

Two sentences, no fluff. Front-loaded with purpose and returns.

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?

Complete for a simple list tool with one optional parameter. Covers purpose, return fields, and usage context.

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

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

Schema coverage is 100% for the single parameter. Description does not add to parameter semantics but lists return fields, compensating for the absent output schema.

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

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

Description clearly states it lists the caller's active subscriptions and specifies return fields (id, type, params, etc.). Distinguishes from sibling tools like subscribe and unsubscribe.

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

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

Explicitly tells when to use: 'review what you're monitoring before adding more or to find an id to cancel.' No ambiguity with 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 mark the tool read-only, idempotent, and non-destructive; the description adds behavioral details such as a 7-day forecast horizon, 6-hour sampling interval, and the specific data fields returned, which usefully extends the annotation-only picture.

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

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

The description is two sentences plus a compact example, front-loading the purpose and providing a concrete usage illustration with zero 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?

Given the absence of an output schema, the description compensates by listing the marine data fields (wave height, swell, water temp, wind), the forecast window, and a code example, making it reasonably complete for a read-only forecast 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 for parameters is 100% with detailed descriptions, and the description only reinforces the example call and the 7-day limit without introducing new parameter semantics, so a 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 verb phrase 'Get marine/ocean conditions forecast for a coastal location' and enumerates the key fields (wave height, swell, water temperature, wind), clearly differentiating it from the general weather 'forecast' sibling by focusing on marine conditions.

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 sets the context as a marine/ocean forecast for coastal locations, which implies when to use it, but it does not explicitly state exclusions or name alternative tools for non-marine queries, so it falls short of full usage guidance.

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

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

While annotations are all false and uninformative, the description discloses key behavioral traits: the claim_token round-trip ('Filing without an account returns a claim_token; pass it back later... to read whether it was fixed and what changed'), rate limiting ('Rate-limited to 5 per identifier per day'), quota impact ('Free; doesn't count against your tool-call quota'), and roadmap influence. It also warns not to paste end-user prompts, adding practical behavioral nuance.

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 (~150 words) but every sentence earns its place: purpose, use cases, exclusions, claim_token mechanics, rate limits, and quota impact. It is front-loaded with the core purpose, making the key information immediately accessible. Slightly verbose but appropriately information-dense.

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 and all annotations false, the description carries the full burden of explaining behavior. It covers when to use, when not to use, how to handle follow-up (claim_token), rate limits, quota implications, and message quality guidance. The return-value behavior is explained via the claim_token mechanism, making the tool fully self-contained in its description.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining the claim_token flow ('Filing without an account returns a claim_token; pass it back later as pipeworx_feedback({claim_token:"pwfb_…"})') and providing message guidance ('Describe the issue in terms of Pipeworx tools/packs — don't paste the end-user's prompt'). This pushes it above baseline.

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

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

The description opens with 'Tell the Pipeworx team something is broken, missing, or needs to exist,' which provides a specific action (telling/sending feedback) and a clear resource (the Pipeworx team). It distinguishes itself from sibling tools by explicitly scoping to Pipeworx-served tools and excluding tools from other MCP servers.

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 the tool ('when a tool returns wrong/stale data (bug), when a tool you wish existed isn't in the catalog (feature/data_gap), or when something worked surprisingly well (praise)') and when not to use it ('if the tool came from a different MCP server ... file it with that server instead'). It also gives a fallback heuristic ('Not sure? Pipeworx tool names are the ones this connection lists').

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

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

Annotations already mark the tool as read-only, idempotent, and non-destructive. The description adds valuable context: data source (CF analytics-engine), no PII, caching behavior (5min-1h), and self-aggregating nature. 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 a single paragraph but well-structured with a clear lead sentence, bullet-like use cases, and technical details. It could be slightly more concise (e.g., list use cases as a bullet list), but remains efficient and front-loaded.

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

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

Given the tool has one parameter, no output schema, and rich annotations, the description covers core purpose, window behavior, caching, and privacy. It lacks explicit details on the return format (structure of 'top tools' and 'top packs'), which would make it fully complete.

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

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

Schema coverage is 100% with a single enumerated parameter 'window'. The description elaborates on the semantic difference between shorter and longer windows ('hot right now' vs 'steady-state'), adding meaning beyond the schema's enum values.

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

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

The description clearly states the tool returns 'top tools, top packs, and total call volume' over a selected window. It uses specific verbs and resources, distinguishing it from siblings like 'ask_pipeworx' or 'discover_tools' by focusing on trending data.

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

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

The description explicitly lists three use cases (discovering hot data sources, confirming canonical tools, checking use case alignment). It implies when to use (hot trends) but does not explicitly state when not to use it, which could improve differentiation from similar 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 declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive. Description adds significant behavioral context: monotonicity checks, partition checks, fill checks against CLOB depth, semantic anchor, placeholder filters, and response structure. No contradictions with annotations.

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

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

The description is well-structured and front-loaded, but slightly verbose due to detailed technical explanations. Every sentence adds value, but some redundancy could be trimmed for even higher 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?

Despite no output schema, the description fully explains the response structure (opportunities array, partition_check, fill_check), covers all modes, edge cases (placeholder filtering, low similarity pairs), and provides trading safety advice. Comprehensive 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% with descriptions for both parameters. The description adds extra meaning: explains recommended usage for event vs topic, provides concrete examples of valid values, and outlines the logic behind each mode.

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

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

The description clearly states the tool finds arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It distinguishes three modes (no args, event, topic) and contrasts with sibling tools like polymarket_fill_risk.

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

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

Explicit guidance on when to use each mode: no args for trending scan, event for specific market, topic for cross-event scanning. Includes when not to trade (when realizable_edge_pp ≤ 0) and recommends polymarket_fill_risk for custom sizing.

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

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

Description extensively documents behavior: caching at KV level for 1h keyed on knobs, three model families with specific logic, diagnostic output for empty segments, and tradeable-edge filters. Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint, and description adds rich context without contradiction.

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

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

Description is quite lengthy, covering extensive details in dense paragraphs. It is structured with segments, but could be more concise by condensing some technical explanations. While informative, it burdens the agent with reading time.

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 with 9 parameters and no output schema, the description is highly complete. It explains top-level response structure, edge metrics, diagnostics, caching, and knobs in detail, leaving little ambiguity 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% with detailed parameter descriptions. Description adds extra context for several parameters (e.g., explains why min_kelly doesn't filter partitions for min_partition_leg_kelly, mentions zero trading fees but practical slippage for slippage_pp). Not all parameters gain additional meaning, but the added value justifies above baseline 3.

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

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

Description clearly states the tool scans Polymarket markets for opportunities where Pipeworx disagrees with market price, targeting 'what should I bet on today'. It distinguishes itself from siblings like polymarket_arbitrage by specifying the Pipeworx data source and unique model families.

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

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

Provides explicit guidance on when to use ('what should I bet on today') and details on customizable knobs like min_liquidity and max_spread_pp. Lacks direct comparison to all siblings, but context signals list related tools, and description implies use for discovering opportunities rather than executing trades.

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

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

Annotations (readOnlyHint, idempotentHint) are consistent. The description adds behavioral details: data source (daily snapshots), response structure (tracked, expired, snapshot_dates), and limitations (60-day TTL, daily closes). This provides useful context beyond the annotations.

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

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

The description is detailed but well-structured, with the core purpose front-loaded. It includes a clear response section and limitations. However, it is somewhat long and could be slightly more concise without losing information.

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

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

Given the absence of an output schema, the description fully explains the return values (tracked[], expired[], snapshot_dates[]) and their meanings. It also covers limitations and defaults. This provides a complete understanding of the tool's behavior.

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

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

Schema coverage is 100%, so baseline is 3. The description reiterates defaults and constraints (e.g., 'days (lookback, default 14, max 30)') but does not add new semantics beyond the schema. It explains how parameters affect the output, but that is expected.

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

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

The description clearly states the tool's purpose: providing edge persistence and decay telemetry from daily snapshots. It answers a specific question about how long an edge has existed and whether it is shrinking. It distinguishes itself from sibling tools like polymarket_edges by focusing on time-series tracking rather than current edges.

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

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

The description explicitly states when to use the tool: to understand if an edge is fresh or decaying. It implicitly contrasts with current snapshots by emphasizing historical trends. Although it does not name alternative tools, the niche is clear.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds detailed behavioral context: it walks the order-book ladder, returns specific metrics (top_of_book, vwap_fill_price, slippage_pp, verdict), and warns about forced directional risk from partial fills. 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 comprehensive and well-structured with clear sections marked by bold headings. It is longer than average, but every sentence adds value given the tool's complexity. Minor redundancy in listing return fields could be tightened, but overall it is efficiently packed with essential 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 lacking an output schema, the description thoroughly documents return fields for both modes, including edge cases like thin_legs and forced_directional_risk. It covers parameter ranges (size_usd clamp 10–1,000,000) and explains the risk profile. The tool's complexity is fully addressed, leaving no critical gaps.

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

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

Schema description coverage is 100%. The description adds meaning beyond schema by explaining the interplay between 'market' and 'event' modes, the default auto behavior for basket side, and how size_usd is interpreted differently for single-market vs basket. This enriches the agent's understanding beyond 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 clearly states it performs a 'Realizable-vs-theoretical edge check against live CLOB order-book depth' and distinguishes two modes: single-market and basket. It explicitly names sibling tools (polymarket_arbitrage, polymarket_edges) and explains when to use this tool, providing a specific verb-resource pairing.

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 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500' and explains the risk of partial basket fills converting an arb into an unhedged directional position. It provides clear when-to-use and when-not-to-use guidance with alternatives named.

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

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

Annotations only declare read-only/idempotent behavior, but the description adds deep behavioral detail: compatibility codes, skipped unclassified legs, low-confidence pairs, temporal alignment checks, and counters for dropped comparisons. This far exceeds what the annotations convey.

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

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

The description is long, but it is organized into modes, response shape, safety fields, and interpretation caveats. Each sentence adds meaningful guidance for a complex tool with no output schema, though the compatibility code list could be tightened slightly.

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 documents the response shape, safety fields, spread semantics, skipped counters, and temporal alignment. It also tells the agent to read compatibility fields even when matched_pairs is greater than zero, leaving little ambiguity about how to interpret results.

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

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

The schema already covers all three parameters at 100%, and the description reinforces their meaning by defining topic mode vs explicit ticker/slug mode and explaining override behavior. It adds worthwhile caveats about pre-mapped topics that the schema alone does not provide.

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

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

The opening sentence names the exact resource (cross-venue spread between Kalshi and Polymarket for the same resolving question) and the behavior clearly. The TWO MODES explanation further disambiguates it from sibling tools like polymarket_arbitrage by focusing on matched same-question comparisons.

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 topic mode and explicit pairing mode are appropriate, and it warns that pre-mapped topics often return compatibility warnings and are not necessarily tradeable. It does not explicitly name sibling alternatives, but the context it gives for using this tool is strong.

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

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

Annotations already indicate read-only, idempotent, non-destructive. Description adds scoping to identifier and pairing info, but no new behavioral traits beyond that.

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

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

Four sentences, each informative and no redundancy. Front-loaded with core action, then use cases and relationships. Highly concise.

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

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

Complete for a simple read tool with one parameter. Covers purpose, usage, scope, and sibling relationships. Output schema not needed.

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

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

Schema coverage is 100% but description adds meaning: explains key type, omission behavior, and gives examples (ticker, address). Adds significant value beyond schema.

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

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

The description clearly states it retrieves saved values or lists all keys, distinguishing from siblings like remember and forget. It uses specific verbs and resources.

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 (look up context) and pairs with remember/forget. Explains behavior when key is omitted and scoping to identifier.

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

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

Annotations already indicate readOnly, idempotent, non-destructive. The description adds that mark_read flags events as read, affecting future calls, and mentions the feed is persisted. No contradictions with annotations.

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

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

Four to five sentences, each adding unique information. Front-loaded with purpose, then details. No redundant or unnecessary text.

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 5 optional parameters and no output schema, the description covers what the tool returns, filtering options, state management, and alternative access. No gaps.

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

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

Schema covers 100% of parameters with descriptions. The description adds context like filtering by type example ('sec_8k'), ISO timestamp interpretation, and mark_read side effects, providing 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 pulls fired events from a subscription feed, specifies return fields (source, citation_uri, etc.), and distinguishes it from the alternative GET endpoint. No sibling tool duplicates this functionality.

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

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

Explicitly says polling works fine, provides filter examples (type, since), explains mark_read behavior, and points to an alternative access method (GET endpoint) for scripts/dashboards.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and non-destructive. The description adds significant behavioral detail: parallel fan-out to multiple sources, fallback from GDELT to GNews on rate limits/5xx, USPTO soft-failure until reactivated, and structured return format with citation URIs. 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 efficiently structured: common query examples front-loaded, followed by data sources, parameter details, and return format. No redundant sentences. Every sentence contributes meaningful 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 no output schema, the description fully explains the return structure (changes grouped by source, total_changes count, citation URIs). It covers fallback mechanisms and limitations. For a tool with 3 required parameters and multiple data sources, this is complete and self-contained.

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

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

The input schema has 100% description coverage, but the description adds substantial value: explains that 'since' accepts both ISO dates and relative shorthand with examples, recommends '30d' for typical monitoring, and clarifies that 'value' can be ticker or CIK. This goes beyond the schema definitions.

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

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

The description clearly states it provides a change feed for a company, listing specific data sources (SEC EDGAR, GDELT/GNews, USPTO). It explicitly distinguishes from sibling tool entity_profile, which is used for static profiles. The purpose is unambiguous and well-defined.

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

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

The description provides explicit when-to-use guidance with common query examples ("What's new with X", "latest on Y"). It directly advises using entity_profile instead for static profiles, and explains fallback behavior between GDELT and GNews. This offers clear context for appropriate tool selection.

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

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

Annotations indicate idempotentHint=true and readOnlyHint=false. The description adds context: key-value pair scoped by identifier, persistent vs 24-hour retention. 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?

Multiple sentences but efficient. Front-loaded with purpose, then usage, then details. No fluff, but could be slightly more concise.

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

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

For a simple store tool with no output schema, the description covers what to store, when, how long, and companion tools. Given context signals and annotations, it 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?

Schema has 100% coverage with good descriptions. The description adds value by giving examples for key and emphasizing that value is any text, reinforcing meaning beyond schema.

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

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

The description starts with a clear verb and resource ('Save data the agent will need to reuse later') and gives concrete examples (ticker, address, preference). It also distinguishes itself from sibling tools recall and forget by mentioning them.

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

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

Explicitly states when to use ('when you discover something worth carrying forward') and provides companion usage hints with recall and forget. Also explains scope and persistence (authenticated vs anonymous).

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 readOnlyHint, openWorldHint, idempotentHint, and destructiveHint annotations, the description discloses behavioral traits: internal cascading through multiple lookup endpoints, graceful degradation when GLEIF/OpenFIGI is unavailable, explicit labeling of unresolved identifiers, and per-source provenance for resolved identifiers. This adds substantial transparency about system behavior and failure modes.

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, starting with user-facing examples and then systematically detailing supported types, output behavior, degradation, and internal complexity. While lengthy, every sentence adds meaningful information for agent decision-making, and the structure flows logically from core purpose to specifics.

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 must fully explain return semantics, and it does: identifiers with source labels, explicit unresolved list, and the return behavior for both 'company' and 'drug' types. It also covers the ISIN-to-LEI mapping, cross-source identity spine, and fallback behavior, making the tool's behavior predictable in all described scenarios.

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

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

The schema already provides 100% coverage, but the description enriches parameter understanding with concrete examples ('AAPL', '0000320193', 'ozempic'), explains how ISIN inputs resolve to legal entities, and details the 'unresolved' field behavior. This goes beyond the schema descriptions by adding real-world usage context and edge cases.

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: 'resolve a user-spoken NAME to the canonical/official identifiers other tools require as input.' It uses a specific verb ('resolve') and resource ('entity'), provides concrete examples ('ticker for', 'CIK for', 'LEI for'), and distinguishes itself from siblings by positioning it as the first tool to use when a name is known but an ID is needed.

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 instructs 'Use FIRST whenever you have a name but need an ID,' giving a clear when-to-use directive. It also notes that the tool 'replaces 2-3 manual lookups,' implying efficiency. However, it does not explicitly name alternative tools or provide when-not-to-use guidance, though the 'Use FIRST' phrasing partially compensates.

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 false. The description adds value by detailing the probing process using ai_visibility_check, mentioning API key requirements for Anthropic, and specifying the output includes score, confidence, and signal density, which are 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 well-structured, starting with the core purpose, then explaining the process, and giving a usage example. It is concise enough to be easily scanned but contains all necessary information. Slight reduction could be made, but overall it's effective.

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

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

Given the four parameters (one required), no output schema, and good annotations, the description fairly covers the tool's behavior and return value. It mentions the ranked list with specific fields, but lacks detail on the exact JSON structure, which would be helpful with no output schema. Still, it is sufficiently complete for selection and invocation.

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

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

With 100% schema coverage, the baseline is 3. The description adds the narrative nuance that the first entity is treated as the 'subject,' which is not in the schema. It also clarifies the relationship between models and _apiKey. This adds meaningful context beyond the schema descriptions.

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

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

The description clearly states the tool compares AI visibility across multiple entities side-by-side, using a specific verb and resource. It distinguishes itself from sibling tools like ai_visibility_check by emphasizing the comparative, multi-entity nature and providing a concrete use case example.

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 indicates when to use the tool (competitive AI-marketing audits) and implies when not to (single entity checks, which would use ai_visibility_check). It could be more explicit about alternatives, but the context and sibling list provide enough guidance.

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

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

Annotations already indicate safe read operation. Description adds significant behavioral details: partial failures degrade gracefully, bundlephobia first measurement can take 5-30 seconds, sources_failed will list timeouts, and return structure is fully described.

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

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

The description is a single paragraph but front-loads the purpose with a clear summary. It is comprehensive yet efficient, including return structure, ecosystem notes, and error handling without excessive verbosity.

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

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

Given no output schema, the description thoroughly explains return values: summary block fields, per-advisory details, links, and alternative versions. Also covers partial failures and timing, making the behavior fully transparent.

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

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

Schema coverage is 100% for both parameters. Description confirms default behavior for version and accepts scoped packages, but adds no new information beyond what the schema already provides.

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

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

The description clearly states it's a composite check for npm packages, combining deps.dev and bundlephobia information. It specifies the verb 'scan' and resource 'dependency', and distinguishes from sibling tools by focusing on package health metrics.

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

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

Explicitly states when to use: when an agent asks about package safety, popularity, size, or cost. Also provides ecosystem limitation (npm only) and directs to deps.dev:version for other ecosystems, giving clear guidance on alternatives.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description goes far beyond by detailing the embedding model (BGE-base-en), similarity metric (cosine), chunking (500-char windows), character limit (200K with truncation and flagging), and output features (character offsets, similarity scores).

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 efficient and well-structured. It front-loads the core purpose, immediately explains usage context, then provides technical details. Every sentence contributes meaningful information without redundancy. No unnecessary words.

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

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

Despite having no output schema, the description adequately explains return values (top-N passages with character offsets and similarity scores). It covers the 200K char input cap and truncation behavior. All three parameters are fully described. The tool's complexity is moderate and the description 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% with all three parameters described. The description adds value by providing examples for the query parameter ('supply-chain risk', 'fiscal year 2024 revenue'), specifying default value and range for limit, and contextualizing the text parameter as 'the document text you already pulled'. This enhances understanding beyond the schema alone.

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

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

The description explicitly states 'Semantic search INSIDE a fetched record' with a specific verb and resource. It distinguishes itself from siblings by mentioning pairing with ask_pipeworx_grounded and contrasting with other search 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 states when to use: 'Use when the record is too big to cram into the prompt.' It explains benefits (saves context, returns relevant passages) and mentions a sibling tool (ask_pipeworx_grounded) for amplification. No explicit when-not, but the condition 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?

The description adds significant behavioral context beyond the annotations: required account type, supported event types with examples, delivery channel details including verification and rate limits. The idempotentHint is not explicitly confirmed or contradicted, but 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 efficient and front-loaded with the core purpose and return value. While it contains extensive detail, each sentence adds value. Minor opportunity to tighten without losing clarity.

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

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

The description covers essential aspects but lacks full return value details (e.g., id format, other response fields) and error conditions. Given the tool's complexity and no output schema, additional context on expected response and failure modes would improve completeness.

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

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

The description provides detailed examples and usage guidance for each type-specific params and delivery channels, adding meaning beyond the schema descriptions. Schema coverage is 100%, and the description enhances understanding.

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

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

The description clearly states the verb 'Create' and resource 'proactive monitoring subscription to a live-data event stream', and specifies the return value 'new subscription id'. This distinguishes it from sibling tools like list_subscriptions and unsubscribe.

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

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

The description explains when to use the tool (to create subscriptions) and provides constraints (requires Pipeworx OAuth account, anonymous/BYO cannot persist). It does not explicitly exclude alternatives, but the context of sibling tools provides differentiation.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is clear. The description adds that the tool returns example questions with tool+argument shapes, providing valuable behavioral context beyond annotations.

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

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

The description is somewhat lengthy but well-structured with a clear topic list and usage instructions. Every sentence adds value, though minor trimming is possible.

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

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

For a simple tool with one optional parameter, the description fully covers what it does, when to use it, and what it returns. No output schema exists, but the description explains the return format adequately.

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

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

Schema coverage is 100%, but the description adds meaning by listing the possible topic values and explaining that omitting the parameter yields a full spread. This goes beyond the schema's description.

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

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

The description clearly states the tool's purpose: an onboarding entry point that returns category-bucketed example questions. It uses specific verbs like 'returns' and 'call', and distinguishes from siblings by being the first tool to use when unfamiliar with Pipeworx.

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

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

Explicitly says 'Use this FIRST when you do not yet know what Pipeworx can do for you' and describes how to use the optional topic parameter. While it doesn't explicitly state when not to use it, the context makes it 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?

Adds valuable behavioral context beyond annotations: deactivates instead of deleting, preserving historical events. Aligns with idempotentHint and destructiveHint. No contradictions.

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

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

Two efficient sentences with no fluff. Front-loads the action and provides necessary details concisely.

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 no output schema, the description covers purpose, ownership, side-effect (deactivation), and relation to recent_alerts. Adequate for correct invocation.

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

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

Schema coverage is 100% and the schema already describes the 'id' parameter. The description repeats 'by id' and adds context about the id being returned by subscribe, which is helpful but not essential.

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

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

Clearly states the action 'Cancel a subscription by id' and specifies the resource. Distinguishes from sibling tools like 'subscribe' and 'list_subscriptions' by focusing on cancellation. Also explains ownership enforcement and deactivation behavior.

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

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

Explicitly says when to use: to cancel a subscription. Ownership enforcement provides context. Does not mention when not to use or alternatives, but the singular purpose is clear given the sibling list.

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, openWorld, idempotent), the description discloses substantial behavioral detail: dual-path execution (SEC EDGAR+XBRL fast path vs. grounded pipeline), the complete verdict vocabulary, and a crucial caveat that 'could_not_verify' means verification did not happen and must not be treated as evidence. It also explains the meaning of 'unsupported', which is extra context not evident from annotations.

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

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

The description is fairly long but every sentence contributes meaningful information—examples, routing logic, verdict semantics, and error handling. It is effective and thorough, though the density makes it less scannable and slightly wordy.

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 takes full responsibility for explaining return values and edge cases. It lists the verdict types, explains 'could_not_verify' and 'unsupported' behaviors, mentions the pipeworx:// citation format, and describes fallback routing. This gives the agent a complete mental model of the tool's behavior.

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 of both parameters with rich descriptions for 'claim' and 'tolerance_pct'. The description's mention of 'exact percent-delta math' adds marginal context, but it does not significantly expand on the schema's parameter semantics, 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 concrete natural-language examples and explicitly states the tool performs 'natural-language claim verification against authoritative sources'. It clearly distinguishes the tool's scope from siblings by describing both structured financial-claim routing and generic grounded fallback, and notes it replaces 4–6 sequential calls.

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 a direct trigger: 'Use whenever the agent needs to check whether something a user said is factually correct.' It also provides routing guidance for different claim types (financial vs. other). However, it does not explicitly name alternative tools or state exclusions, so it's not fully explicit on when not to use it.

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