Netherlands Tenders

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

Annotations already indicate readOnly, idempotent, openWorld, non-destructive. The description adds: scores 0-100, returns per-model {score, confidence, signals, raw_response} plus combined view, and cost implications for Anthropic calls. No contradictions.

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

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

Three sentences front-loaded with core purpose and score range, then default model and optional key, then return structure and use cases. No wasted words, efficient and clear.

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

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

With no output schema, the description covers the return structure (per-model scores, confidence, signals, raw_response) and use cases. It could mention model list or limits, but overall it is sufficiently complete for an AI agent.

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

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

Schema coverage is 100%, but the description adds meaningful context: default model is Workers AI Llama-3.3-70b (free), _apiKey enables Anthropic probing (BYO key), and context parameter disambiguates entities. This goes beyond the schema descriptions.

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

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

The description clearly states the tool probes LLMs for knowledge about an entity and scores visibility 0-100 per model. It specifies the default model and optional Anthropic probing, and distinguishes from sibling tools like 'scan_competitor_ai_presence' by focusing on AI visibility scoring across multiple models.

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

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

The description explains when to use the tool (AI-marketing audits, pre-launch brand checks, competitive monitoring) and notes prerequisites (default model free, _apiKey for Anthropic). It does not explicitly exclude alternatives, but the context is clear.

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

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

Annotations already declare the tool safe (readOnlyHint, openWorldHint, idempotentHint, destructiveHint false). The description adds useful behavioral context: it routes to many sources, fills arguments, returns structured answers with stable citation URIs, and is a fast single call. No contradictions; slightly less detail on failure modes, hence 4.

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 verbose but well-structured: starts with the core instruction 'PREFER OVER WEB SEARCH', lists covered domains, explains the routing mechanism, then provides tiered usage guidance and examples. Every sentence adds value for a tool with many siblings. Could be slightly tighter, but earns 4 for clarity and front-loading.

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

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

Despite no output schema, the description explains return value (structured answer with pipeworx:// URIs). It covers typical use cases, alternatives, and scope. However, it omits details on routing failures or out-of-scope questions. For a complex routing tool, this is fairly complete; 4 matches the strong coverage.

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 6 parameters documented). The description adds only that it accepts natural language queries and 'fills arguments', but does not explain parameter formats or constraints beyond the schema. Baseline 3 is appropriate as the description adds marginal value over the already-complete 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: to answer factual questions about current/historical data from 5,564 tools across 1462 sources. It lists specific domains (SEC, FDA, FRED, etc.) and explicitly differentiates from siblings like ask_pipeworx_grounded and deep_research with usage conditions.

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

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

The description provides explicit when-to-use guidance: 'START HERE for most questions — this is the default entry point'. It also states when to use alternatives (hallucination-resistant questions → ask_pipeworx_grounded; broad/multi-part → deep_research). It even addresses breaking news as handled by this tool, leaving no ambiguity.

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

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

Annotations already show readOnlyHint, idempotentHint, openWorldHint, destructiveHint false. The description adds behavioral context: it is a beta with candidate routing improvements, currently matches the stable router exactly, and results are used to decide merges. This goes beyond the annotations by explaining the experimental nature and fallback behavior.

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

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

The description is a single, well-structured paragraph. It leads with the beta status and core identity, then explains candidate improvements, current state, and usage guidance. 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?

The description covers the tool's purpose, relationship to the stable version, current behavior, and usage guidance. With no output schema, it could explicitly mention the response shape (though implied as same as ask_pipeworx). Overall, it is sufficiently complete for a beta variant.

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 all six parameters are documented as aliases for the same 'question' field. The description adds no additional meaning about parameters, which is acceptable given the schema already fully describes them.

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 is a beta version of ask_pipeworx, an identical universal router with the same 5,564 tools and arguments. It distinguishes itself from the stable sibling as the experimental edge, making the purpose specific and unambiguous.

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

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

The description advises using this tool 'when you want the newest routing' and explains that results are compared against the stable router. It also notes the current state (no active candidate) and that it falls back to nothing. It lacks explicit when-not-to-use or alternatives, but the sibling list includes ask_pipeworx and ask_pipeworx_grounded for comparison.

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 idempotent, read-only, open-world, and non-destructive hints. The description adds significant behavioral detail: the two-step routing+extraction process, explicit refusal reasons list, and standard success response shape. No contradiction found. Slightly less than 5 because it doesn't describe rate limits or auth needs, but annotations cover the broad safety profile well.

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

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

Every sentence provides critical information without fluff. Four clear sections: purpose statement, process summary, return format+refusal behavior, usage guidance+cost trade-off. Front-loaded with the key differentiator.

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 (choosing among 5,564 tools, with a heavy extraction step) and no output schema, the description fully covers input expectations, return shape (including error cases), behavior, and cost trade-off. No gaps remain.

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

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

Schema coverage is 100% and all parameters are aliases of `question`. The description adds value by stating the parameter expects natural language, which is not redundant with schema hints. Baseline would be 3 due to high coverage, but the natural language guidance earns 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 uses a specific verb-resource pair ('Hallucination-resistant answer mode') and clearly distinguishes this from its sibling `ask_pipeworx` by highlighting the grounded extraction process and explicit refusal behavior.

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

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

Explicitly states when to use (high-stakes reads, answers that will be quoted/cited/acted on) and when not to prefer (`ask_pipeworx` for casual lookups) because it's heavier (costs one extra LLM call). Also names the alternative directly.

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

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

The description is exceptionally transparent about the tool's behavior: it explains the resolver contract (confidence levels, alternatives, suggestions), parent event extraction, news fields with fallback mechanisms, safety blocks (low confidence, closed markets), spread warnings, and cancellation rules. This far exceeds what annotations (readOnly, idempotent) provide, offering deep insight into internal logic and edge cases.

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 with valuable information but is quite long. It front-loads the purpose and provides structured sections (CLASSIFIERS, FAN-OUT EXAMPLES, RESPONSE SHAPES, etc.), which aids readability. However, some repetition and excessive detail could be trimmed for conciseness. Every sentence earns its place, but the length reduces scanability.

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

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

Given the tool's complexity (multiple classifiers, fan-out, resolver, parent events, safety checks), the description is remarkably complete. It covers every major aspect of behavior, output structure, and edge cases (e.g., cancellation rules, low confidence paths, illiquid spread). There is no output schema, so the detailed RESPONSE SHAPES and RESOLVER CONTRACT sections fully compensate.

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 3 parameters, and the description adds meaningful context: market input types, depth options with implications, and include_raw guidance on response size and use cases. While the baseline is 3 for high coverage, the description elevates by providing practical advice beyond schema definitions.

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

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

The description clearly defines the tool's purpose: researching a Polymarket bet by retrieving Pipeworx data. It specifies the input (slug, URL, question text) and output (evidence packet + market-model comparison). While it doesn't explicitly distinguish from sibling tools, the unique capabilities (resolving, classifying, fanning out) are clearly stated, making it specific and differentiated.

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

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

The description provides explicit use cases ('should I bet on X', 'what does the data say about Y', 'is there edge in Z') and details on input formats. It also gives guidance on when to inspect fields like market_match_confidence and parent_event. However, it does not explicitly state when not to use this tool or suggest alternatives, which would be helpful given the sibling tools.

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

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

Description adds detailed behavioral context: data sources (SEC EDGAR/XBRL for company, FAERS for drug), fiscal year handling, sorted results, citation URIs. Annotations already declare idempotent and non-destructive, and description aligns fully.

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

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

Every sentence adds value; front-loaded with purpose and usage priority, followed by type-specific details. Concise yet comprehensive with no redundancy.

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

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

Fully explains operation, data sources, and return structure without needing an output schema. All relevant aspects are covered given the tool's complexity.

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

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

Schema covers all parameters (100% coverage). Description adds meaning: explains what each type retrieves (financials vs. adverse events) and gives concrete examples and constraints for values (tickers/CIKs, names, limits).

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 'side-by-side comparison of 2–5 companies or drugs in ONE parallel call' with specific verb and resource, and distinguishes from sequential single-pack lookups.

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

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

Explicitly says 'ALWAYS PREFER over sequential single-pack lookups when comparing entities' and provides example queries, giving clear context and exclusions.

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

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

Annotations already declare readOnlyHint=true, etc., but the description adds significant context: account requirement, paid plan for thorough, use of structured data (not web), return format (findings with citations, gaps, contradictions, hop field, citation_uri), and behavioral differences between depth levels (gap recovery, contradictory scan, lead chasing). No contradiction with annotations; the description aligns and enriches.

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 verbose but well-structured. It front-loads the critical 'ACCOUNT REQUIRED' notice, then progresses logically from what it does to when to use it, to behavioral details. Every sentence adds value, but some sections (e.g., the thorough explanation of citation_uri) could be tightened. Still, it earns a 4 for being informative and organized.

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 return value: a findings packet with verbatim evidence, confidence, source, fetched_at, pipeworx:// citation, explicit gaps[], contradictions[]. It also mentions time expectations (15-60s, thorough up to ~90s) and semantic excerpting of large records. This is nearly complete for a complex tool, missing only a minimal example.

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 both parameters have descriptions. The description adds meaningful value: for 'depth', it explains the number of facets and hops per level beyond the enum; for 'question', it clarifies that broad/multi-part questions are acceptable. This enhances understanding beyond the schema alone.

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

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

The description clearly states the tool's purpose: grounded multi-source research across Pipeworx's structured data sources. It uses specific verbs ('researches', 'decomposes', 'routes', 'returns') and distinguishes itself from siblings like ask_pipeworx by emphasizing it is NOT open-web search and handles broad/multi-part questions.

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

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

Provides explicit when-to-use guidance: 'For a single lookup use ask_pipeworx', 'For BREAKING or colloquial CURRENT-NEWS... prefer ask_pipeworx', and 'if you are not signed in, use ask_pipeworx instead'. Also gives example good use cases and explains depth options for different scenarios. This is comprehensive and actionable for an AI agent.

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

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

Annotations already indicate readOnly, idempotent, non-destructive. The description adds value by specifying the return format (top-N tools with schemas) and that results are ready to call directly, which is beyond the annotations.

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

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

The description is a single paragraph with a clear front-loaded purpose. It is concise and every sentence adds value, though it could be slightly more structured with bullet points.

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

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

Given the tool's complexity (6 params, 1 required, no output schema), the description fully explains its purpose, return value, and usage context. It even includes examples of queries and domains.

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 by stating the query parameter accepts natural language and listing aliases, as well as describing the limit default (20) and max (50). This adds meaningful usage guidance.

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

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

The description clearly states the tool's purpose: 'Find tools by describing the data or task.' It lists many specific domains (SEC filings, FDA drugs, etc.), distinguishing it from sibling tools that are task-specific.

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

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

The description advises to 'Call this FIRST when you have many tools available and want to see the option set,' providing clear context. It does not explicitly list when not to use, but the guidance is sufficient.

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 as read-only and idempotent. Description adds detail on data sources (SEC EDGAR, XBRL, USPTO, news, GLEIF), includes failure mode for patents (soft-fail), and mentions single parallel call. 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?

Front-loaded with query examples, each sentence adds value. No redundancy. Appropriate length for a 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?

Return fields are well described (cik, filings, fundamentals, patents, news, LEI) even without output schema. Missing edge cases like empty results, but complete enough for most uses.

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 that value accepts ticker or zero-padded CIK, and clarifies that names are not supported. Also notes that type only supports company.

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

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

Clearly states the tool returns a holistic profile for US public companies in one parallel call. Distinguishes from siblings by explicitly saying to prefer it over chaining single-pack lookups.

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

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

Explicitly says when to use (holistic view) and when not (names not supported, use resolve_entity). Also provides parameter examples for ticker or CIK.

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 destructiveHint and idempotentHint; description adds context about deleting agent-saved memories and pairing with other tools, providing 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, front-loaded with action, every sentence adds value. No wasted words.

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

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

With single parameter and no output schema, description fully covers purpose, usage context, and relationships to sibling tools.

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

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

Schema coverage is 100% and parameter description is clear. Description adds no new meaning beyond the schema, so baseline 3 is appropriate.

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

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

Description uses specific verb 'Delete' and resource 'previously stored memory by key', clearly distinguishing 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) and mentions pairing with siblings, but lacks explicit when-not-to-use scenarios.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint as true, and destructiveHint as false. The description adds behavioral detail beyond annotations: 'Fetches the page, extracts title/description/key links, and emits the standard llms.txt markdown format.' It does not contradict annotations and provides clarity on the fetch-and-generate process.

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 long, front-loaded with the main purpose, and every sentence adds value. No redundant or filler content. It is efficient and easy to parse.

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

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

Given the tool's simplicity (2 parameters, no output schema, no nested objects), the description provides all necessary context: input (URL), behavior (fetch & extract), output format ('standard llms.txt markdown format', 'single text blob ready to drop at site-root/llms.txt'), and use cases. Nothing missing.

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

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

Schema coverage is 100% for both parameters. The description adds value by providing examples for 'url' ('e.g. "https://example.com" or a specific landing page') and default/max values for 'max_links' ('default 25, max 50'). 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 verb 'generate' and the resource 'llms.txt file', with explicit scope 'for any URL'. It distinctively explains what it does: 'Fetches the page, extracts title/description/key links, and emits the standard llms.txt markdown format'. No sibling tool performs the same function, so it is well-differentiated.

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

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

The description lists concrete use cases: 'getting a client's site indexed by AI, drafting llms.txt for your own project, or auditing how an AI crawler would see a competitor.' It provides when to use but does not explicitly exclude scenarios or compare to alternatives, though no obvious alternatives exist among siblings.

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

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

Annotations already indicate read-only, non-destructive, idempotent behavior. Description adds return field details and user specificity, complementing annotations 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?

Two sentences, no redundancy, front-loaded with action and immediate value proposition. Every word 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?

Adequately covers purpose, usage, and return data for a simple list tool with good annotations. Lacks mention of pagination or ordering, but not critical given tool simplicity.

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

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

Schema coverage is 100% with parameter 'include_inactive' fully described. Description does not add parameter-level detail beyond schema, so baseline 3 is appropriate.

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

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

Clearly states it lists active subscriptions, specifies returned fields (id, type, params, etc.), and distinguishes from sibling tools subscribe/unsubscribe by its listing nature.

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

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

Provides explicit use cases: review before adding subscriptions or find id to cancel. While it doesn't mention when not to use, the guidance is practical and context-aware.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds value by detailing the rich return content (title, buyer, CPV codes, etc.) and mentions the PDF link and public URL, giving the agent a clear picture of what to expect beyond the annotations.

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

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

The description is a single, well-structured paragraph. It front-loads the action, follows with a comprehensive list of return contents, and ends with a usage hint. Every sentence adds necessary context without redundancy.

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

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

Given the tool is a simple fetcher with one parameter and no output schema, the description compensates fully by listing many return fields, specifying the platform (TenderNed) and scope (Dutch), and referencing sibling tools. It provides complete context for an agent to understand and use the tool.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning by explaining the parameter as a 'publication id', providing an example, and instructing the agent to use the id from sibling tools, which clarifies where the value originates.

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

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

The description clearly states the verb 'Fetch' and the resource 'Dutch public-procurement notice from TenderNed by its publication id'. It distinguishes from siblings by specifying that the id comes from nl_tender_search or nl_tender_recent, making the tool's specific role unambiguous.

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

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

The description explicitly says to use the id from nl_tender_search or nl_tender_recent results, providing clear context for when to invoke this tool. While it does not state negatives (e.g., when not to use), the guidance is direct and practical for an agent.

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

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

Annotations already cover read-only, idempotent, non-destructive behavior. Description adds that results are shaped and sorted newest-first, with specific output fields, providing useful behavioral context beyond annotations.

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

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

Single paragraph under 100 words, front-loaded with purpose, followed by optional filtering and output format. 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?

Given the complexity (4 optional params, no output schema), the description fully covers output fields, default behaviors, and pagination, making it complete for agent use.

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

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

All parameters have schema descriptions (100% coverage). Description adds default values (days=7, limit=10) and expands notice_type options with examples, going beyond 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?

Clearly states it lists the latest Dutch government tenders/contract awards from TenderNed in the last N days, and contrasts with sibling tools like nl_tender_search for broader querying.

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 frames it as a monitoring tool for new notices and provides filtering options, but does not directly state when not to use it or recommend sibling tools for 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds valuable context: it returns notices newest-first, structured fields (id, title, buyer, type, etc.), and explains full-text search scope. No contradictions with annotations.

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

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

Description is a single paragraph that efficiently conveys purpose, preference, search capabilities, and return fields. It is front-loaded with the key action and recommendation. Slightly dense but no wasted words.

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

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

For a search tool with no output schema, the description includes what fields are returned (id, title, buyer, etc.) and the default sort order. All 8 optional parameters are covered in the schema. The description is sufficient for an agent to use the tool correctly, though it could briefly mention pagination 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% with detailed descriptions for all 8 parameters. The tool description provides minimal extra meaning beyond the schema (e.g., 'Full-text search over title, buyer, and description' reinforces query semantics). Baseline 3 is appropriate as the schema already carries the burden.

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

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

Description clearly states it searches Dutch government public-procurement notices on TenderNed, specifying the platform, country, and types of notices. It distinguishes from generic web search by naming the specialized source, and the verb 'Search' with detailed scope sets a clear purpose.

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

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

Explicitly recommends this tool over web search for Dutch public tenders, listing specific notice types it covers. However, it does not mention sibling tools like nl_tender_detail or nl_tender_recent as alternatives or exclusions, leaving some ambiguity about when to use those instead.

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

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

Beyond all-false annotations, the description discloses critical behaviors: the dual-mode claim_token flow, rate limiting (5 per identifier per day), no quota count, and the instruction not to paste user prompts. It also explains what happens after filing (daily digests, roadmap impact), fully covering the behavioral context.

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

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

The description is long but front-loaded with the core purpose and every sentence carries useful information (exclusions, token flow, rate limits). It earns its length, though it could be tightened by removing peripheral details like team digest cadence.

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 and the tool's two modes (submit vs. claim_token query), the description is thorough: it covers what to include, how to check status, constraints, and alternatives. It leaves no major operational 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?

Although the schema already covers all parameters at 100%, the description enriches usage by explaining the claim_token round-trip ('Filing without an account returns a claim_token; pass it back later') and how to frame the message in terms of Pipeworx tools/packs, which is not in the schema.

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

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

The description opens with a specific, actionable purpose: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' This clearly identifies the resource (Pipeworx team) and the action (providing feedback), and distinguishes it from sibling tools like ask_pipeworx which are for questions.

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: bug, feature/data_gap, or praise. It also states a clear exclusion (only for Pipeworx connection tools, not other MCP servers) and provides a fallback 'Not sure?' heuristic for ambiguous cases.

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

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

Annotations already provide safety hints (readOnly, idempotent, non-destructive). The description adds critical behavioral context: data source (CF analytics-engine), privacy (no PII), and caching behavior (5min-1h), which annotations do not cover.

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

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

The description is efficient: one sentence stating purpose, followed by a compact bullet list of use cases. No redundant phrases, and the most important information (purpose and use cases) 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?

For a simple trending tool with rich annotations, the description covers purpose, usage, data source, caching, and parameter semantics. No output schema is needed given the tool's straightforward nature, and the description fully compensates for any missing structured info.

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

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

Schema coverage is 100% with one parameter fully described via enum. The description adds meaningful insight: 'Shorter windows surface what's hot right now; longer windows show steady-state demand,' enhancing the agent's understanding of parameter impact.

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, distinguishing it from siblings like discover_tools or ask_pipeworx. The verb 'returns' and specific resource 'trending data' make the purpose explicit.

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 three explicit, actionable use cases (discovering hot sources, confirming canonical tools, aligning use case with agent demand). While it doesn't explicitly state when not to use it, the context of sibling tools implies 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 mark the tool as read-only, idempotent, and non-destructive. The description adds significant behavioral context: Jaccard similarity filter, partition placeholder filter, fill check using CLOB depth, and detailed output structure. 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 thorough and front-loaded with the core purpose. However, it is somewhat lengthy (multiple paragraphs with detailed logic). While no sentence is wasted, a slightly more concise presentation could improve readability without losing content.

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

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

Given the tool's complexity (three modes, internal filters, output structure including fill check), the description is remarkably complete. It explains the output format (opportunities, partition_check, fill_check) and mentions sibling tools for custom sizing. No output schema exists, so the description compensates fully.

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

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

Schema coverage is 100% with both parameters described. The description enriches meaning by explaining expected formats (event slug, topic string), providing concrete examples, and detailing how each mode affects scanning scope and output.

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 finds arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It clearly distinguishes between three invocation modes (no args, event, topic) with specific use cases, and contrasts with sibling tools like polymarket_edges and polymarket_edge_tracker.

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

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

Provides explicit when-to-use guidance for each mode (no args for trending scan, event for specific market, topic for cross-event scanning). Recommends event mode for specificity. Also advises when not to trade (realizable_edge_pp ≤ 0) and references polymarket_fill_risk for custom sizing.

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

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

Annotations (readOnlyHint, idempotentHint) are consistent. Description adds rich behavioral detail: caching at KV level for 1h, response structure with diagnostics to explain empty segments, tradeable-edge filters, and specific calculation methodology (e.g., Kelly fractions, slippage). 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 lengthy but front-loaded with purpose. Uses informal bullet-like listing and parentheses to pack details. Could benefit from more structured formatting, but every sentence adds value given the tool's complexity. Minor redundancy (e.g., repeated mention of segments).

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 0 parameters required and no output schema, the description fully details input knobs, output structure (by_segment, fed_candidates, diagnostics), caching, and example usage. Covers all necessary aspects for correct invocation and interpretation of 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?

100% schema coverage ensures all parameters have descriptions. Description adds significant context beyond schema: explains tradeable-edge knobs (e.g., max_spread_pp, min_liquidity), distinguishes min_kelly vs min_partition_leg_kelly, and provides usage examples for slippage. Enhances parameter understanding.

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

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

The description clearly states the tool scans Polymarket markets for opportunities where Pipeworx data disagrees with market price, targeting the 'what should I bet on today' use case. It distinguishes itself from sibling tools by focusing on edge discovery without paging hundreds of markets.

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

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

Describes when to use: to discover opportunities without manual browsing. Provides detailed knobs and segments (e.g., model_driven, structural_arbitrage). However, lacks explicit when-not-to-use or comparison to siblings like polymarket_arbitrage, though context implies differentiation.

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

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

Annotations already provide readOnlyHint=true and destructiveHint=false. The description adds significant behavioral detail: response structure (tracked[], expired[], snapshot_dates[]), interpretation of trend and decay, limits (60-day TTL, daily closes), and edge semantics (signed by trade direction). This goes well beyond the annotations.

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

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

The description is detailed but well-structured with clear sections for response fields and limits. It is front-loaded with the core purpose. While lengthy, every sentence contributes necessary context.

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

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

Given two optional parameters and no output schema, the description thoroughly explains the return structure and limitations. It covers edge tracking, expiration, and data gaps, providing sufficient context for an AI to understand the tool's capabilities and constraints.

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

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

Schema coverage is 100%, so the schema already describes parameters well. The description adds context: default values (days=14, window='1wk'), clamp range for days (2-30), and explains what days and window mean in terms of lookback and snapshot family. This adds meaningful value.

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: 'Edge persistence and decay telemetry built from daily polymarket_edges snapshots.' It answers a specific question about edge age and shrinkage, distinguishing it from sibling tools like polymarket_edges and polymarket_arbitrage.

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

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

The description implies when to use this tool (e.g., 'a fresh wide edge and a 3-week-old wide edge are different trades'), but does not explicitly name alternatives or provide exclusion conditions. The context is clear enough for an AI to infer usage.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds substantial behavioral context: mode selection (market vs event), default parameter behaviors, return verdicts (clean|degraded|cannot_fill), and risk disclosure about forced directional risk and thin legs. 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 dense but well-structured with clear sections (SINGLE-MARKET, BASKET) and front-loaded purpose. Every sentence adds value, covering mode specifics, return fields, and risk warnings. However, it could be slightly more concise for faster scanning, but the detail is justified given the tool's complexity.

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

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

Despite lacking an output schema, the description explicitly lists all return fields for both modes, explains edge cases (thin legs, partial fills), and provides risk context (forced directional risk). It covers all critical aspects for correct usage, including parameter defaults and behavioral constraints.

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

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

Schema description coverage is 100%, but the description adds meaning beyond schema by explaining how parameters interact in each mode (e.g., size_usd interpreted as settlement notional for basket, side default auto from partition sum). It provides context for interpretation that the schema alone does not convey, such as 'capture overround' and 'max spend on buys, target proceeds on sells'.

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 realizable-vs-theoretical edge check against live CLOB order-book depth. It distinguishes between single-market and basket modes, lists specific return fields (top_of_book, vwap_fill_price, etc.), and differentiates from sibling tools like polymarket_arbitrage and polymarket_edges through explicit usage guidance.

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 THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500'. It also explains when not to rely solely on theoretical overround ('theoretical overround on thin books is not capturable') and warns about risks of partial fills converting arb into unhedged directional positions. This satisfies both positive and negative usage contexts.

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 extensively covers behavioral traits beyond annotations, including two operational modes, response structure (leg-by-leg prices, top spreads), safety fields (compatibility_warning, temporal_alignment, skipped_cross counters), and limitations. No contradiction with annotations (readOnly, openWorld, idempotent, non-destructive).

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 verbose. It is well-structured with clear sections (modes, response, safety fields), but could be slightly more concise. Every sentence earns its place given the tool's complexity.

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

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

Given no output schema, the description provides a comprehensive explanation of the response, including leg-by-leg prices, top spreads, and safety fields. It covers all user-facing aspects and possible edge cases (compatibility warnings, temporal alignment).

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

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

Schema coverage is 100% and each parameter is described. The description adds critical context: lists allowed topic values, explains that explicit tickers override topic mapping, and clarifies the interplay between parameters (e.g., topic with no tickers uses default mapping).

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 cross-venue spread calculator between Kalshi and Polymarket, distinguishing it from sibling tools by focusing on spread analysis. It specifies two modes (topic shortcuts and explicit tickers) and the outcome (leg-by-leg prices and spreads).

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

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

The description explicitly states when to use the tool (for cross-venue spread analysis) and provides detailed guidance on when not to use it, including conditions like compatibility warnings for non-equivalent bet shapes or temporal misalignment. It also differentiates between pre-mapped topics and custom pairings.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds scoping details (identifier-based) and pairing context, but could mention potential response size when listing keys.

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

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

The description is three sentences, front-loaded with purpose, and every sentence adds value. No redundant or filler content.

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

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

For a tool with one optional parameter, no output schema, and annotations covering safety, the description is complete. It explains scoping and pairing, though a note about typical responses (e.g., value string vs. list of keys) would improve it further.

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

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

Schema coverage is 100%, so the schema already documents the key parameter. The description adds no new syntax or format details beyond what the schema provides, meeting the baseline of 3.

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

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

The description uses specific verbs ('retrieve a value', 'list all saved keys') and clearly distinguishes the tool from sibling tools like 'remember' and 'forget'.

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

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

The description explicitly states when to use (look up context stored earlier) and when to omit the key (to list all keys). It also references complementary tools (remember, forget).

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 states that setting mark_read:true flags events as read, which modifies state (mutates the feed), but annotations declare readOnlyHint=true, indicating no state modification. This contradiction is harmful; score 1 per rules.

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

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

The description is front-loaded with the primary purpose, each sentence adds specific information (return structure, filtering options, mark_read behavior, alternative access). It is relatively concise at 5 sentences with no redundancy.

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

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

The description covers the return fields, filtering, and mark_read behavior. Despite the lack of an output schema, it gives enough context for an agent to understand the return structure. The only minor gap is no mention of the 'limit' parameter, but it's in the 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%, so baseline is 3. The description adds useful context for 'since' (ISO timestamp) and 'mark_read' (explains effect on subsequent calls), but does not mention 'limit' or 'unread_only', which are already well-described in the schema. Overall, it adds moderate 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 starts with 'Pull fired events from your subscription feed' which is a specific verb (pull) and resource (fired events from subscription feed). It clearly distinguishes from sibling tools like list_subscriptions (which lists subscriptions) by focusing on events from the feed.

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

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

The description explains how to filter by type and since, and how to use mark_read for read tracking. It mentions that polling works and provides an alternative endpoint for scripts, giving good context on when and how to use the tool, though it does not explicitly exclude 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?

Adds rich behavioral detail: fans out to SEC EDGAR, GDELT→GNews fallback (explains fallback logic and conditions), USPTO with sunset note. Returns structured changes[] grouped by source, total_changes count, citation URIs. 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?

Description is detailed but efficient; each sentence adds value (fallback logic, date format, return structure, sibling differentiation). Could be slightly tighter but 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?

Despite no output schema, describes return structure (changes grouped by source, total_changes count, citation URIs). Covers error/fallback scenarios (GDELT→GNews, USPTO soft-fail). Complete for a multi-source change feed tool with 3 required parameters.

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

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

Schema coverage is 100%, and description reinforces param meaning: suggests typical monitoring values for `since` ("30d", "1m"), explains `value` accepts ticker or zero-padded CIK. Adds usage suggestions beyond schema.

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

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

Description starts with common user queries and states 'change feed for a company in the last N days/weeks/months in ONE parallel call.' It clearly specifies the verb (get change feed), resource (company recent changes), and explicitly distinguishes from sibling tool 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?

Explicitly advises 'Use entity_profile instead when you want the static profile...' and implies usage for 'what's new' queries. Lacks broader alternatives among the many siblings, but context is clear.

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

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

Annotations already indicate idempotency and non-destructiveness. Description adds valuable behavioral details: key-value scoping by identifier, persistent storage for authenticated users, 24-hour retention for anonymous sessions. 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?

Five sentences, each serving a distinct purpose: purpose, usage trigger, mechanism, persistence details, and pairing with siblings. No wasted words, 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?

No output schema, but the description implicitly defines return by mentioning pairing with recall. Tool complexity low; description covers key aspects. Slight gap: does not describe success/error response, but acceptable given 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 provides 100% coverage with good descriptions of key and value. Description reinforces usage with examples but does not add new constraints or semantics beyond the schema. Baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Save data the agent will need to reuse later' with specific examples of when to use it (resolved ticker, target address, user preference). It explicitly pairs with sibling tools recall and forget, distinguishing its role.

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

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

Provides explicit when to use ('discover something worth carrying forward') and contrasts with alternatives: 'Pair with recall to retrieve later, forget to delete.' Also mentions scoping and persistence difference between authenticated and anonymous sessions, guiding correct usage.

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

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

Annotations declare readOnly, idempotent, and non-destructive, but the description adds substantial behavior: graceful degradation when GLEIF/OpenFIGI are unavailable, explicit listing of unresolved identifiers, source-labelled results, and internal cascading lookups. This goes far beyond the annotations and provides genuine transparency.

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

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

The description is a single dense run-on paragraph with embedded parentheticals and many asides, making it hard to scan. It is information-heavy but lacks bullet points or clear structure, so it is not concise.

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

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

With no output schema, the description still conveys key return characteristics: source labels, explicit unresolved list, and drug fields (RxCUI + ingredient + brand + citation). It covers fallback behavior and accepted input types well, with only minor omissions around error cases or pagination.

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

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

The input schema already covers both parameters with descriptions (100% coverage), but the description adds meaning beyond the schema: ISIN input support, LEI ownership details, RxNorm citation format, and the behavior of unresolved identifiers. This enriches the semantics beyond the schema's simple 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 states the tool resolves a user-spoken NAME to canonical/official identifiers, with explicit examples ('What's the ticker for…', 'find the CIK for…'). It distinguishes itself as the first step when an ID is needed, differentiating it from sibling tools that consume IDs.

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 FIRST whenever you have a name but need an ID' and notes that it replaces 2–3 manual lookups. It gives clear context for when to use the tool, though it does not explicitly name alternatives or state when not to use it.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint, so behavioral safety is covered. The description adds transparency by stating it 'probes each entity with ai_visibility_check' and returns a ranked list with score, confidence, signal density. This informs the agent of the sub-tool dependency and output format 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 two sentences long, front-loads the core action, and contains no filler. Every phrase earns its place, achieving high density of useful information.

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

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

Given the tool has 4 parameters (1 required), no output schema, and no nested objects, the description is complete. It describes input (entities, models, etc.), process (probes each, ranks), and output (ranked list with score, confidence, signal density). The annotations cover safety, and no further detail is needed.

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

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

Schema coverage is 100%, with clear descriptions for all 4 parameters. The description adds one piece of semantic value: the first entity in the array is treated as the 'subject' for narrative purposes, which is not in the schema. This enhances the agent's understanding of parameter usage.

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

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

The description clearly states the tool compares AI visibility across multiple entities side-by-side, using specific verbs like 'compare', 'probes', 'ranks', and 'surfaces'. It distinguishes from sibling tool 'ai_visibility_check' which likely operates on a single entity, and 'compare_entities' which is more generic. The example query solidifies the purpose.

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

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

The description provides explicit use context: 'competitive AI-marketing audits' and an example. It implies when to use (multi-entity comparison vs. single check) but does not explicitly state when not to use or name alternatives beyond sibling tools. The note about first entity as 'subject' for narrative adds clarity.

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

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

Description adds significant behavioral context beyond annotations: fans out to external services, partial failures degrade gracefully, bundlephobia first measurement can take 5-30s, and sources_failed list. Aligns with annotations (readOnly, idempotent, openWorld).

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

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

Description is detailed but well-structured, front-loading purpose and breaking down capabilities. Some redundancy (e.g., mentions npm ecosystem twice) but overall concise for the complexity.

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

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

Given no output schema, description fully covers return data (summary block, per-advisory detail, links, alternatives) and behavior (partial failures, timing). Sufficient for agent to understand expected output and edge cases.

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

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

Schema coverage is 100%, so baseline 3. Description does not add meaning beyond schema: 'package' is npm package name, 'version' defaults to latest. No additional semantics provided.

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

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

The description clearly states it is a composite check for npm packages using deps.dev and bundlephobia, addressing questions about safety, popularity, and size. It distinguishes from sibling tools, which are unrelated (e.g., AI visibility, poly market).

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

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

Explicitly states when to use: when an agent asks about safety, popularity, size, or cost of adding an npm package. Notes NPM ecosystem limitation and fallback for other ecosystems. Lacks explicit when-not-to-use but provides clear context.

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

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

Annotations already show readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds valuable behavioral details: BGE-base-en embeddings, cosine similarity, 500-char overlapping windows, 200K char limit with truncation flag. No contradictions.

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

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

Two sentences, logically organized: what it does, when to use, technical details, pairings. No fluff, every sentence adds value.

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

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

No output schema, but description explains return format (top-N passages with offsets and similarity scores). Also covers embedding model, windowing, and char limit. Complete for a tool with 3 params.

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 enriches each parameter: 'text' is 'document text you already pulled', 'query' is 'natural-language query' with examples, 'limit' max passages. Adds context beyond schema definitions.

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

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

Description clearly states 'Semantic search INSIDE a fetched record' with specific verb (search) and resource (text). It distinguishes from siblings by mentioning pairing with ask_pipeworx_grounded and using context-saving approach.

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

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

Explicitly says 'Use when the record is too big to cram into the prompt' and provides alternatives (pair with ask_pipeworx_grounded). Also mentions the 200K char cap and truncation behavior.

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

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

The description adds substantial behavioral context beyond annotations: it explains the creation of a persistent subscription, authentication requirements, rate limits (10 SMS/day), and webhook auto-disable after 10 failures. It aligns with annotations (non-readOnly, idempotent) and does not contradict them.

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

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

The description is detailed but front-loaded with the main purpose. While it is longer than necessary, every sentence adds value. It could be slightly more concise but remains well-structured.

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

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

Given the tool's complexity (3 params, nested objects, multiple types) and no output schema, the description covers creation behavior, authentication, type specifics, and delivery constraints. It lacks error handling details but is largely 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%, but the description enriches each parameter with examples, type-specific details, and delivery channel behaviors. It goes beyond the schema to explain how to use the 'params' and 'delivery' objects.

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 'Create a proactive monitoring subscription to a live-data event stream.' and specifies the return of a subscription id. It uniquely identifies the tool's purpose among siblings like 'list_subscriptions' and 'unsubscribe'.

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

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

The description mentions prerequisites (Pipeworx OAuth account), supported types and their parameters, and delivery channel options. It provides context for when to use the tool but does not explicitly state when not to use it or compare to alternatives.

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

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

Annotations already declare readOnlyHint, openWorldHint, etc. The description adds that it returns executable suggestions with tool+argument shapes, and that calling with no arguments gives full spread. Some behavioral details (e.g., caching or live nature) are not mentioned, but overall 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?

The description is informative but slightly long with many examples. Front-loaded with common user queries, but could be more concise. Still, every sentence adds value.

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

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

For a tool with no required params and no output schema, the description fully explains what it does, when to use it, and what to expect (category-bucketed examples with tool shapes). Complete and self-sufficient.

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

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

Schema has 100% coverage for the single parameter. Description expands by listing possible topic values and explaining omission behavior ('omit for cross-category spread'), adding meaningful context beyond the schema.

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

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

The description clearly states the tool returns category-bucketed example questions for Pipeworx, with optional topic filtering. It distinguishes itself from sibling tools like ask_pipeworx by being the onboarding entry point.

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

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

Explicitly says 'Use this FIRST when you do not yet know what Pipeworx can do for you' and explains how to call meta-tools. Provides clear when-to-use 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?

Disclosures beyond annotations: ownership enforcement, row deactivation (not deletion), and historical data preservation. No contradiction with annotations (readOnlyHint=false, destructiveHint=false, idempotentHint=true).

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

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

Two focused sentences: first states the core action, second adds important constraints and side effects. 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 parameter and no output schema, the description covers the operation, ownership, effect on data, and connection to another tool ('subscribe'). Complete and sufficient.

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

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

Schema coverage is 100% with a clear parameter description. The description adds that the id comes from 'subscribe', providing useful context beyond the schema's 'Subscription id (uuid)'.

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

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

The description clearly states the action ('Cancel a subscription by id') and distinguishes it from siblings like 'subscribe' and 'list_subscriptions' by specifying the primary operation and effect.

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 usage context ('Ownership is enforced — you can only cancel your own subscriptions') and explains the effect ('deactivated, not deleted'), but does not explicitly mention when to use vs. alternatives such as 'list_subscriptions' for finding IDs.

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

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

The description goes far beyond the readOnlyHint/idempotentHint annotations by disclosing the internal routing (SEC EDGAR vs. grounded pipeline), the exact verdict return set, the meaning of 'could_not_verify' (including that it must not be shown as evidence), and the meaning of 'unsupported'. It also reveals edge-case behavior with verification_error{stage,detail}. 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 lengthy but densely packed with necessary information. It front-loads with natural-language trigger phrases, then progressively covers usage, routing, output, and caveats. Every sentence adds value—even the final 'Replaces 4–6 sequential calls' communicates efficiency. No filler.

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

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

With no output schema, the description must explain return values, and it does: the verdict enums, the grounded/structured value with citation, and reasoning. It also covers error semantics and routing, making the tool fully understandable without further lookup. This is a complete picture for a complex NLP-based tool.

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

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

The input schema already describes both parameters with 100% coverage. The tool description adds crucial usage nuance for tolerance_pct—explaining that it overrides the wording-implied tolerance, with a default capped at 5, and suggesting 1–2 for hallucination detection. The claim param is also exemplifed in the schema, so semantics are fully fleshed out.

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 explicit natural-language triggers and states the tool's core function: 'natural-language claim verification against authoritative sources.' It also distinguishes from sibling tools by noting it replaces 4–6 sequential calls, making it a dedicated claim-checking tool rather than a generic research or ask tool.

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

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

The description explicitly states when to use: 'Use whenever the agent needs to check whether something a user said is factually correct.' It also explains the routing logic for financial vs. other claims, giving clear context. However, it does not explicitly name alternative tools for when not to use this one.

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