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?

The description is consistent with the annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false) and adds useful context about routing and citation URIs without implying any side effects. It clearly indicates a non-destructive, read-only 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 somewhat lengthy and contains some repetition (e.g., the routing phrase appears twice), but it is well-structured with clear guidance, examples, and escalation options. It is informative without being overly verbose, though it could be trimmed for conciseness.

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

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

The description provides comprehensive context: domain coverage, examples, alternative tools, tier/account notes, and mention of return format (structured answers with citation URIs). It gives the agent all necessary information to decide when and how to invoke 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?

The schema already covers all parameters with descriptions, including aliases, achieving 100% coverage. The tool description does not add additional parameter semantics beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose as a question-answering endpoint that routes queries across numerous data sources and returns structured answers with citations. It explicitly contrasts with web search and provides domain examples, making the purpose unambiguous.

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

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

It explicitly instructs to prefer this tool over web search for factual queries and provides clear escalation paths to ask_pipeworx_grounded for hallucination-resistant answers and deep_research for multi-part questions. This gives concrete guidance on when to use this tool versus alternatives.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so safety is covered. The description adds valuable behavioral context: the beta nature, the fact that routing improvements are enabled live when under test, that none is active right now, and that it matches ask_pipeworx exactly currently. It also clarifies it is not a fallback but a full working router. This goes beyond annotations without contradicting them.

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

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

The description is front-loaded with the key identity (beta, identical to ask_pipeworx) and current state, then gives usage guidance and clarifies a potential misconception. Every sentence earns its place, and it's concise for a tool of this complexity. No waste.

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

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

For a router with 5,801 tools, the description is remarkably complete. It specifies the relationship to ask_pipeworx, the experimental nature, current state, usage instructions, and that the response shape matches ask_pipeworx. The lack of output schema is mitigated by the explicit 'same response shape' statement. Nothing critical is missing.

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

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

Schema description coverage is 100%, with all six parameters being aliases for 'question'. The description doesn't add parameter-specific details, but none are needed since the schema fully documents them. The mention of 'same arguments' is contextual and doesn't add semantics beyond the schema. Baseline 3 is appropriate for high schema coverage.

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

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

The description explicitly states it is a beta version of ask_pipeworx, an identical universal router with the same 5,801 tools, arguments, and response shape. It clearly distinguishes itself from the stable ask_pipeworx by being the experimental edge with candidate routing improvements. The purpose is specific and well-differentiated from siblings.

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

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

It explicitly instructs to 'Use it exactly like ask_pipeworx when you want the newest routing' and explains that results are compared against the stable router. It also clarifies the current state (no active candidate) and that it is a full working router, not a fallback. This gives clear when-to-use and why, with implicit contrast to the stable sibling.

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

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

Beyond the annotations (readOnly, openWorld, idempotent), the description discloses the additional LLM call cost and the explicit refusal mechanism with specific refusal_reason values. This is important behavioral information not present in 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 slightly verbose but well-structured, leading with the core purpose, then the mechanism, return format, and usage guidance. The repetition of 'ask_pipeworx' is functional for comparison, though it adds some length.

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

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

Given the simple parameter set and no output schema, the description provides a complete picture: behavior, return shape, refusal reasons, cost, and comparison to the alternative. Nothing essential is missing.

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

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

The input schema already fully documents all six parameters as aliases for a single question string (100% coverage). The description adds no further parameter-specific detail, so the score stays at 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 clearly states the tool is a hallucination-resistant answer mode that extracts answers only from tool results, with explicit mention of evidence and refusal behavior. It differentiates itself from the sibling ask_pipeworx tool by its grounding guarantee.

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

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

It explicitly states when to use this tool—when the answer will be quoted, cited, or acted on and facts must not be invented—and when to prefer ask_pipeworx for casual lookups, due to the extra LLM call cost. This provides clear selection criteria.

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

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

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?

The description thoroughly discloses behavior: decomposition into facets, parallel routing to 5,801 tools, return of findings with 'veritable evidence + confidence + source + fetched_at + a stable pipeworx:// citation', handling of gaps ('gaps[]'), contradiction detection ('contradictions[]'), semantic excerpting, and expected latency. None of this contradicts the annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false).

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

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

Although long, every sentence adds distinct value—purpose, usage, depth semantics, citation guarantee, gap handling, contradiction scanning, latency. The structure is front-loaded with purpose and usage, then proceeds logically to parameters, edge cases, and expectations. No filler or redundant clauses.

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

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

Given there is no output schema, the description adequately covers the return format (findings packet with evidence, confidence, source, fetched_at, citation_uri, hop, contradictions), error/edge behavior (gaps, empty results for news topics), and performance expectations (15-60s, up to 90s for thorough). It also explains the citation resolvability guarantee.

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% (question and depth). The description elaborates on both: question is 'The research question, in natural language. Broad/multi-part is fine' and depth is fully explained with enum meanings including the default and paid tier ('standard=3 (default; adds a gap-recovery hop... thorough=6 (paid; adds a full iterative hop...)').

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 exact purpose: 'Grounded multi-source research across Pipeworx's 1517 STRUCTURED data sources' and clearly distinguishes it from ask_pipeworx ('For a single lookup use ask_pipeworx'). It also specifies the scope of use cases ('Best for broad/multi-part questions over structured data') and what it returns ('findings packet').

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

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

Explicit when-to-use and when-not-to-use guidance is given: 'Best for broad/multi-part questions over structured data' and 'For BREAKING or colloquial CURRENT-NEWS... prefer ask_pipeworx'. It also explains the depth parameter options and their behavioral implications, such as 'standard adds a gap-recovery hop' and 'thorough additionally chases the best leads'.

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?

Goes far beyond the readOnly/openWorld/idempotent annotations: it discloses the fan-out across eight source families, the meaning of sources_used/sources_failed ('an empty section is a real "no data", not a bug'), soft-fail behavior for the USPTO patents endpoint, expected-empty fda_products for small-molecule-only companies, the GDELT→GNews fallback, and the resolved:false + notes path for private companies. 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?

Front-loaded and information-dense: trigger phrases and core function lead, followed by the preference rule, source list, return layout, then failure semantics. It is one long run-on paragraph and mildly repeats the type-interchangeability fact already in the schema, so it is not a 5, but no sentence is wasted for a tool of this complexity.

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

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

With no output schema, the description shoulders the return-format burden and succeeds: it specifies cik, company_name, resolved fields, recent_filings with pipeworx:// URI format, fundamentals fields, and every per-source section (patents, federal_contracts, fda_products, hiring, news, LEI). Failure modes and empty-result semantics are covered per source, leaving nothing an agent needs to invoke it correctly.

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

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

Schema coverage is 100% with detailed descriptions of both params, so the baseline is 3. The description adds concrete examples ('AAPL', '0000320193', 'Moderna'), the SEC EDGAR name-resolution mechanism, and edge-case behavior (resolved_from/resolved_to when value was a name, private-company notes), which meaningfully enriches the semantics beyond the schema.

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

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

The description states a specific verb and resource: 'full cross-source profile of a US public company in ONE parallel call,' and reinforces it with seven realistic trigger-phrase examples ('Tell me about X', 'company profile for Microsoft', 'give me the rundown on NVDA'). The scope (US public company, cross-source, single call) clearly distinguishes it from single-source lookups, though it does not name sibling tools like compare_entities explicitly.

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?

Gives an explicit preference rule: 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view,' which states both the condition and the alternative pattern. It also implies exclusions — private companies resolve to false with notes, and 'person/place coming soon' marks the tool as company-only. However, it never names concrete sibling tools (resolve_entity, compare_entities, deep_research), so routing among visible siblings is left partly to inference.

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?

Even though annotations already mark the tool readOnly, openWorld, idempotent, and non-destructive, the description goes well beyond them. It discloses matching limitations, non-empty compatibility warnings on returned pairs, gross-vs-net fee treatment, skipped comparison counters, and the precise meaning of null temporal_alignment fields, which materially shapes agent expectations.

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

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

The description is long and dense, but it front-loads the core purpose and the two modes before diving into safety fields and edge-case semantics. Almost every sentence contributes operational or interpretive value, though bullet points or clearer paragraph breaks would improve scannability.

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

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

With no output schema, the description carries the full burden of explaining return structure and interpretation. It names leg-by-leg prices, top_spreads_pp, compatibility_codes, skipped_unclassified, low_confidence_pairs, temporal_alignment, fees_note, and the skipped comparison counters, leaving no critical behavioral gap for an agent selecting and invoking 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?

All three parameters already have schema descriptions (100% coverage). The description adds mode-level meaning: topic auto-fetches the matching event, the explicit kalshi_event_ticker and polymarket_event_slug override the mapped side, and both modes produce identical safety disclosures. This supplements the schema without repeating it.

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 'Cross-venue spread between Kalshi and Polymarket for the same resolving question', which states a specific resource and measurement in one sentence. It also names two distinct operational modes and makes the tool's scope clear relative to single-venue or general arbitrage siblings by emphasizing the Kalshi–Polymarket pairing.

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

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

The description gives clear context for when to use each mode: topic shortcuts for pre-mapped macro events and explicit ticker/slug for custom pairings, noting both modes run the identical matcher. It cautions that pre-mapped topics are not necessarily tradeable and that most return compatibility warnings, but it does not explicitly contrast this tool with sibling alternatives like polymarket_arbitrage.

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 already declare readOnly/idempotent/non-destructive, and the description adds substantial behavioral context: it cascades through multiple lookup endpoints, 'LEI/FIGI enrichment degrades gracefully' when upstream sources are unavailable, and unresolved identifiers are 'stated explicitly under unresolved rather than omitted.' This goes well beyond annotation defaults.

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 content is valuable but delivered as one long, nested paragraph with multiple parentheticals and semicolons, making it difficult to scan. It front-loads examples but fails the 'appropriately sized' test; it should be split by supported type or formatted as bullets.

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

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

For a tool with no output schema, the description fully covers return values for both types (EDGAR identifiers, LEI/ownership, FIGI, RxCUI, ingredient, brand, citation), input formats, fallback behavior, and unresolved-id handling. No critical call-time information is missing.

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

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

The input schema already documents that value accepts ticker/CIK/name for company and brand/generic for drug. The description adds meaning beyond the schema by covering ISIN input, exact-ticker vs name-search resolution, and why non-equity instruments resolve here. It could have been more clearly tied to the two parameters, but it is genuinely additive.

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

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

The description opens with concrete user-phrase examples, then states the core function: 'resolve a user-spoken NAME to the canonical/official identifiers other tools require as input.' This is a specific verb+resource and differentiates resolve_entity from siblings like entity_profile or compare_entities by positioning it as the name-to-ID 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?

It gives an explicit trigger rule — 'Use FIRST whenever you have a name but need an ID' — and explains that other tools require these IDs as input. It stops short of naming alternative tools or stating when not to use it, so it lacks the explicit exclusions of a 5.

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

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

Annotations already declare readOnlyHint, 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.