Asub Ax

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds critical details: returns per-model {score, confidence, signals, raw_response} plus combined view, pricing model (free vs BYO key for Anthropic), and the scoring range 0-100. This goes well 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 plus a brief list of use cases. Front-loaded with the core action, no filler. Every sentence adds value. Highly efficient.

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

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

Given the tool has 4 parameters, no output schema, and no nested objects, the description is remarkably complete. It covers purpose, input parameters, default behavior, optional customization, return format, and use cases, leaving no significant gaps.

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

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

Schema coverage is 100%, so baseline is 3. The description adds context beyond the schema: it names the default model ('Workers AI Llama-3.3-70b'), clarifies the API key purpose ('BYO key — you pay directly'), and explains the return structure. This extra guidance justifies a 4.

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

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

The description clearly states the tool probes LLMs for awareness of a business/brand/product/topic and returns a visibility score (0-100) per model. It distinguishes itself from sibling tools like 'entity_profile' and 'deep_research' by focusing specifically on AI visibility, not general research or entity details.

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

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

The description lists use cases (AI-marketing audits, pre-launch brand checks, competitive monitoring), implying when to use the tool. It also explains the default free model and how to add a paid model via API key, but does not explicitly contrast with alternative tools or state when not to use it.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so safety profile is covered. The description adds valuable behavioral context: it routes to 5,439 tools, fills arguments, returns stable pipeworx:// citation URIs, and works on every tier in one fast call. No contradiction. Slightly misses detail on failure modes or rate limits, but strong for annotation-rich 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 dense but well-structured: starts with the primary instruction ('PREFER OVER WEB SEARCH'), scope, mechanics, usage triggers, examples, and escalation path. It is longer than typical but every sentence earns its place with concrete information. Minor redundancy in listing many triggers/examples, but justified for adoption.

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 broad scope and no output schema, the description compensates well by explaining what kinds of questions to ask, what happens internally (routing, argument-filling, citations), and how it relates to siblings. It doesn't detail return format, but the examples and citation mention provide a clear picture. Slight gap: no mention of failure/edge cases, but acceptable for a query router.

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

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

Schema coverage is 100%: all six parameters are aliases for the single natural-language question parameter. The description adds example queries and clarifies accepted aliases, which is useful but the schema already documented this. No new parameter-specific semantics; baseline 3 is appropriate.

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

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

The description uses a specific verb ('ask', 'routes', 'returns') and resource ('Pipeworx', 5,439 tools across 1,412 sources) with clear scope: factual questions about current/historical data. It strongly distinguishes itself from siblings by explicitly naming ask_pipeworx_grounded and deep_research as alternatives, and by contrasting with web search.

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: 'PREFER OVER WEB SEARCH', 'START HERE for most questions', and when to step up to alternatives (ask_pipeworx_grounded for hallucination-resistant single answers, deep_research for broad/multi-part). Also lists triggers ('what is', 'look up', 'find') and examples, plus exclusion for breaking news/opinion.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, etc.), the description adds behavioral context about the experimental nature: candidate routing improvements are enabled live, currently none active, and it 'falls back to nothing' while being a full working router. This helps set expectations about variability.

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

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

The description is concise and front-loaded with the core beta identity, then explains current status and usage in a few sentences. It includes specific details (tool count, date) without unnecessary fluff, though slightly longer than strictly needed.

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 (universal router) and no output schema, the description adequately covers what it is, its current operational state, how to use it, and what happens with results. It fully addresses the experimental context and relationship to the stable version, making it complete for selection and invocation.

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

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

Schema coverage is 100% with descriptions for each alias and the main 'question' parameter. The description only says 'same arguments' as ask_pipeworx, which doesn't add significant meaning beyond the schema, matching the baseline.

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

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

The description clearly identifies the tool as a beta version of ask_pipeworx, a universal router with the same 5,439 tools, arguments, and response shape. It distinguishes from siblings by explicitly positioning it as the experimental edge versus the stable ask_pipeworx and the grounded variant.

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

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

Provides explicit guidance: 'Use it exactly like ask_pipeworx when you want the newest routing' and explains that results are compared against the stable router to decide merges. Also clarifies current state (no active candidate, so identical to stable), giving clear context for when to use it.

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

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

Annotations already declare read-only/idempotent, but the description adds rich behavioral detail: refunded refusal reasons (not_in_source, no_tool_match, tool_error, data_truncated, llm_error), guarantee to only use tool output, and the cost of one extra LLM call. This exceeds what annotations convey and helps the agent anticipate 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 compact and dense, covering purpose, behavior, output format, refusal reasons, and cost tradeoff in about 150 words. Each sentence contributes distinct value with no filler, though the length is near the upper bound of ideal conciseness for a tool description.

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

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

All necessary context is present: success/failure return shapes, specific refusal reasons, use-case guidance, and cost implications. Since there is no output schema, the description fully substitutes it by detailing the response structure, making it complete for an agent to invoke correctly.

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

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

The schema describes all six parameters with 100% coverage, including the primary 'question' parameter and its five aliases. The description adds no additional parameter semantics, so it correctly relies on the schema; baseline 3 is appropriate.

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

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

The description clearly identifies this as a hallucination-resistant answer mode that routes like ask_pipeworx but extracts answers solely from tool results with explicit refusals. It distinguishes itself from the sibling ask_pipeworx by emphasizing evidence and refusal structure, making the tool's unique value obvious.

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

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

Explicit when-to-use guidance is provided: 'Use whenever an answer will be quoted, cited, or acted on' and recommends preferring ask_pipeworx for casual lookups due to the extra LLM cost. It names the alternative (ask_pipeworx) and provides clear conditions for choosing this tool.

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

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

Annotations (readOnlyHint, idempotentHint, openWorldHint) are complemented by extensive behavioral details: resolver contract with confidence levels, parent event extractor, news fallback fields, safety short-circuits, spread warnings, and cancellation rule parsing. No contradictions with annotations.

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

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

The description is very long and verbose, mixing multiple details in prose. While informative, it lacks conciseness and could benefit from structured formatting. Key information is front-loaded but overall density is high.

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

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

Given no output schema, the description provides comprehensive response shape details (market, analysis, evidence fields), resolver contract, parent event, news fields, safety mechanisms, and cancellation rules, ensuring agents understand all outputs.

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%, baseline 3. Description adds value by explaining market input flexibility, depth enum behavior, and include_raw param usage context (e.g., when to pass true for full payloads).

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 researches a Polymarket bet by pulling Pipeworx data in one call, specifying input types (slug, URL, question text) and listing classifiers and fan-out examples. It distinguishes itself from sibling tools like polymarket_arbitrage or polymarket_edges by focusing on comprehensive data gathering for a single bet.

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 use cases ('Use for ...'), provides examples, and describes safety checks and blocking conditions. However, it lacks explicit when-not-to-use guidance, though it is implied given the context and 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?

Beyond annotations (readOnly, openWorld, idempotent, non-destructive), the description discloses specific data sources (SEC EDGAR/XBRL, FAERS), handling of off-calendar fiscal years, sorting by primary metric, and citation URI returns, adding substantial 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 front-loaded with trigger phrases and every sentence adds value, but it is relatively long. However, it remains efficient for the complexity of the tool.

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

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

The description covers return values (paired data, citation URIs) and sorting, but lacks explicit structure of the returned data. Given the tool's simplicity and lack of output schema, it is nearly 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%, and description adds significant value by detailing what data each 'type' value pulls (company: financial metrics; drug: adverse-event counts) and providing concrete examples for 'values' (tickers/CIKs, drug names).

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 explicit trigger phrases like 'Compare X and Y' and clearly states it performs side-by-side comparison of 2-5 companies or drugs in one parallel call, differentiating it from sequential lookups and sibling tools like entity_profile.

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

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

The description explicitly states 'ALWAYS PREFER over sequential single-pack lookups when comparing entities,' providing clear when-to-use and when-not-to-use guidance, with implied 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 readOnly, openWorld, and idempotent hints, and the description adds rich behavioral context beyond that: parallel decomposition, gaps[] never invented, hop field, contradictions[] scan, semantic excerpting, latency expectations, and account-tier limitations. This significantly exceeds what annotations alone provide.

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

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

The description is long but information-dense, covering prerequisites, alternatives, behavioral nuances, depth semantics, and output characteristics. It's front-loaded with the critical account requirement and main purpose. Minor deduction for density that could overwhelm an agent, but every sentence conveys a useful distinction.

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 (depth levels, parallel routing, gap recovery, contradictions, citations, latency), the description is remarkably complete without an output schema. It explains return values (findings packet, gaps[], contradictions[], hop field, citation_uri), failure modes (empty gaps[] for non-catalog topics), and edge cases (large records excerpted semantically). No significant gaps identified.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaningful context beyond schema by explaining what 'depth' levels actually do (gap recovery, contradiction pass, hop iteration) and that 'question' accepts broad/multi-part natural language. Slight deduction because the description doesn't detail the exact format of the findings packet beyond what's mentioned.

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

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

The description clearly states it performs 'Grounded multi-source research across Pipeworx's 1412 STRUCTURED data sources' in one call, decomposing questions into facets and routing to 5,439 tools in parallel. This specific verb+resource+scope distinguishes it from siblings like ask_pipeworx, which is explicitly contrasted.

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 and when-not-to-use guidance: 'Best for broad/multi-part questions over structured data' and 'For a single lookup use ask_pipeworx' and for breaking/current news topics prefer ask_pipeworx. Also covers depth-level choice and account requirements, giving clear context for 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 declare readOnlyHint, idempotentHint, and destructiveHint correctly. The description adds value by explaining that it returns the top-N most relevant tools with full schemas and curated examples, ready to call directly, which is beyond what annotations provide.

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

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

The description is well-structured, front-loaded with purpose, and provides examples. While it is slightly long, every sentence adds value and no space is wasted.

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

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

Given no output schema, the description adequately explains what is returned (top-N tools with names, descriptions, full schemas, curated examples) and assures no second lookup is needed. This is complete for a discovery tool.

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

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

Schema coverage is 100%, so the schema documents all parameters. The description adds value by providing example queries and noting that 'query' accepts multiple aliases (task, q, search, description), which helps agents understand flexibility.

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

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

The description uses specific verbs like 'find', 'browse', 'search', 'look up', and 'discover' to describe the tool's purpose, and explicitly lists domains (SEC filings, financials, etc.) and returns ready-to-call tools. It clearly differentiates from siblings by stating it is for discovering tools, not for executing a specific answer.

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 'Call this FIRST when you have many tools available and want to see the option set (not just one answer)', providing clear when-to-use guidance and implying that if you already know the tool, you should skip this.

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: lists all data sources (SEC EDGAR, XBRL, USPTO, news, GLEIF), specifies soft-fail for patents, and details return fields. No contradictions with annotations.

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

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

The description is thorough and front-loaded with examples, but it is relatively long. Every sentence adds value, though some minor redundancy exists (e.g., repeating 'use resolve_entity first'). Overall well-structured.

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

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

Despite no output schema, the description fully explains all return fields (cik, company_name, recent_filings with URIs, fundamentals, patents, news, LEI). This is sufficient for the agent to understand what to expect. No gaps.

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

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

Schema coverage is 100%, and both parameters are described in the schema. The description reinforces with examples (e.g., 'AAPL' or '0000320193') and adds the important constraint that names are not supported. Baseline 3, but additional context merits 4.

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

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

The description clearly states the tool's purpose: 'full cross-source profile of a US public company'. It provides multiple example queries ('Tell me about X', 'research Acme', etc.) and distinguishes itself from siblings like resolve_entity, which is listed separately.

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 to 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view'. Also clearly states to use resolve_entity first if only a name is available, providing a specific alternative.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false. The description reinforces this by stating 'delete' and adds nuanced behavioral context about clearing 'stale' or 'sensitive' data, providing extra 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 concise sentences front-load purpose and usage, with zero fluff. Every word 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 simple single-parameter deletion tool with no output schema, the description covers purpose, usage context, and sibling relationships completely.

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 description of the 'key' parameter. The tool description mentions 'by key' but does not add new semantic information beyond the schema, meeting the baseline.

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

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

The description uses a specific verb and resource: 'Delete a previously stored memory by key.' It clearly distinguishes from sibling tools 'remember' and 'recall' by explicitly mentioning them, establishing its role as the deletion counterpart.

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 contexts for use ('when context is stale, the task is done, or you want to clear sensitive data') and instructs to pair with 'remember' and 'recall', effectively guiding the agent on when and with what to use this tool.

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

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

The description discloses the full behavior: fetches page, extracts title/description/key links, emits standard markdown. Annotations already indicate read-only, idempotent, non-destructive. The description adds value beyond annotations by describing the extraction and output process. No contradictions.

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

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

The description is concise (four sentences), front-loaded with purpose, and every sentence adds information. No filler or irrelevant details.

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 params, no output schema, strong annotations), the description covers the expected behavior, output format, and use cases. It is complete enough for an AI agent to use the tool correctly.

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

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

Schema description coverage is 100%; both parameters ('url' and 'max_links') have clear descriptions in the schema. The tool description does not add new semantic details beyond what the schema provides, so baseline score of 3 applies.

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

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

The description clearly states the action ('generate') and resource ('llms.txt file for any URL'). It distinguishes from sibling tools like 'scan_competitor_ai_presence' by focusing on a specific output file format. Examples of use cases further clarify its 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 three explicit use cases (indexing a client's site, drafting own llms.txt, auditing competitors). While it doesn't explicitly state when not to use it or list alternatives, the context is sufficient for an AI agent to understand its specific role 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 provide readOnlyHint, idempotentHint, destructiveHint. Description adds context on return fields and parameter behavior (default active only), which is useful but not extensive.

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

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

Two concise sentences that front-load the action and purpose. Every word earns its place, with no redundancy or filler.

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

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

Despite no output schema, the description lists all returned fields. The tool is simple with one optional parameter, and the description fully covers what an agent needs to know.

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 description for include_inactive. The tool description does not add new parameter meaning beyond what is already in the schema, hitting the baseline.

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

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

The description clearly states 'List the caller's active subscriptions' and lists return fields. The second sentence distinguishes it from sibling tools like subscribe and unsubscribe by specifying use cases for review and cancellation.

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: 'review what you're monitoring before adding more or to find an id to cancel', directly contrasting with subscribe and unsubscribe 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?

With all annotations false, the description fully carries the burden. It discloses rate limiting ('Rate-limited to 5 per identifier per day'), cost ('Free; doesn't count against your tool-call quota'), and the team-visible effect ('reads digests daily and signal directly affects roadmap'). It also scopes the tool to 'tools served by this Pipeworx connection,' which is important 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 every sentence carries necessary information: purpose, usage, exclusions, feedback composition tips, and constraints. It is front-loaded with the core purpose, and the structure flows logically from what/why to how and limitations. Not as tight as a two-sentence description, but appropriate for 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?

For a tool with no output schema, no annotations, and 3 parameters, the description covers purpose, usage triggers, exclusions, content guidance, rate limits, and quota impact. It leaves no significant gap for an agent to misuse the tool, and the optional context object is mentioned in the schema rather than needing extra description.

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

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

The schema already covers all parameters with rich descriptions, so baseline is 3. The description adds extra semantics for the 'message' parameter by advising 'Don't paste the end-user's prompt' and 'Describe the issue in terms of Pipeworx tools/packs,' which goes beyond the schema. No additional technical syntax is needed.

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

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

The description opens with a specific verb+resource: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It clearly distinguishes from sibling tools by focusing on feedback for the Pipeworx connection itself, and it enumerates the feedback types (bug, feature, data_gap, praise).

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 triggers for each feedback type, and even gives an exclusion: 'if the tool came from a different MCP server... file it with that server instead.' It also offers practical guidance on how to phrase feedback and how to identify Pipeworx tools, making the usage context unambiguous.

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

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

The description adds significant behavioral context beyond annotations: data source (CF analytics-engine), no PII, the data structure (pack, tool, count), and caching behavior (5min-1h). Annotations already declare read-only and idempotent, and the description reinforces safety while adding useful implementation details.

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

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

Four sentences, each sentence serves a clear purpose: what the tool returns, three use cases listed concisely, and a brief note on data derivation and caching. No extraneous text; structure is easy to scan.

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

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

For a simple analytics tool with one optional parameter and no output schema, the description fully explains what the tool returns and why it is useful. The lack of an output schema is compensated by clear enumeration of return components (top tools, top packs, call volume).

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 (window) having an enum and base description. The description adds semantic guidance: 'Shorter windows surface what's hot right now; longer windows show steady-state demand.' This adds value beyond the schema's attribute listing.

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

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

The description uses a specific verb ('Returns') and resource ('top tools, top packs, and total call volume') and clearly distinguishes this tool from its siblings by focusing on trending usage data within a configurable time window. It is not a general-purpose discovery tool like 'discover_tools'.

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

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

The description explicitly lists three concrete use cases (discovering hot data sources, confirming canonical tools, checking alignment with agent needs) and implies when it is appropriate (trending/analytics) versus alternatives. While it doesn't explicitly state when not to use it, the use cases are clear and distinct from 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?

Description adds significant context beyond annotations: details on scanning logic, semantic anchor (Jaccard similarity), partition filter, fill check using live CLOB depth, and conditions for not trading. No contradiction with annotations (readOnlyHint, idempotentHint).

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 comprehensive but slightly verbose with technical details (e.g., Jaccard threshold, placeholder percentage). Well-structured with key terms capitalized, but could be more streamlined without losing substance.

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 checks, response format), the description covers all essential aspects: input modes, logic, output fields (opportunities, partition_check, fill_check), and error conditions (low similarity, placeholder filter). No major gaps identified.

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

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

Schema coverage is 100%, but description enriches both parameters: event explains slug/URL acceptance and partition check behavior; topic explains cross-event scanning and semantic similarity. Adds concrete examples like 'fed-decision-may-2026' and 'Strait of Hormuz traffic returns to normal'.

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

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

The description clearly states the tool finds arbitrage opportunities on Polymarket, with specific methods (monotonicity violations, partition-sum checks) and modes (trending, event, topic). It distinguishes itself from sibling tools like polymarket_edges by focusing on arbitrage detection.

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

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

Provides explicit guidance: call with no args for trending scan, pass event for specific market partition check, pass topic for cross-event scanning. Recommends event mode for specificity and mentions fill check and polymarket_fill_risk for custom sizing, indicating when to use alternatives.

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

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

The description extensively discloses behavioral traits beyond what annotations provide, including response structure (by_segment with model_driven, structural_arbitrage, concentrated_longshot), diagnostics for empty segments, caching behavior (1h at KV level), and caveats about Fed bets. 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 information-dense but quite long, with many technical details that might overwhelm an agent. It is front-loaded with the purpose, but the extensive enumeration of model families and knobs could be more concise. It balances between being thorough and overly verbose.

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

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

The description is very complete given the tool's complexity, covering response segments, diagnostics, caching, and tradeable-edge knobs. It explains key caveats like Fed bet unreliability, ensuring the agent has sufficient context to use the tool effectively.

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

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

All 9 parameters are described in the schema (100% coverage), and the description adds significant context, such as the purpose of min_liquidity and max_spread_pp as 'tradeable-edge filters' and the role of min_partition_leg_kelly for partition arbs. This adds meaning beyond the schema, warranting a score above baseline 3.

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

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

The description clearly states the tool's purpose: 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price.' It conveys a specific verb and resource, and the context 'Built for "what should I bet on today"' distinguishes it from sibling tools that may focus on arbitrage or fill risk.

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

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

The description explicitly frames the tool for discovering betting opportunities without paging through markets, providing a clear use case. However, it does not explicitly state when not to use it or mention alternative sibling tools, so some guidance is missing.

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?

Exceeds annotations by detailing that decay numbers come from daily closes of edge_pp_net, not intraday, and that history is bounded by a 60-day snapshot TTL. No contradiction with readOnlyHint and idempotentHint annotations.

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

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

The description is well-structured with sections for args, response fields, and limits, and it front-loads the purpose. However, it is somewhat verbose; each sentence is earned but could be tightened.

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

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

Despite no output schema, the description thoroughly explains the response structure (tracked, expired, snapshot_dates) with field details. It covers limitations and assumptions, making it complete for an 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 value by explaining the meaning of 'days' (lookback, default 14, clamp 2-30) and 'window' (snapshot family) beyond the schema's brief 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 it provides 'edge persistence and decay telemetry' and answers a specific question about edge longevity. It distinguishes itself from sibling tool 'polymarket_edges' by focusing on time-series and decay, not just current snapshots.

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 this tool (to understand edge longevity and trend) but does not explicitly state when not to use it or provide alternatives to exclude. The context is clear but lacks explicit exclusions.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint. The description adds specific behavioral details: walks the ladder, returns fill details, verdict, and warns about partial basket fills converting arb into directional position (dominant loss mode). 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?

Well-structured with clear sections (REQUIRES, SINGLE-MARKET, BASKET, USE THIS) and concise sentences. Every sentence adds value with no redundancy, appropriate for a complex tool.

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

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

Despite no output schema, the description comprehensively lists return values for both modes, covers risks (thin books, partial fills), and provides enough information for an agent to use the tool correctly.

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

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

Schema coverage is 100%, but description adds value by explaining the dual interpretation of parameters (e.g., size_usd as spend vs target proceeds), requiring one of market/event, and default behavior for side in basket mode. This clarifies meaning beyond schema.

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

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

The description clearly states it checks realizable-vs-theoretical edge against live order book depth, distinguishes between single-market and basket modes, and explicitly tells when to use it before polymarket_arbitrage signals or trades above $500, differentiating from sibling tools.

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

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

It explicitly says 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500', providing clear context and alternatives implied by mentioning when not to act directly.

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

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

The description goes far beyond annotations (readOnlyHint, idempotentHint, openWorldHint) by explaining safety fields like compatibility_warning, temporal_alignment, skipped_cross_type, and their meanings. It discloses when spreads are mathematically meaningless (temporal misalignment) and when no arb exists (non-equivalent bet shapes). No contradiction with annotations.

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

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

The description is well-structured with clear labeled sections (TWO MODES, RESPONSE, SAFETY FIELDS) and front-loaded with the core purpose. While a bit lengthy, every sentence contributes necessary context; no filler is present.

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 3 optional parameters, the description compensates fully. It explains the response format, safety fields, temporal alignment, and the rarity of real spreads. It even cautions that 'pre-mapped ≠ tradeable'. This provides a complete mental model for correct invocation.

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

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

Schema coverage is 100%, baseline 3. The description adds value by explaining how parameters interact (explicit overrides topic-mapped side), providing concrete examples for topic values, and detailing response fields like compatibility_warning. It adds semantic richness beyond 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 it computes cross-venue spread between Kalshi and Polymarket for the same question. It specifies two distinct modes (topic shortcuts and explicit ticker/slug) and explains the core logic of comparing bet shapes. This is unique among siblings like 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 explicitly details when to use each mode: use 'topic' for common pre-mapped macro shortcuts, and use explicit 'kalshi_event_ticker'+'polymarket_event_slug' for custom pairings. It also warns that most pre-mapped topics currently return compatibility warnings, guiding users away from unreliable results.

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

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

Annotations already indicate safe, idempotent, read-only behavior. Description adds context about the .px path suffix and the per-response cell limit constraint, which are not in 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?

Three focused sentences with zero waste. The first sentence delivers the core action; the second specifies format; the third provides a critical usage constraint.

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

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

Given no output schema, the description explains the request format well but does not detail the json-stat2 response structure. However, the tool is straightforward and the response format is standard.

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

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

With 100% schema coverage, description adds substantial meaning: path must end in '.px', body is a PxWeb query object with specific structure, and gives an example. This goes beyond what the schema alone provides.

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

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

The description clearly states the verb 'POST' and the resource 'ÅSUB table', and specifies the return format 'json-stat2'. It distinguishes from siblings like 'table_meta' by focusing on data retrieval.

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

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

Provides explicit guidance to narrow dimension values to avoid cell limits. Does not explicitly compare to sibling tools, but implies when to use (for data queries vs. metadata).

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 context beyond annotations: scoping to identifier, pairing with remember/forget, and listing behavior on omitted key. Annotations already declare read-only, idempotent, non-destructive.

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

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

Three sentences, zero wasted words. Purpose, usage, and scoping are front-loaded and efficient.

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

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

Fully covers input, behavior, scoping, and relationship to sibling tools. No output schema needed for this read operation.

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

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

Schema has 100% coverage. Description explains the single key parameter's role and the special behavior when omitted (list all keys), adding full semantic meaning.

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

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

Description clearly states the tool retrieves a value or lists all keys, with explicit linkage to remember and forget siblings. Verb+resource+scope is specific and distinguishes from other tools.

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

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

Explicitly tells when to use (look up stored context) and how (omit key to list all keys). Does not explicitly state when not to use, but the narrow purpose makes exclusions unnecessary.

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

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

Discloses stateful behavior of mark_read modifying read status, which is beyond annotations. Explains idempotency (polls work fine) and provides alternative access method. Annotations already indicate safety, but description adds valuable 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?

Relatively concise at 4 sentences; each sentence provides useful information. Front-loaded with main purpose. Minor redundancy possible but not significant.

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

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

Covers return fields, filter options, stateful behavior, and alternative access. Lacks pagination details or ordering beyond 'most recent', but sufficient for a list tool with 5 parameters fully described.

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 adds example for type ('sec_8k'), specifies format for since (ISO timestamp), and clarifies mark_read effect. Adds value beyond 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?

Clearly states verb 'pull' and resource 'fired events from your subscription feed'. Distinguishes itself from siblings like 'list_subscriptions' by focusing on events rather than subscriptions.

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

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

Provides context on filtering, marking read, and polling. Mentions alternative endpoint for scripts/dashboards. Lacks explicit when-not-to-use or comparison to 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?

The description goes beyond annotations by detailing the fan-out to multiple sources (SEC EDGAR, GDELT→GNews fallback, USPTO with a sunset note), the parallel call behavior, and the return format (changes[] grouped by source plus total_changes count and citation URIs). No contradictions with annotations.

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

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

The description is a well-structured single paragraph that front-loads example queries, then covers source details, parameter guidance, and output format. Every sentence adds value without being verbose.

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

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

Given the tool's complexity (multiple sources, fallback mechanisms, sunset note, no output schema), the description is complete. It covers all essential aspects: parallel calls, source behavior, parameter usage, and output structure. It also relates to the sibling tool 'entity_profile' for appropriate context.

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

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

Schema coverage is 100%, so each parameter already has a description. The tool description adds value by providing examples for `since` (ISO date or relative) and suggesting '30d' or '1m', and clarifying `value` accepts ticker or CIK. This enhances understanding beyond the schema.

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

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

The description clearly states the tool's purpose: providing a change feed for a company over a specified time window. It includes example queries like "What's new with X" and distinguishes itself from the sibling tool 'entity_profile' by specifying the difference between dynamic changes and static profiles.

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

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

The description explicitly says when to use this tool (for recent changes) and when to use 'entity_profile' instead (for static profiles). It also provides guidance on the `since` parameter, suggesting '30d' or '1m' for typical monitoring.

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 idempotentHint=true, destructiveHint=false, readOnlyHint=false. The description adds valuable context: scoping by identifier, persistent memory for authenticated users, 24-hour retention for anonymous sessions. 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: purpose, usage guidance, storage details. Front-loaded with verb and resource. No unnecessary words.

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

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

For a simple write tool with 2 params and no output schema, the description covers all essential aspects: what it does, when to use, how storage works, and related 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% with clear descriptions for key and value. The description only generically mentions 'key-value pair' and does not add details beyond schema. Baseline 3.

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

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

The description clearly states 'Save data the agent will need to reuse later' and provides concrete examples (resolved ticker, target address, user preference). It distinguishes itself from sibling tools recall and forget by explicitly mentioning them as partners.

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

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

Description provides explicit when-to-use guidance: 'Use when you discover something worth carrying forward' with examples. Mentions pairing with recall and forget, but does not explicitly state when not to use.

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

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

Annotations indicate safe, read-only, idempotent behavior. Description adds that each call cascades through multiple internal endpoints, replacing manual lookups, and details output structure for each entity type (including citation URIs). No contradiction.

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

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

Description is front-loaded with examples and clear purpose. Every sentence adds value, though slightly longer than minimal; but efficiency is high.

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?

Without output schema, description fully explains return values for both entity types (ticker, CIK, company_name, citation URI for company; RxCUI, ingredient, brand, citation for drug). Covers scope and internal cascading.

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

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

With 100% schema coverage, description enriches both parameters: for 'type', it lists supported values and output; for 'value', it provides specific examples and accepted formats (ticker, CIK, brand/generic name). Adds meaning beyond schema.

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

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

Description explicitly states the tool resolves names to official identifiers, provides clear examples (ticker, CIK, RxCUI), and distinguishes from siblings by recommending it as the first step when needing an ID.

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

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

Clear usage context: use when you have a name but need an ID. Examples for each type and accepted inputs are given. However, no explicit exclusion or alternatives to sibling tools are mentioned.

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 behavioral details beyond annotations: probes each entity, ranks, surfaces most/least recognized. Annotations already indicate readOnly, idempotent, non-destructive. Description enriches understanding of operation and output.

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, followed by context and example. No wasted words, efficient and informative.

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 specifies return fields: 'ranked list with score, confidence, signal density per entity'. Adequate for understanding output. Could add more detail on ranking criteria.

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

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

Schema coverage is 100%. Description adds that the first entity is treated as the 'subject' for narrative, adding value beyond schema. Other parameters not elaborated, but schema is sufficient.

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, probes with ai_visibility_check, ranks by score. This distinguishes it from siblings like ai_visibility_check (single entity) and compare_entities (generic comparison).

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 case: 'competitive AI-marketing audits' with a concrete example. Does not explicitly mention when not to use or alternatives, but context implies appropriate 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 indicate read-only, idempotent, and non-destructive. The description adds critical behavioral context: partial failures, bundlephobia timing (5–30s for first measurement), and graceful degradation via sources_failed. 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?

Single well-structured paragraph with front-loaded purpose. Every sentence adds value, but could be slightly more organized (e.g., bullet list for return fields). Still concise and efficient.

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

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

No output schema exists, so description must fully document returns. It lists summary fields, advisory details, links, and alternative versions. Combined with behavioral transparency about failures, it leaves no significant gaps for agent usage.

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

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

Schema coverage is 100%, providing good baseline. Description adds nuance: package name accepts scoped packages, version defaults to latest. These are helpful but not extensive beyond schema. Score reflects extra value without being redundant.

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 composite check for adding an npm package, covering license, advisories, version history, and bundle size from deps.dev and bundlephobia. It specifies the verb 'scan' and resource 'dependency' with a focused scope. Siblings do not overlap in function.

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: whenever an agent asks about safety, popularity, size, or cost. Provides exclusion: 'NPM ecosystem only in v1; PyPI/Maven/Cargo/Go fall under deps.dev:version directly.' This offers clear guidance on alternatives.

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

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

Discloses significant behavioral details beyond annotations: uses BGE-base-en embeddings with cosine similarity, 500-char overlapping windows, 200K char cap with truncation and flagging, and that every passage carries a character offset. Complements readOnlyHint, idempotentHint, and destructiveHint with rich operational 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?

Concise but packed with essential information: purpose, use case, technical details, and limitations. Every sentence adds value. Front-loaded with the core action and example scenarios, followed by implementation specifics.

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

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

Given no output schema, the description fully explains return values (top-N passages with character offsets and similarity scores). It covers what the tool returns, its inner workings (embedding model, windowing), and constraints (character limit). Completely equips an agent to decide and use the tool correctly.

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

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

Schema coverage is 100% (all three parameters have descriptions), so baseline is 3. The description adds more value by providing natural-language examples for the query parameter ('supply-chain risk', 'fiscal year 2024 revenue') and clarifying the 'text' limitation ('max ~200K chars'). This enriches understanding 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 'Semantic search INSIDE a fetched record' and gives concrete examples (SEC 10-K, article) and a clear verb-resource pair. It distinguishes from siblings by mentioning pairing with 'ask_pipeworx_grounded', making 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?

Explicitly states 'Use when the record is too big to cram into the prompt' and explains that it 'saves context' and returns only relevant passages. Also names an alternative workflow ('Pairs with ask_pipeworx_grounded') for grounding, providing clear when-to-use and when-not-to guidance.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive hints. The description adds behavioral context by detailing that folders are type 'l' and tables are type 't' with ids ending in '.px'. This provides useful functional transparency 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 concise sentences that front-load the purpose and follow with necessary detail. No redundant or extraneous information.

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

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

For a simple tool with one optional parameter, the description covers both usage scenarios (with and without path) and mentions the types of results. While it lacks details on the exact return format, the overall completeness is adequate given the low complexity and absence of an output schema.

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

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

The input schema covers the 'path' parameter with description and examples (100% coverage). The description adds value by explaining the structure of valid sub-paths (e.g., 'Statistik', 'Statistik/BE') and how they map to folders and tables, enriching the semantic 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 specifies the verb 'browse', the resource 'ÅSUB (Statistics Åland) PxWeb subject tree', and explains behavior with and without a sub-path. It clearly distinguishes the tool's role from siblings by focusing on tree navigation rather than data querying or other operations.

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

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

The description explains how to use the tool (with or without path) but does not explicitly compare it to sibling tools like query_table or table_meta. It lacks guidance on when to choose this over alternatives, which is a gap given the large number of siblings.

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

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

Beyond annotations (idempotent, not read-only, not destructive), the description details side effects: requires OAuth, persists subscriptions, imposes SMS caps, and explains webhook auto-disable after failures. It adds significant behavioral context not captured by annotations.

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

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

The description is comprehensive but slightly dense; it covers all necessary details in a well-structured format with front-loaded purpose. Every sentence adds value, though minor reorganization could improve 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 types, delivery channels, constraints) and no output schema, the description covers return value (subscription id), prerequisites, type-specific parameters, delivery options, and failure handling (SMS cap, webhook auto-disable).

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

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

With 100% schema coverage, the description still adds substantial value by providing concrete examples for each type (e.g., sec_8k with item codes, polymarket topic) and explaining nested delivery parameters (e.g., webhook signing secret). It goes beyond the schema's bare 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 it creates a proactive monitoring subscription to a live-data event stream and returns the new subscription id. This verb+resource combination is specific and distinguishes it from sibling tools like list_subscriptions and unsubscribe.

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

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

The description explains prerequisites (Pipeworx OAuth account), supported types with examples, and delivery options. It implies when to use but lacks explicit when-not or alternatives. However, the context of sibling tools provides differentiation.

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

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

Annotations already declare the tool as read-only, open-world, and idempotent. The description adds that it returns example questions with tool call shapes, reinforcing its safe, exploratory nature 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 somewhat long but every sentence adds value—purpose, usage, parameter detail, and return type. It is front-loaded with key info and well-structured, though could be slightly trimmed without losing clarity.

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

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

Given no output schema, the description adequately explains return structure (category-bucketed examples with tool calls). It covers purpose, when to use, and parameter. Missing error behavior for invalid topics, but overall complete for its onboarding role.

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 optional 'topic' parameter is explained in both schema and description. The description adds meaning by detailing what each topic covers (e.g., 'finance', 'pharma') and that omitting topic gives a full spread, beyond just listing enum values.

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

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

The description clearly states the tool is an onboarding entry point for new users, specifying it answers 'what can I ask' and returns category-bucketed example questions. It distinguishes itself from sibling tools like ask_pipeworx by positioning itself as the first tool to use.

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 to use this tool FIRST when you do not know what Pipeworx can do, and to learn how to call meta-tools. It implies not to use when you already have a specific query, directing to other tools 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?

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds useful context: the path must end in '.px' and the return includes dimension codes, labels, and value lists. 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 with no wasted words. States purpose, input requirement, and return value in a compact, front-loaded manner.

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 and the presence of annotations covering safety, the description fully explains what the tool does, what input it expects, and what output it provides (dimension codes, labels, value lists). It also connects to the sibling query_table tool, making its role clear.

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

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

The single parameter 'path' is described both in the schema (with an example) and in the tool description (with the constraint that it must end in '.px'). The description adds clarity beyond the schema's example.

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 fetches dimension definitions and valid values for a PxWeb table, specifies the required path format ending in '.px', and provides an example. This distinguishes it from siblings like query_table which would use this data.

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

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

The description explains when to use the tool (to get dimension info for building a query_table body) and what input is required (full path ending in .px). It does not explicitly mention when not to use or alternatives, but the context of sibling tools is clear.

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

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

Annotations indicate non-readOnly, non-destructive, idempotent. The description adds context by explaining that the row is deactivated (not deleted), preserving historical events. This goes beyond annotations by clarifying the exact behavioral impact.

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, each carrying essential information: the action and the behavioral details. 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 simple tool with one parameter and no output schema, the description covers purpose, ownership constraint, deactivation behavior, and impact on historical data. It is fully informative.

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

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

The single parameter 'id' is described in the schema, and the description adds that it is a UUID returned by 'subscribe', linking the tools. With 100% schema coverage, the description provides useful additional context.

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 'Cancel a subscription by id' with a specific verb and resource. It distinguishes itself from sibling tools like 'subscribe' and 'list_subscriptions' by specifying cancellation.

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

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

The description provides clear usage context: 'Ownership is enforced — you can only cancel your own subscriptions.' It also explains the effect on historical data, guiding when to use this tool versus alternatives. It does not explicitly state when not to use, but the ownership constraint is a strong guideline.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds substantial behavioral context: it details the two verification pipelines (structured vs. grounded), the exact verdict types (confirmed, approximately_correct, refuted, inconclusive, unsupported), and that it returns a grounded actual value with citation and reasoning. No contradictions with annotations.

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

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

The description is concise yet comprehensive, using bullet-like structure and examples to front-load key information. Every sentence serves a purpose: query examples, use case, pipeline differentiation, return format, and efficiency claim. 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 tool with 2 parameters, no output schema, and a complex claim verification task, the description covers all necessary aspects: triggers, two processing paths, verdict types, return structure (with citations and reasoning), and efficiency gains. The agent can fully understand what the tool does and what it returns.

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

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

Both parameters have schema descriptions covering 100% of their meaning. The description enhances the `claim` parameter with concrete examples and clarifies that it accepts natural-language phrasing. For `tolerance_pct`, it adds the override intent and usage guidance for hallucination detection (1-2%). This goes beyond the schema's basic description.

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

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

Description starts with explicit query patterns ("Is it true that…", "fact check", etc.) and states the core function: natural-language claim verification against authoritative sources. It clearly distinguishes the tool from siblings by specifying that it replaces 4–6 sequential calls and handles both company financial claims via SEC EDGAR and other claims via grounded pipeline.

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: 'Use whenever the agent needs to check whether something a user said is factually correct.' It also describes two separate verification paths, giving context on how different claim types are handled. However, it lacks explicit exclusions or alternatives (e.g., when not to use), though the sibling list includes other research tools that may serve different purposes.

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