Worldbank Climate

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false. The description adds value by explaining that Workers AI is free while Anthropic incurs costs via a BYO key, and that the tool returns per-model scores, confidence, signals, and raw responses. It does not contradict annotations and provides useful behavioral context beyond what 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 concise, using a single paragraph that covers purpose, default behavior, optional parameters, cost implications, output structure, and use cases. Every sentence is informative; no fluff. The most critical information (what it does and output) is front-loaded.

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

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

Given no output schema, the description adequately describes return values (per-model score, confidence, signals, raw_response, combined view). It explains both inputs and outputs clearly. The tool has moderate complexity (4 parameters, 1 required), and the description covers all aspects: entity, model selection, API key, context. Use cases are provided, making it complete for agent selection.

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 extra meaning by clarifying the default behavior (omit models for just workers-ai), the purpose of `_apiKey` (only needed if anthropic is in models), and the role of `context` for disambiguation. This goes beyond the schema's parameter descriptions.

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

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

The description clearly states the tool's purpose: probing LLMs for knowledge about entities and scoring visibility. It specifies the default model and optional Anthropic probing with BYO key. The verb 'probe' and resource 'LLMs' are specific, and the output (score 0-100 per model) is well-defined. It distinguishes from siblings like 'scan_competitor_ai_presence' by focusing on multi-model scoring.

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

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

The description provides clear use cases: AI-marketing audits, pre-launch brand checks, competitive monitoring. It explains when to use the default vs. Anthropic model. However, it does not explicitly mention when not to use this tool or differentiate from closely related sibling tools (e.g., 'scan_competitor_ai_presence'), which would be helpful.

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

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

Annotations already cover read-only, idempotent, open-world, and non-destructive behavior. The description adds meaningful behavioral context beyond those annotations: it explains that the tool routes the question to sub-tools, fills arguments, and returns structured answers with stable citation URIs. It does not mention failure modes or rate limits, but the core behavior is transparent.

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

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

The description is long but front-loaded with the most important routing preference and followed by concrete examples and exclusions. It is mostly efficient, though phrases like 'synthesized synthesis' and the redundant 'START HERE for most questions — except as noted below' add minor noise.

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

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

For a tool with no output schema and a simple one-parameter input, the description is unusually complete: it covers scope, examples, output format, citation URIs, and when to prefer alternatives. It does not differentiate from the close siblings ask_pipeworx_beta and ask_pipeworx_grounded, which is a small but notable gap.

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

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

Schema description coverage is 100%, and the schema already documents that question is a natural-language query with several aliases. The description's examples and trigger phrases provide some guidance on what kind of question to ask, but they do not add significant meaning beyond what the input schema already provides.

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

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

The description clearly identifies the tool as a router for factual and data-oriented questions, stating that it routes to one of 5,710 tools across 1,494 verified sources and returns structured answers with pipeworx:// citation URIs. This is a specific verb-resource-scope statement that distinguishes it from generic web search and other siblings.

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

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

The description gives explicit when-to-use guidance with domain lists, trigger phrases, examples, and named alternatives like DEEP_RESEARCH, WEB_SEARCH, RECALL, and MEMORY. It loses a point because it says to prefer this tool over web search 'even if web search could also answer it' but later says to prefer WEB_SEARCH for simple direct factual answers, leaving a mild internal tension about routing.

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 carry the safety profile (readOnlyHint, idempotentHint, openWorldHint, non-destructive), lowering the bar. The description adds genuinely valuable behavioral context beyond annotations: experimental status, the dated no-active-candidate state, and the explicit correction that this is a full working router, not a fallback stub. It stops short of describing what changes behaviorally when a candidate IS under test, so not a 5.

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, appropriately sized for a beta-variant tool, and front-loaded with identity and current state. Every sentence adds a distinct fact, but the identity point is made three times ('identical', 'matches exactly', 'use it exactly like'), and the timestamped state claim will age stale — mild redundancy prevents 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?

For a router variant with 6 params, 100% schema coverage, and rich annotations, the description covers identity, current state, when-to-use, and evaluation behavior. The only gap: with no output schema present, response shape is deferred to ask_pipeworx ('same response shape') rather than being self-contained — an acceptable pointer in a sibling context but not fully standalone.

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% — all six parameters (question plus five documented aliases) are covered, so the baseline is 3. The description only notes 'same arguments' as ask_pipeworx, which adds no parameter-level meaning beyond what the schema already provides; no compensation needed, no bonus earned.

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

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

States a specific verb and resource ('ask Pipeworx') and immediately defines itself as the beta of ask_pipeworx, differentiating it from the stable sibling. The phrase 'identical universal router (same 5,710 tools, same arguments, same response shape)' makes scope and relationship unambiguous without opening the sibling's definition.

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?

'Use it exactly like ask_pipeworx when you want the newest routing' is an explicit when-to-use directive that names the alternative tool. The framing that 'results are compared against the stable router to decide what merges' gives the agent operational context for selecting this over the stable variant.

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 this as read-only, open-world, idempotent, and non-destructive. The description goes further by disclosing the exact refusal behavior, the return payload with evidence and confidence, and the constraint that the answer is derived only from the tool result. This is rich behavioral context that goes well beyond the annotations and would prepare an agent for refusal outcomes.

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

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

The description is dense but every sentence serves a distinct purpose: it states the mode, explains routing/mechanics, specifies success and refusal outputs, gives use cases, and notes the cost differential. It is front-loaded with the most important behavioral distinction and remains focused without repeating schema or annotation content.

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

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

Given that there is no output schema, the description fully compensates by specifying the success return shape, the refusal shape with all possible refusal_reason enum values, and the business context for when to use grounded mode. It also addresses cost and sibling routing, so an agent has everything needed to invoke the tool correctly and interpret its results.

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

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

Schema coverage is 100% and the schema already documents both the canonical 'question' parameter and all five aliases. The description does not add parameter-specific meaning beyond the schema, but since the schema is fully self-explanatory, a baseline of 3 is appropriate. No compensation is needed for undocumented parameters.

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

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

The description clearly identifies this as a hallucination-resistant, grounded answer mode for high-stakes reads, and explicitly contrasts it with ask_pipeworx by emphasizing that it extracts answers only from tool results and returns evidence/refusals. The mention of 'Same routing as ask_pipeworx' gives agents a concrete sibling anchor, and the distinctive return/refusal shape makes the tool 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?

Usage guidance is explicit: 'Use whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts' with concrete domains (financial verdicts, legal claims, medical lookups, public statements). It also provides a clear exclusion rule, 'prefer ask_pipeworx for casual lookups,' and explains the cost tradeoff of one extra LLM call, leaving no ambiguity about when to select this tool.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint=true, destructiveHint=false. The description goes far beyond by detailing low-confidence resolution short-circuiting, closed market handling, wide spread tradeability flag, resolution-rule risk (cancellation_rule), parent event extraction, news fallback fields, and the resolver contract with market_match_confidence. No contradictions.

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

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

The description is long but well-structured with section headers (CLASSIFIERS, FAN-OUT EXAMPLES, RESPONSE SHAPES, etc.). Every sentence adds value given the tool's complexity. Could be slightly trimmed, but the structure aids readability and information density.

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

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

Despite no output schema, the description details response shapes (result.market, result.analysis, result.evidence), resolver contract, parent event extractor, news fields, and safety/edge cases. It covers all necessary context for an AI agent to use the tool correctly, including what to inspect before trusting analysis.

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 has 100% coverage; every parameter has a description. The description adds meaning: market parameter accepts slug, URL, or question text; depth parameter has quick/thorough with defaults; include_raw explains when to use false vs true. Examples in schema and description enhance 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 it researches a Polymarket bet by pulling relevant Pipeworx data. It specifies the action (research), the resource (Polymarket bet), and the method (resolves market, classifies, fans out). It distinguishes from sibling tools like polymarket_edges, polymarket_arbitrage, etc., which focus on different aspects.

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

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

The description explicitly says 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z"'. It provides usage examples and explains when the tool returns blocking statuses (low_confidence_match, market_closed_or_inactive). It does not directly compare to all siblings but the specific use cases are 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?

In addition to the annotations (readOnly, idempotent, etc.), the description discloses key behaviors: data sources for company (SEC EDGAR/XBRL with off-calendar handling) and drug (FAERS, FDA, trials), sorting by primary metric, and return of 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 one dense paragraph, but every sentence adds value. It is front-loaded with example phrases and usage guidance. While concise, a slight restructuring could improve readability, but no unnecessary content.

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

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

Given the tool's complexity (two entity types, multiple data sources, no output schema), the description is comprehensive. It covers data sources, edge cases (off-calendar fiscal years), sorting behavior, output format, and efficiency benefits. It fully compensates for the lack of an output schema.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds significant semantic meaning: explains that 'company' type returns 10-K financial metrics and 'drug' type returns adverse-event counts, approval counts, and trial data. This goes well beyond the schema's enum labels.

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

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

The description clearly states the tool performs side-by-side comparison of 2–5 companies or drugs in a single parallel call. It uses specific action verbs ('compare', 'rank') and explicitly distinguishes from sequential single-entity lookups, which are common among siblings like 'entity_profile'.

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 'ALWAYS PREFER over sequential single-pack lookups when comparing entities', providing clear guidance on when to use this tool. It also quantifies efficiency by stating it replaces 8–15 sequential lookups, but does not explicitly list scenarios where it should not be used.

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, open-world, and idempotent, and the description is consistent with those. It adds substantial behavioral detail beyond annotations: decomposition into facets, parallel routing across 5,710 tools, the findings packet shape, explicit gaps[], contradiction detection, citation URI semantics, semantic excerpting, and expected latency. This far exceeds the baseline disclosure burden.

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

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

The description is long, but front-loaded with the most decision-critical information: account requirement, free tier, and sibling alternative. The structure is logical and nearly every sentence adds value. It loses a point because some depth semantics are restated from the schema and the output-format details make the description more sprawling than necessary for mere tool selection.

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

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

Despite having no output schema, the description fully covers what an agent needs: authentication requirement, free vs paid access, when to prefer ask_pipeworx, the return packet contents, citation format, gaps behavior, contradiction scan, excerpting behavior, and latency expectations. For a complex research tool with only two parameters, this is exceptionally complete.

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

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

Schema coverage is 100%, so the baseline is 3, but the description meaningfully expands on the schema. It explains the practical effects of depth values: 'quick' as single-hop, 'standard' adding gap-recovery and contradictions, and 'thorough' being paid and chaining follow-up hops. It also clarifies that 'question' supports broad/multi-part natural language, which is not obvious from the schema alone.

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

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

The description clearly identifies a specific action ('Grounded multi-source research across Pipeworx's 1494 STRUCTURED data sources') and explicitly contrasts itself with open-web search. It also names the sibling tool ask_pipeworx as the alternative for different use cases, so an agent can reliably distinguish deep_research from its siblings.

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

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

The description gives explicit when-to-use guidance: it is best for broad/multi-part questions over structured data, and it states concrete exclusion conditions like 'If you are not signed in, use ask_pipeworx instead' and 'For a single lookup use ask_pipeworx instead.' It also clarifies tier-based access, including when the paid 'thorough' depth is 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?

Annotations already provide readOnlyHint and destructiveHint. Description adds that it returns top-N tools with full schemas ready to call, which is useful context without contradicting annotations.

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

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

Front-loaded with purpose and usage, though the list of domains makes it slightly lengthy. Overall efficient and well-structured.

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

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

Despite no output schema, description fully explains what is returned (names, descriptions, input schemas). Helps agent understand complete 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%, but description adds value by explaining alias parameters and the limit parameter, as well as the behavior of returning top-N results.

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 tools by describing data or task, lists many domains, and distinguishes itself from siblings as the first tool to call for browsing.

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 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' Provides clear when-to-use 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 declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. Description adds context about fanning out across multiple sources, patent soft-fail until May 2025, and return details. No contradictions.

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

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

Description is front-loaded with purpose and examples, then details sources and return fields. Somewhat dense but every sentence adds value. Could be slightly more concise but still effective.

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

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

Despite no output schema, description thoroughly explains what is returned (cik, company_name, filings with URIs, fundamentals, patents status, news, LEI) and covers limitations (patents sunset, name not supported). Complete 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 both parameters described. Description reinforces meaning and adds critical constraint 'Names not supported — use resolve_entity first,' going 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 the tool's purpose: 'full cross-source profile of a US public company in ONE parallel call.' It provides multiple example queries and distinguishes from sibling tools that would require chaining multiple 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?

Explicit when-to-use guidance: 'ALWAYS PREFER over chaining single-pack lookups when the user asks for a holistic view.' Also specifies when not to use: 'names not supported (use resolve_entity first if you only have a name).'

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

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

Annotations provide destructiveHint and idempotentHint. Description adds context about why to delete but doesn't disclose behavior for non-existent keys or return value.

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

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

Two concise sentences: first states purpose, second gives usage guidance. 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?

Simple tool with one param and no output schema. Description adequately explains use cases and provides context. Could mention permanence of deletion, but sufficient overall.

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

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

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

Clear verb 'delete' and resource 'memory by key'. Distinguishes from sibling tools 'remember' and 'recall'.

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

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

Explicitly states when to use: stale context, task done, clear sensitive data. Mentions pairing with remember and recall, but lacks explicit when-not-to-use.

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

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

Annotations already declare read-only, idempotent, non-destructive behavior. The description adds context on fetching the page, extracting title/description/key links, and emitting standard markdown format. No contradiction.

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

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

Four sentences: first states main purpose, second explains process, third describes output format, fourth lists use cases. No wasted words, 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?

Despite no output schema, the description adequately explains the output (single text blob in llms.txt format). Together with annotations (read-only, etc.), it provides sufficient context for agent 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% with clear parameter descriptions. The tool description does not repeat or add to parameter details, but it implicitly relates to the 'url' and 'max_links' parameters. 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 it generates a production-ready llms.txt file for any URL, specifying the exact output and its use for AI crawler indexing. It distinguishes itself from sibling tools like 'ai_visibility_check' and 'scan_competitor_ai_presence' by focusing on file generation rather than analysis or checks.

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

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

Explicit use cases are provided: getting a client's site indexed, drafting for own projects, auditing competitors. However, it does not offer explicit when-not-to-use guidance or compare directly with siblings.

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

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

Beyond annotations indicating readOnly and non-destructive behavior, the description reveals key behavioral traits: automatic indicator code assembly, return format (ISO3 keys, startYear-07), and failed API testing for era5/cru collections. This adds substantial value.

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

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

The description is front-loaded with purpose and includes detailed worked examples. While somewhat long, the examples are verified and earn their place. Slight room for brevity, but well-structured.

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

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

Given 8 parameters, no output schema, and no nested objects, the description provides comprehensive coverage: default values, return format, collection caveats, and fallback mechanism. It leaves little ambiguity 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 description coverage is 100%, so baseline is 3. The description adds value by explaining composite indicator code construction, parameter defaults, and warnings (e.g., collection preference). This elevates the score 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 explicitly states the tool retrieves World Bank CCKP climate data, listing data types (historical observations, projections), variables (temperature, precipitation), and the automatic assembly of indicator codes. It is specific and distinguishes from unrelated 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 includes worked examples demonstrating typical use cases and explains when to use the indicator_code fallback. It does not explicitly state when not to use the tool, but given no direct siblings for climate data, this is a minor gap.

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

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

Discloses that it takes no arguments and returns a static reference object. Annotations already indicate read-only, open-world, idempotent, non-destructive, and description adds value by detailing return content.

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 repeats 'Takes no arguments' and similar phrases twice. Could be more concise without losing meaning.

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

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

No output schema, but description fully explains the components of the returned object, making it complete for a reference 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?

No parameters; schema coverage 100%. Baseline 4 is appropriate as description adds context about the return object's contents beyond the empty 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 returns a static reference object documenting CCKP indicator-code components, listing specific elements. It distinguishes from sibling get_climate_data by indicating it should be called first.

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

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

Explicitly instructs to call before get_climate_data to choose valid parameter combinations, providing clear when-to-use 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 declare readOnlyHint and idempotentHint. The description adds specific return field details (id, type, params, timestamps, fire_count) and implies default filtering to active subscriptions, going beyond the annotations.

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

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

Two sentences, front-loaded with functionality and return fields, then usage guidance. No redundant information.

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

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

For a simple tool with one optional parameter and no output schema, the description covers purpose, usage, and return fields adequately. It could mention pagination or limits, but these are not required given the tool's simplicity.

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

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

Schema coverage is 100% and the parameter is well-described in the schema. The description does not add new semantic detail beyond stating 'active subscriptions,' so the baseline of 3 applies.

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

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

The description clearly states the tool lists the caller's active subscriptions and specifies return fields. While it distinguishes from sibling subscribe/unsubscribe by context, it lacks an explicit differentiation statement, so it's not a perfect 5.

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 using this tool to review subscriptions before adding more or to find an id to cancel, providing clear context for when to invoke it. It doesn't mention alternatives or when not to use, but the sibling tools are obvious complements.

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

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

The description discloses several behaviors beyond what the sparse annotations (all false) convey: the claim_token flow for anonymous filing, daily digest review, a rate limit of 5 per identifier per day, and that it does not count against tool-call quota. These are material behavioral traits a user would not otherwise know. No contradiction with annotations exists.

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

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

The description is longer than average but each sentence earns its place: purpose, use cases, exclusions, workflow, and policy constraints are all covered. It is front-loaded with the core purpose and flows logically. Minor verbosity (e.g., 'The team reads digests daily and signal directly affects roadmap') could be trimmed, but it remains efficient and structured.

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

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

For a feedback tool with 4 params (one nested), no output schema, and weak annotations, the description is remarkably complete. It explains the full lifecycle (filing, anonymous claim token, checking resolution), scope boundaries, rate limits, and quota impact. The absence of an output schema is compensated by describing the claim_token return, making the tool feel fully 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 coverage is 100%, so each parameter already has a detailed description. The description adds value by explaining how the claim_token parameter works ('Filing without an account returns a claim_token; pass it back later as pipeworx_feedback({claim_token:"pwfb_…"}) to read whether it was fixed'), which is a workflow not fully captured in the schema's field description. It also clarifies the intended use of context fields via examples.

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

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

The description opens with a specific, actionable verb+resource: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It clearly distinguishes itself from sibling tools by scoping feedback exclusively to Pipeworx-owned tools, and enumerates concrete use cases (bug, feature/data_gap, praise). This leaves no ambiguity about what the tool does.

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

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

The description provides explicit when-to-use guidance: 'Use when a tool returns wrong/stale data (bug), when a tool you wish existed isn't in the catalog (feature/data_gap), or when something worked surprisingly well (praise).' It also gives a clear exclusion criterion: 'if the tool came from a different MCP server... file it with that server instead.' This is exemplary usage guidance with both positive and negative conditions.

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

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

The description adds context beyond annotations by revealing the data source (CF analytics-engine), privacy (no PII), and caching behavior (5min-1h). Annotations already declare safety traits (readOnly, openWorld, idempotent, non-destructive), and description aligns without contradiction.

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

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

The description is three sentences with no wasted words. It leads with the core purpose, then lists use cases, then adds technical detail. Efficient and well-structured.

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

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

Given the single parameter with full schema coverage, strong annotations, and no output schema needed, the description provides complete context: purpose, use cases, source, caching, and data types. Nothing essential is missing.

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

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

The schema covers 100% of parameters (just 'window') with enum and description. The description does not add new parameter semantics beyond what the schema provides, so baseline score of 3 is appropriate.

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

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

The description clearly states the tool returns top tools, top packs, and total call volume over a window, with a specific verb and resource. It distinguishes from sibling tools by focusing on trending data rather than search or entity lookup.

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

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

The description lists three explicit use cases for when to use the tool and explains how window selection affects results (short window for hot trends, long for demand). It does not explicitly state when not to use, but the guidance is clear and helpful.

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

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

Annotations already declare read-only and idempotent behavior. The description goes far beyond by detailing internal logic: Jaccard similarity threshold, partition filter, fill check against CLOB depth, and conditions for not trading. 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 thorough but lengthy, packed with technical details. It is front-loaded with the core purpose and structured by mode, but could be slightly more concise without losing content. Nonetheless, every sentence earns its place.

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

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

Given the complexity of arbitrage detection with multiple modes and no output schema, the description fully explains input choices, algorithmic details, response shape, and caveats (fill check, placeholder filters). No important gaps remain.

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

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

Schema coverage is 100% with both parameters described. The description enhances each parameter by explaining the mode behavior (e.g., event mode walks child markets, topic mode searches related events) and provides examples, adding significant 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 finds arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It distinguishes three modes (trending_scan, event, topic) and provides specific usage scenarios, making the purpose extremely clear.

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

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

The description provides explicit guidance on when to use each mode: trending_scan for top markets, event for specific events (recommended), and topic for cross-event scanning. It also references polymarket_fill_risk for custom sizing, giving clear alternatives and context.

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

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

Annotations already indicate safe, read-only behavior. The description goes far beyond by detailing caching (1h KV cache keyed on all knobs), model families (crypto_price, news_momentum, etc.), edge calculations, tradeable-edge knobs, and diagnostics. This exceeds the required transparency.

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

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

The description is very long and includes extensive technical details that, while valuable, may overwhelm an AI agent. It is well-structured with sections, but a more concise front-loading of key information would improve usability for quick decision-making.

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

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

For a tool with 9 parameters, no output schema, and complex behavior, the description is exceptionally complete. It covers all three model segments, tradeable-edge knobs, diagnostics, and even notes about unreliable Fed signals and caching behavior. The agent has all necessary context to use the tool effectively.

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

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

Schema coverage is 100%, so baseline is 3. The description adds context beyond the schema, such as default values and usage hints (e.g., 'Bump for very thin partitions; drop to 0 if you have a smarter fill model'). This additional guidance justifies a score above baseline.

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

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

The description clearly states the tool's function: scanning Polymarket markets to return opportunities where Pipeworx data disagrees with market price, with a specific use case of 'what should I bet on today'. It distinguishes itself from siblings like polymarket_arbitrage and polymarket_edge_tracker by detailing its model families and unique methodology.

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

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

The description provides a clear use case and mentions knobs for filtering tradeable edges, but it does not explicitly outline when to use this tool versus alternatives like polymarket_arbitrage or polymarket_edge_tracker. While the context is helpful, explicit exclusions or comparisons would improve this dimension.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false. The description adds valuable behavioral context: history depth bounded by 60-day TTL, snapshots written on cache-miss, decay from daily closes not intraday. No contradiction.

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

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

The description is relatively long but every sentence adds essential detail like response structure and limits. It is front-loaded with purpose. Could be slightly tightened but remains 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?

Despite no output schema, the description thoroughly explains the response fields (tracked[], expired[], snapshot_dates[]) and their meaning. Also covers limits and data freshness, making it complete for a complex time-series 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 days and window. The tool description adds default values, max bounds, and clarifies what each parameter controls (lookback, snapshot family), going beyond the schema.

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

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

The description uses specific verbs and nouns: 'edge persistence and decay telemetry', 'answers how long has this edge existed and is it shrinking?'. It clearly distinguishes from siblings like polymarket_edges by focusing on time-series behavior.

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

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

The description explains the use case (comparing fresh vs old edges) and implicitly differentiates from alternatives like polymarket_edges (which likely gives current edges). However, it lacks explicit 'when not to use' 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 declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive. The description adds valuable behavioral context: walks the ladder, returns specific fields (top_of_book, vwap_fill_price, etc.), and explains the risk of partial fills. 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 (required, single-market, basket, usage note) but is somewhat verbose. Every sentence adds value, though some could be tightened. Front-loaded with the main purpose, making it easy to scan.

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

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

Despite no output schema, the description enumerates all return fields for both modes (e.g., top_of_book, vwap_fill_price, verdict, capture_ratio, thin_legs). It fully addresses the tool's complexity (4 params, 2 modes, 0 required) and provides enough context 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% with descriptions for all four parameters. The tool description adds significant semantic value by explaining how parameters behave differently in single-market vs basket mode (e.g., size_usd interpretation, side auto-detection). This goes beyond the schema's basic 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 performs a 'realizable-vs-theoretical edge check against live CLOB order-book depth' with two distinct modes (single-market and basket). It distinguishes itself from sibling tools like polymarket_arbitrage and polymarket_edges by specifying when to use it before acting on their signals.

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

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

Explicit guidance is provided: use this tool before polymarket_arbitrage signals or polymarket_edges trades above $500. It also warns against assuming capturable overround on thin books and the risk of partial basket fills converting arb into unhedged positions, which is the dominant loss mode.

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

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

Even though annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, the description adds substantial behavioral context: safety fields, compatibility codes, skipped-unclassified leg handling, counters for dropped comparisons, temporal alignment, and warnings about false signal when bet shapes differ. This goes far beyond what the annotations provide and gives the agent a clear picture of failure modes and data-quality caveats.

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 earns its length: it is dense with actionable information and uses clear structural signposts like TWO MODES, RESPONSE, SAFETY FIELDS, and Codes. It is front-loaded with the core purpose and mode selection. It could be tightened slightly, but every sentence contributes meaning for a relatively complex 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?

There is no output schema, so the description must carry the burden of explaining return values and edge cases. It does this thoroughly by describing top_spreads_pp, compatibility_warning, compatibility_codes[], skipped_unclassified, low_confidence_pairs[], temporal_alignment, and the counters. Given the complexity of cross-venue matching, nothing essential is missing for an agent to invoke and interpret the tool correctly.

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

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

Schema description coverage is already 100%, but the description adds meaning beyond the raw schema: it enumerates all ten valid `topic` values, explains the override behavior of `kalshi_event_ticker` and `polymarket_event_slug`, and clarifies the relationship between the two modes. The examples in the schema are reinforced and expanded by the prose, so no parameter is left ambiguous.

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

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

The description starts with a specific, unambiguous statement of what the tool does: computes cross-venue spread between Kalshi and Polymarket for the same resolving question. It clearly distinguishes the two modes (topic shortcuts vs explicit pairings). It does not explicitly contrast itself with sibling tools like polymarket_arbitrage or polymarket_edges, but the resource and mechanism are clear enough that an agent can tell it apart.

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

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

The description gives explicit when-to-use guidance: use `topic` for pre-mapped shortcuts, use `kalshi_event_ticker`/`polymarket_event_slug` for custom pairings. It also sets realistic expectations by warning that most pre-mapped topics return compatibility warnings and that pre-mapped does not equal tradeable. However, it does not explicitly say when to prefer this tool over sibling spread/arbitrage tools, so it stops short of a 5.

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

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

Annotations indicate read-only, idempotent, non-destructive. Description adds scoping to identifier and the behavior of listing all keys when key omitted, which is useful context.

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

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

The description is two sentences, front-loaded with the action, and every sentence adds value. No redundancy.

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

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

For a simple tool with one optional parameter and no output schema, the description covers both modes, use cases, and scoping. It does not explain return format or errors, but it's adequate.

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

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

Schema coverage is 100%, and the description restates the key behavior (omit to list). No additional semantic information is provided 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 retrieves a saved value or lists all keys, with concrete examples (ticker, address, research notes). It distinguishes from siblings by naming 'remember' and 'forget'.

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

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

The description explains when to use the tool: to retrieve previously stored context without re-deriving. It mentions scoping and pairing with remember/forget, but does not explicitly exclude other use cases.

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

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

Adds value beyond annotations by describing return fields (source, citation_uri, raw payload), mark_read behavior, and filtering options. Annotations already indicate safe read operation (readOnlyHint, idempotentHint), and description does not contradict them.

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

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

Four sentences, front-loaded with main purpose, no redundant or misleading information. Every sentence serves a clear role.

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

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

Covers essential aspects: return format, filtering parameters, mark_read side effect, polling suitability, and alternative access. Lacks error handling details but sufficient for a read-only tool with minimal side effects.

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 descriptions, so description adds limited extra meaning. It groups parameters and explains purpose informally, but does not significantly augment schema information.

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

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

Clearly states it pulls fired events from the subscription feed, returning recent alerts with specific fields. Distinguishes from siblings like list_subscriptions by focusing on reading alerts versus managing subscriptions.

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

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

Provides clear guidance on when to use: to get recent alerts with optional filtering by type and since, and mark_read behavior. Mentions polling works and alternative HTTP endpoint for scripts, but does not explicitly exclude scenarios or compare with all siblings.

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

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

Annotations already declare safe, idempotent, non-destructive. Description adds that it fans out to multiple sources in one parallel call, has fallback behavior, and return structure (changes grouped by source, total_changes, citation URIs).

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

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

Front-loaded with example queries. Every sentence adds value. Length appropriate for complexity of multi-source tool. Clear structure.

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

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

Despite no output schema, description explains return structure. Covers all three parameters, source behavior, fallbacks, and distinguishes from sibling. Complete 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%. Description adds examples for 'since', explains 'value' accepts ticker or CIK, and clarifies 'type' only supports 'company'. Provides recommended 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 is a change feed for a company, listing example user queries. It distinguishes from sibling entity_profile and details the sources (SEC EDGAR, GDELT/GNews, USPTO).

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

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

Explicitly says to use entity_profile for static profile. Provides guidance on when to use relative shorthand vs ISO dates and recommends '30d' or '1m'. Mentions GDELT preferred over GNews and USPTO soft-fail.

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 write, idempotent, non-destructive. The description adds valuable context: scoped by identifier, persistence differences for authenticated vs anonymous sessions (24 hours), and session-spanning capability. No contradictions.

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

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

The description is concise with five sentences, front-loading the core purpose and usage. Every sentence adds value without redundancy.

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

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

For a simple two-parameter tool, the description fully covers purpose, usage, persistence behavior, and pairing with siblings. No gaps given the annotations and schema.

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

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

Schema coverage is 100% with clear parameter descriptions. The description adds concrete examples for key and value (e.g., 'subject_property', 'any text'), enhancing understanding beyond the schema fields.

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

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

The description uses a specific verb 'save data' and clearly states the resource (key-value store) and purpose (reuse later). It distinguishes from sibling tools 'recall' and 'forget' by explicitly pairing with 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?

The description provides clear use cases (e.g., 'a resolved ticker, a target address') and when to use it (when something worth carrying forward). It mentions pairing with recall and forget but does not explicitly exclude alternative tools beyond that.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive), and the description adds rich behavioral detail: enrichment degrades gracefully, identifiers are labeled with source, unresolved identifiers are explicitly listed, and internal cascading through multiple lookup endpoints is revealed. No contradiction with annotations.

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

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

The description is detailed and well-structured with 'SUPPORTED TYPES' sections, but it is somewhat verbose with redundant examples (e.g., multiple query phrasings). It earns its length for a complex tool, but a bit of trimming would improve 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?

With no output schema, the description sufficiently describes return behavior: identifiers with source labels, explicit unresolved list, example outputs like RxCUI + ingredient + brand, and graceful degradation. It also covers edge cases (ISIN for non-US issuers, GLEIF/OpenFIGI unavailability), making it complete for complex 2-parameter tool.

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

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

Schema coverage is 100%, and the description further enriches parameter meaning: for 'type' it explains the two entity categories with detailed sub-behaviors; for 'value' it gives examples (ticker, CIK, ISIN, brand, generic) and notes special cases like ISIN-to-LEI resolution for non-US issuers. This goes well beyond the schema.

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

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

The description clearly states it resolves user-spoken names to canonical/official identifiers, with a specific verb ('resolve') and resource ('NAME to identifiers'). It includes numerous concrete examples of user queries and explicitly distinguishes itself from siblings by stating 'Use FIRST whenever you have a name but need an ID'.

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

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

It provides explicit guidance on when to use the tool ('Use FIRST whenever you have a name but need an ID') and notes it replaces 2-3 manual lookups. However, it does not explicitly name alternative tools or say when not to use it, so it misses 'when-not' 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-only, idempotent behavior. The description adds that it probes each entity with ai_visibility_check, ranks by score, and returns per-entity metrics (score, confidence, signal density), providing operational insight without contradicting annotations.

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

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

The description is three sentences: first states the core action, second explains the probing and ranking process, third gives a concrete use case and return format. It is front-loaded, concise, and contains no redundant information.

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

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

Given 4 parameters, 1 required, 100% schema coverage, and no output schema, the description fully explains the tool's behavior and return value (ranked list with score, confidence, signal density). It covers the probing mechanism and the special role of the first entity.

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

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

Schema coverage is 100% with descriptions for all parameters. The description adds value by clarifying that the first entity in the array is treated as the 'subject' for narrative, and that models defaults to workers-ai, requiring _apiKey only for anthropic model.

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, using ai_visibility_check to probe and rank. It specifies the use case for competitive AI-marketing audits with an example question, distinguishing it from single-entity tools like ai_visibility_check.

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

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

The description provides context for when to use the tool ('competitive AI-marketing audits') and gives an example query. It implicitly contrasts with ai_visibility_check by describing the multi-entity comparison, but lacks explicit alternative guidance or when-not-to-use instructions.

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

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

Annotations already declare readOnlyHint and idempotentHint, but the description adds significant behavioral context: it fans out across multiple services, mentions potential latency (5-30s for new versions), describes the return format (summary block, per-advisory detail, links, alternative versions), and explains that partial failures degrade gracefully with a sources_failed list. 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 front-loaded with the main purpose. Every sentence adds value, though breaking it into sections could improve readability. It is appropriately sized given the complexity.

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

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

With no output schema, the description thoroughly explains the return value: a summary block with fields like is_latest, license, bundle sizes, etc., plus per-advisory details, links, and alternative versions. It also covers edge cases like partial failures, making the tool's behavior fully understandable.

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?

Both parameters are described in the schema (100% coverage). The description adds value by clarifying that scoped packages (e.g., '@types/node') are accepted for the 'package' parameter and that the 'version' defaults to latest, which reinforces 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's purpose as a composite check for evaluating whether to add an npm package, aggregating data from deps.dev and bundlephobia. It distinguishes itself from siblings by specifying the npm-only scope and directing users to other tools for other ecosystems.

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

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

The description explicitly tells when to use the tool ('when an agent asks is X safe / popular / small'), and when not to use it (other ecosystems: PyPI, Maven, etc. fall under deps.dev directly). It also provides guidance on graceful degradation for partial failures.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description goes beyond by revealing the underlying model (BGE-base-en), algorithm (cosine over 500-character overlapping windows), character limit (200K chars with truncation and flagging), and output structure (passages with offsets and scores). No contradictions.

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

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

The description is compact (4 sentences) with front-loaded purpose. Every sentence serves a distinct purpose: stating the action, explaining benefits, pairing with a sibling, and detailing technical constraints. No redundancy or filler.

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

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

Despite lacking an output schema, the description clearly states the return format (top-N passages with offsets and similarity scores). It covers input constraints (max chars, truncation), usage context, and pairing with another tool. For a tool with this complexity and given existing schema coverage, the description provides complete context.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by giving concrete examples for the query parameter (e.g., 'supply-chain risk') and clarifying the text parameter's maximum size with examples (SEC 10-K, article). It also explains the limit parameter's default and range. This extra context warrants a 4.

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

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

The description clearly states the tool performs semantic search inside a fetched record, with concrete examples like SEC 10-K bodies and articles. It distinguishes itself from sibling tools by emphasizing that it saves context by returning only relevant passages, implying it's for large documents rather than general Q&A.

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

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

The description explicitly says 'Use when the record is too big to cram into the prompt' and pairs with ask_pipeworx_grounded, providing clear when-to-use guidance. However, it does not explicitly state when not to use the tool or mention alternatives like using the document directly for small records.

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 mutability (readOnlyHint=false) and idempotency. The description adds context such as account requirements, type-specific parameter examples, delivery channel specifics (e.g., one-time webhook secret, auto-disable after 10 failures). 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 moderately lengthy but well-structured: it starts with the core action, then prerequisites, supported types with examples, and delivery details. Every sentence adds value, though some redundancy with schema parameter descriptions exists. It remains clear and scannable.

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

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

Given the complexity (multiple subscription types, nested delivery object, no output schema), the description is remarkably complete. It covers prerequisites, type-specific parameters, delivery channel behaviors (including verification, limits, and webhook auto-disable), and what the tool returns (subscription ID). No critical gaps remain.

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

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

Parameter schema coverage is 100%, and the description adds significant meaning beyond the schema: it provides detailed examples for each type (e.g., items codes for sec_8k), explains delivery fields with constraints (e.g., phone verification, webhook signing), and clarifies required vs optional fields. This greatly aids correct parameter selection.

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

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

The description clearly states the tool creates a proactive monitoring subscription to a live-data event stream and returns a subscription ID. It distinguishes from siblings like list_subscriptions and unsubscribe by specifying the creation action and output.

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 set up subscriptions) and provides prerequisites (Pipeworx OAuth account, non-anonymous). It details supported types and delivery channels, including constraints like phone verification and SMS caps. However, it doesn't explicitly state when not to use or compare with 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, destructiveHint. Description adds behavioral detail: returns category-bucketed example questions with live tool shapes. No contradictions.

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

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

Description is efficient with no wasted words; front-loads trigger phrases and purpose. Slightly long but each 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?

Tool is simple (optional param, no output schema). Description covers behavior, output, usage ordering, and customization. Fully adequate for an onboarding 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 100%, so baseline is 3. Description adds value by listing example topics and explaining the optional parameter's purpose, going beyond schema description.

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

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

Description clearly states this is an onboarding entry point to discover what Pipeworx can do, listing specific categories and that it returns example questions with tool+argument shapes. Distinguishes from sibling tools by being the first call for an agent uncertain of capabilities.

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

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

Explicitly says 'Use this FIRST' and provides guidance on when to call (when you do not yet know capabilities) and how to call (no arguments vs topic). Lacks explicit when-not to use, but the context is clear.

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

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

Annotations indicate destructiveHint=false and the description clarifies that rows are deactivated, not deleted, adding behavioral context. Ownership enforcement is also disclosed. Description adds value beyond annotations.

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

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

Two sentences, no wasted words. First sentence states core action, second provides critical nuance about ownership and deactivation.

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

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

The tool is simple (one param, no output schema). Description fully explains the effect, ownership rules, and references a sibling tool for historical data. No gaps identified.

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?

Only one parameter 'id' with schema coverage 100% (description includes source: 'returned by subscribe'). Description adds minimal extra 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?

Description clearly states the verb 'Cancel' and the resource 'subscription by id'. It distinguishes from siblings like 'subscribe' and 'list_subscriptions' by specifying cancellation and ownership enforcement.

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

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

States ownership enforcement ('you can only cancel your own subscriptions') and mentions that historical events remain available via 'recent_alerts', indicating a related tool for viewing past events. No explicit when-not-to-use, but context is clear.

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

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

The annotations already declare readOnlyHint=true, openWorldHint=true, and idempotentHint=true, but the description goes further by explaining the return verdicts (confirmed, approximately_correct, refuted, inconclusive, unsupported, could_not_verify), the citation format, and the critical distinction between could_not_verify and unsupported. This transforms the tool from a simple 'checker' into one with well-understood edge cases and failure semantics.

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 every sentence carries weight: trigger phrases, usage rules, routing behavior, return contract, and error semantics are all present. It is front-loaded with concrete examples, and the structure is logical, moving from user-facing triggers to internal mechanics to caller cautions. 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 fully accounts for return values and their meanings, including the subtle difference between could_not_verify and unsupported. It also explains the dual-path execution (financial vs. other claims), making the tool's complex behavior transparent. For a high-complexity tool, this description is remarkably complete.

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

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

Schema description coverage is 100%, so both parameters (claim and tolerance_pct) are already well-documented in the input schema. The description adds context about percent-delta math and tolerance defaults, but it does not provide additional syntax or formatting guidance beyond what the schema offers. Baseline 3 is appropriate because the schema carries the load without conflicting with the description.

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

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

The description uses specific verbs like 'verify' and 'fact check' and identifies the resource as 'natural-language claim verification against authoritative sources.' It clearly distinguishes this tool from siblings such as ask_pipeworx_grounded and deep_research by focusing on factual claim verification with a defined verdict taxonomy. The explicit trigger phrases and dual-path structure 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 usage context: 'Use whenever the agent needs to check whether something a user said is factually correct.' It also differentiates between company-financial claims and any other factual claims, and notes that it replaces 4–6 sequential calls, which signals when to use it as a shortcut. However, it stops short of naming alternatives or stating explicit when-not-to-use conditions, leaving a small gap.

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