Singstat Sg

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context: default model is free, Anthropic requires BYO API key, and details the return structure. 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, front-loaded with core purpose, zero waste. Every clause adds value, including optional API key note and return structure.

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

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

No output schema is present, but the description explains return fields (score, confidence, signals, raw_response) and combined view. Parameter documentation is strong. For a 4-parameter read-only tool, this is largely complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning beyond the schema: default model details, API key usage, and context disambiguation purpose. This elevates the score.

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

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

The description clearly states the tool's purpose: probing LLMs for knowledge about an entity and scoring visibility (0-100). It uses specific verbs (probe, score) and resource (visibility per model), and is distinct from siblings like 'compare_entities' or 'entity_profile'.

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

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

Explicitly states use cases: 'AI-marketing audits, pre-launch brand checks, competitive monitoring'. It does not list when not to use or alternatives, but the context is clear and sufficient for correct selection.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive. The description adds meaningful behavioral context: it routes to the right tool, fills arguments automatically, and returns results with stable pipeworx:// citation URIs. It also notes it works on every tier and is a fast, single call. This goes beyond the annotations without contradicting them.

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

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

The description is longer than typical, but it is well-organized: it front-loads the core purpose with 'PREFER OVER WEB SEARCH', then explains routing/citations, then provides usage triggers, examples, and sibling comparisons. Some redundancy exists (the 'Use whenever' sentence overlaps with the opening), but every sentence contributes to guiding the agent. It earns its length.

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

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

For a complex tool that routes to thousands of sources, the description covers the essential aspects: what it does, how it behaves (fills arguments, returns citations), when to use it, and when to use alternatives. It does not detail edge cases (e.g., no results found) or exact response structure, but given the openWorldHint and no output schema, this is sufficient 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?

The input schema has 100% coverage with descriptions for 'question' and its five aliases. The schema already explains that 'question' accepts natural language and that aliases are equivalent. The description adds value by providing concrete example questions ('current US unemployment rate', etc.), which helps the agent formulate parameter values correctly. This compensates for the schema's somewhat redundant alias descriptions.

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

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

The description clearly states the tool's purpose: to answer factual questions by routing to 5,562 verified sources and returning structured answers with citations. It explicitly says 'PREFER OVER WEB SEARCH' and provides a list of domains (SEC filings, FDA data, etc.), distinguishing it from generic search. It also differentiates from siblings by identifying itself as the default entry point.

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

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

The description gives explicit when-to-use guidance (any factual question about real-world entities, events, numbers), what user intents trigger it ('what is', 'look up', 'find', etc.), and, crucially, when to step up to alternatives: ask_pipeworx_grounded for hallucination-resistant answers and deep_research for broad/multi-part questions. It even addresses breaking-news. This is exemplary guidance for tool selection.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and non-destructive. The description adds useful experimental context: candidates may be active, none are active now, and it is a full working router with no fallback. 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?

Four sentences, each serving a purpose: beta definition, current state, usage guidance, and non-fallback reassurance. Slightly verbose with details like the exact tool count, but overall efficient and well-structured.

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

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

Description covers the beta relationship, live candidate status, comparison purpose, and confirms it is a full router. It references the same response shape as ask_pipeworx, which compensates for the lack of output schema. Does not discuss error behavior, but given the sibling reference and annotations, it is adequately 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?

Input schema covers 100% of parameters (all six are aliases for question, each described). The description adds no additional parameter meaning, so the baseline score of 3 applies.

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

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

Description clearly states it is a beta version of ask_pipeworx, a universal router with 5,562 tools, same arguments and response shape. It distinguishes from the stable sibling by mentioning candidate routing improvements enabled live. The verb 'ask' plus resource 'Pipeworx' is specific.

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

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

Explicitly instructs to 'Use it exactly like ask_pipeworx when you want the newest routing' and explains results are compared against the stable router. Provides clear context for choosing beta over stable, though it doesn't enumerate 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?

Beyond the read-only/idempotent annotations, the description discloses the exact success return shape with evidence/confidence/refusal_reason:null, and the explicit refusal reasons list. It also discloses the extra LLM call cost. 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?

Three dense sentences pack purpose, mechanism, return, failure modes, and usage guidance. Slightly long but each clause earns its place; front-loaded with core purpose. Minor deduction for length but no waste.

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

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

Despite no output schema, the description fully documents return value shape including refusal reasons. Covers cost, routing, and usage boundaries, making it complete for an agent to decide when to invoke and what to expect back.

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 already documents the question parameter and aliases at 100% coverage; description does not add parameter-level detail but doesn't need to. It mentions the tool fills arguments on its own, which is behavioral context rather than parameter semantics. Baseline 3 is appropriate as schema does the heavy lifting.

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

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

Description clearly states this is a hallucination-resistant answer mode that routes through the same tool selection as ask_pipeworx but extracts answers only from tool results. It explicitly distinguishes from sibling ask_pipeworx by adding evidence and refusal behavior, giving a specific verb+resource+differentiation.

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 gives use cases: 'whenever an answer will be quoted, cited, or acted on' against inventing facts, and explicitly prefers ask_pipeworx for casual lookups due to cost. This provides clear when-to-use and when-not-to-use guidance, naming the alternative 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 already declare readOnlyHint, idempotentHint, destructiveHint false. The description adds extensive behavioral context: low-confidence resolution short-circuits with status, market_closed_or_inactive handling, illiquid wide spread warnings, resolution-rule risk parsing, response shapes, resolver contract, parent event extraction, news fallback fields, and safety checks. 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 comprehensive but verbose, containing several paragraphs with extensive examples and technical details. It is well-organized with sections but could be more concise. Some repetition exists (e.g., resolution paths described twice).

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 return values: response shapes (result.market, result.analysis, result.evidence), resolver contract (confidence, score, alternatives, suggestions), parent event extractor, news fields with fallback mechanisms, safety short-circuits, closed market handling, wide spread warnings, and resolution-rule risk. Covers nearly all aspects of complex behavior.

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

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

Schema coverage is 100%, so baseline is 3. The description adds significant meaning: for the 'market' parameter, it specifies slugs, URLs, or question text; for 'depth', explains quick vs thorough; for 'include_raw', describes when to use true vs false. This goes well beyond the schema's descriptions.

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

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

The description clearly states the tool's purpose: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies the action (research), resource (Polymarket bet), and scope (one call). It also provides example queries and distinguishes itself from sibling tools by focusing on a single bet with fan-out to data packs.

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

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

The description explicitly lists use cases: 'should I bet on X', 'what does the data say about Y', 'is there edge in Z'. It also describes the internal workflow (resolve, classify, fan-out) to help the agent understand when to call it. However, it does not explicitly state when not to use it or name alternative tools for comparison, though the sibling list is provided externally.

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

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

Annotations already indicate readOnly, idempotent, and non-destructive behavior. The description adds detailed behavioral info: specific data sources (SEC EDGAR/XBRL for companies, FAERS/FDA/clinical trials for drugs), off-calendar fiscal year handling, and sorting by primary metric. 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 dense but well-front-loaded with key phrases and examples. Every sentence adds value, though a minor redundancy exists (e.g., repeating 'type="company" pulls...'). Still, it earns its length.

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

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

Despite no output schema, the description mentions return format ('paired data + pipeworx:// citation URIs'). It covers both entity types, data sources, and edge cases (off-calendar fiscal years). Adequate for an agent to select and invoke correctly.

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

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

Schema coverage is 100%, but the description enriches parameter meaning: 'type' enum values are explained with what data they pull (revenue/net income/cash/debt for company; adverse events/approvals/trials for drug), and the 'values' parameter format is clarified (tickers for company, names for drug).

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

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

The description explicitly states the tool performs side-by-side comparisons of 2–5 companies or drugs in a single parallel call, using clear verbs like 'compare' and specific resources ('companies or drugs'). It distinguishes itself from sibling tools like entity_profile by focusing on multi-entity 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?

The description instructs 'ALWAYS PREFER over sequential single-pack lookups when comparing entities,' providing strong usage guidance. It also includes example queries ('which is bigger...') and implies when not to use (avoid sequential lookups).

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

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

Annotations already mark read-only, open-world, idempotent, and non-destructive. The description adds rich behavioral details: returns findings with citations, explicit gaps[], never invents, includes hop fields, contradictions scans, semantic excerpting, and latency expectations. 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 long but information-dense and well-structured, front-loaded with the account requirement and purpose, then usage guidelines, then depth details. Every sentence contributes to correct selection and invocation.

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

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

For a complex research tool with no output schema, the description thoroughly covers the return packet structure, gaps, contradictions, citation behavior, latency, and depth options, leaving no significant ambiguity for an AI agent.

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

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

The input schema describes question and depth with enum, but the description elaborates meaningfully on depth semantics (quick vs standard vs thorough with specific behaviors) and question guidance (broad/multi-part acceptable). This adds significant value beyond the schema's 100% coverage.

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

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

The description clearly states it performs grounded multi-source research across Pipeworx's structured data sources, decomposes questions into facets, routes to tools in parallel, and contrasts itself with open-web search. It distinguishes from siblings like ask_pipeworx by its multi-hop research nature.

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

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

Explicitly states when to use (broad/multi-part questions over structured data) and when not (single lookups or breaking news), naming ask_pipeworx as the alternative. Also specifies account/tier prerequisites and expected latency.

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 and idempotentHint=true. The description adds valuable behavioral context: it returns 'the top-N most relevant tools with names, descriptions, and full input schemas (with curated examples) — each result is ready to call directly, no second schema lookup needed.' This goes beyond annotations by explaining output format and readiness. 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 concise (about three sentences) and front-loaded with the core purpose. Every sentence serves a purpose: defining the tool, listing domains, and explaining the return value. No wasted words. Excellent structure.

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

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

Given that there is no output schema, the description adequately explains what is returned (top-N tools with schemas). It also covers the 'when to use' aspect. It lacks details on error handling or empty results, but for a discovery tool this is sufficient. Scores 4.

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%, baseline 3. The description adds value by providing usage examples (e.g., 'analyze housing market trends', 'look up FDA drug approvals') and explaining that multiple aliases (task, q, description, search) all map to the query. This helps the agent understand parameter usage beyond the formal schema. Scores 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: to find/discover relevant tools by describing a data or task. It uses specific verbs ('browse, search, look up, discover') and explicitly contrasts with sibling tools by instructing 'Call this FIRST'. It distinguishes itself well from the many domain-specific siblings.

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

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

The description provides explicit when-to-use guidance: 'Use when you need to browse, search...' and 'Call this FIRST when you have many tools available and want to see the option set.' It does not explicitly state when not to use, but the context strongly implies it is for discovery before using other tools. Scores 4 for clear context without exclusion criteria.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds significant behavioral context beyond annotations: it fans out across multiple sources (SEC, XBRL, USPTO, news, GLEIF), explains parallel execution, discloses a sunset limitation for patents, and details return structure. No contradiction with annotations.

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

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

The description is front-loaded with example queries and usage guidance, but it is somewhat verbose. Every sentence adds value, but the length could be trimmed slightly without loss. Overall, well-structured and efficient for the complexity.

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

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

Given the complexity of the tool (multiple sources, parallel call, fallbacks) and no output schema, the description thoroughly explains what is returned: CIK, recent filings with URIs, fundamentals, patents with sunset note, news via fallback, and LEI. It covers limitations and usage constraints, making it complete for an AI agent.

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

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

Schema description coverage is 100% as both parameters have descriptive comments. The tool description essentially repeats the schema's description for the 'value' parameter and does not add new information for 'type'. Baseline 3 is appropriate since the schema already provides full clarity.

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 provides a full cross-source profile of a US public company in one parallel call, using specific examples like 'brief me on Tesla'. It explicitly distinguishes itself from chaining single-pack lookups, which is reinforced by naming the alternative tool resolve_entity for name-based queries.

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

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

The description explicitly states when to prefer this tool ('ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view') and when not to use it ('Names not supported — use resolve_entity first if you only have a name'). It also notes the patents source may soft-fail, setting clear expectations.

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

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

Annotations already provide destructiveHint=true and idempotentHint=true. Description adds 'delete' which matches, but doesn't elaborate on effects or return behavior. Minimal added value beyond annotations.

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

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

Two sentences, direct and to the point. No redundant information. Every sentence earns its place.

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

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

For a simple tool with one parameter and no output schema, the description covers purpose and usage but omits what the tool returns (e.g., success confirmation). Adequate but could be more 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 covers the only parameter fully (100% coverage). Description mentions 'by key' but adds no new detail beyond the schema's 'Memory key to delete'.

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 'Delete a previously stored memory by key', specifying the verb, resource, and method. References siblings 'remember' and 'recall', providing context on how it fits in the tool family.

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

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

Explicitly states when to use: 'when context is stale, the task is done, or you want to clear sensitive data'. While it doesn't list when not to use, it pairs with siblings, implying alternatives.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, confirming safe, idempotent, read-only behavior. The description adds valuable context: the process (fetches page, extracts title/description/links), output format (standard markdown, single text blob), and deployment location (site-root/llms.txt). 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, each serving a distinct purpose: action definition, process summary, and use cases. No redundant words, front-loaded with key verb and resource.

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

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

With 2 non-nested parameters and no output schema, the description fully covers input, process, output format, and usage context. It explains how the output should be used (dropped at site-root/llms.txt) and for whom (AI crawlers). No gaps.

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

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

Schema coverage is 100%, so baseline is 3. The description enhances both parameters: for 'url' it provides an example, for 'max_links' it states default (25) and max (50). These details add practical 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 defines the tool's action (generate), resource (llms.txt file), and target (any URL). It distinguishes from siblings by specifying 'production-ready' and the exact output format, which is unique among sibling tools like scan_competitor_ai_presence.

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 lists three practical use cases (client index, own project, competitor audit) that help an agent decide when to invoke. Lacks explicit 'when not to use' or direct alternative tool references, but the use cases are sufficient for 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 provide readOnlyHint, idempotentHint, destructiveHint. The description adds that it returns specific fields and usage context, which is useful but not heavily 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: first front-loads action and fields, second provides usage guidance. 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?

Given the tool's simplicity (1 optional parameter, no output schema, rich annotations), the description adequately covers purpose, return fields, and usage context.

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

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

Schema coverage is 100% with a single optional boolean parameter fully described. The description does not add extra meaning beyond the schema, earning the baseline score.

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 'List' and resource 'caller's active subscriptions', and specifies returned fields. It distinguishes from sibling tools like subscribe/unsubscribe by mentioning review and cancellation 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?

The description explicitly says 'Use this to review what you're monitoring before adding more or to find an id to cancel,' providing clear context for when to use the tool, though it doesn't 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 are all false, so the description carries the burden, and it delivers richly. It discloses the claim_token flow ('Filing without an account returns a claim_token; pass it back later...'), rate limiting ('Rate-limited to 5 per identifier per day'), cost ('Free; doesn't count against your tool-call quota'), and maintenance ('The team reads digests daily'). This goes well beyond the annotations.

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

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

The description is longer than ideal but each sentence earns its place—purpose, usage, exclusions, token flow, roadmap impact, rate limit, and cost are all relevant. It is front-loaded with purpose and structured logically, though slightly verbose in the middle sections.

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 moderate complexity and no output schema, the description covers all essential context: what it does, when to use or avoid, how to structure feedback, the claim_token follow-up mechanism, and privacy (don't paste end-user prompts). No critical information is missing.

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

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

Schema coverage is 100%, so baseline is 3. The description adds genuine value beyond the schema: for claim_token, it explains the exact invocation pattern ('with no other arguments'), and for message, it adds 'don't paste the end-user's prompt' which is not in the schema. These semantics help an agent use parameters correctly.

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

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

The description explicitly states the tool's purpose: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It distinguishes itself from siblings by clearly limiting scope to 'tools served by this Pipeworx connection' and excluding other MCP servers. This provides a specific verb + resource + scope, and contrasts with sibling tools like ask_pipeworx.

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

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

The description provides explicit when-to-use guidance: 'Use when a tool returns wrong/stale data (bug), when a tool you wish existed isn't in the catalog (feature/data_gap), or when something worked surprisingly well (praise).' It also gives a clear when-not-to-use exclusion: 'if the tool came from a different MCP server... file it with that server instead.' Even includes a disambiguation for identifying Pipeworx 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, idempotent, etc.), the description adds valuable context: data source (CF analytics-engine), privacy (no PII), caching behavior (5min-1h), and that it's self-aggregating. 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?

Two sentences followed by bullet points. Every sentence adds value without redundancy. Front-loaded with the core action, then use cases and context. No fluff.

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 (1 optional param, no output schema), the description provides complete context: what it returns, use cases, caching, privacy, and data source. Annotations richly cover behavioral hints. Nothing missing.

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

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

The schema covers the 'window' parameter with enum descriptions (100% coverage). The description adds nuance: 'Shorter windows surface what's hot right now; longer windows show steady-state demand.' This provides meaningful behavioral guidance beyond the schema.

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

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

The description clearly states it returns 'top tools, top packs, and total call volume' over a window. The verb 'returns' and resource 'trending data' are specific. It distinguishes from siblings like 'discover_tools' and 'ask_pipeworx' by focusing on trending signals rather than listing all tools or answering questions.

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

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

Three concrete use cases are listed (discovering hot data sources, confirming canonical tools, seeing use case alignment). While it doesn't explicitly say when not to use it or mention alternatives, the guidance is clear and actionable for an AI agent.

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

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

Annotations indicate readOnly, openWorld, idempotent, non-destructive. The description adds critical behavioral context: fill check logic, semantic anchor similarity filter, partition filter with placeholder fraction, and warning against trading when realizable edge ≤ 0. 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 for modes, filters, and response format. Every sentence adds value, though some technical details (like Jaccard threshold) could be compressed. Length is justified by 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?

No output schema, but description fully details response structure (opportunities array, partition_check, fill check). Covers error conditions (skipped_low_similarity, placeholders_filtered) and trade advice, making it complete for agent use.

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

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

Schema coverage is 100%, but description adds significant meaning: explains each parameter's purpose, provides example values (e.g., 'fed-decision-may-2026'), and notes that full URLs are accepted. Goes well beyond basic 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: finding arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It distinguishes itself from sibling tools like polymarket_edges and polymarket_fill_risk by focusing on arbitrage detection across events.

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

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

Provides explicit guidance on when to use each mode: no args for trending scan, 'event' for specific markets, 'topic' for cross-event scanning. Also directs users to polymarket_fill_risk for custom sizing, making selection clear.

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

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

Annotations already declare readOnlyHint, idempotentHint, etc. The description adds valuable context: caching behavior ('Cached 1h at the KV level'), response structure including diagnostics, and how edge is calculated. 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 quite long (over 400 words) and dense with technical details. While well-structured with sections, it could be more concise. The front-loaded purpose sentence is helpful but the overall length may hinder quick parsing by an agent.

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

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

Given the complexity and no output schema, the description is remarkably complete. It explains the three model segments, response top-level fields (by_segment, fed_candidates, _diagnostics), knobs, and even diagnostics for empty segments. It covers all necessary context for an agent to understand what the tool 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?

Schema coverage is 100% with detailed parameter descriptions. The description adds context on how knobs like min_liquidity and max_spread_pp filter tradeable edges, and explains the purpose of min_partition_leg_kelly. This goes beyond the schema's descriptions.

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

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

The description clearly states the tool scans top Polymarket markets to return opportunities where Pipeworx data disagrees with market price. It specifies the models used and segments, making it distinct from siblings like polymarket_arbitrage which likely focus on pure 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 mentions 'what should I bet on today' as a use case, but does not explicitly state when not to use it or provide alternatives. Given the sibling tools (e.g., polymarket_arbitrage, polymarket_edge_tracker), more explicit guidance would help differentiate.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, and no destructiveness. The description adds significant behavioral context: it uses daily snapshots, tracks time-series, computes trend and decay, handles expired opportunities, and notes limits (60-day TTL, snapshot enablement). No contradiction with annotations.

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

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

The description is dense with information but front-loaded with purpose. Every sentence contributes value, but it could be slightly more concise by trimming redundant phrasing while retaining all key 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 complexity of time-series tracking and lack of output schema, the description fairly completely covers response fields (tracked, expired, snapshot_dates) and limits. Minor gaps like missing pagination or examples are acceptable for this type of tool.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds value by specifying defaults, clamp ranges, and the meaning of window families. It also explains the response structure, which is not in the schema.

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

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

The description clearly identifies the tool's purpose: providing edge persistence and decay telemetry from daily snapshots. It distinguishes itself from sibling tools like polymarket_edges by focusing on time-series analysis and answering a specific question about edge longevity.

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 assess if an edge is fresh or aged) and provides context about what differentiates a fresh wide edge from an old one. However, it does not explicitly state when not to use it or mention alternatives like polymarket_edges for raw snapshots.

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, destructiveHint) are non-contradictory. The description adds behavioral details: walks the order-book ladder, returns specific fields like slippage_pp and forced_directional_risk, and warns about the dominant loss mode (unhedged directional positions from partial basket fills). This goes beyond annotations.

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

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

The description is thorough but slightly verbose. However, it is well-structured with capital labels (SINGLE-MARKET, BASKET) and bullet-like lists within prose. Every sentence adds value, but could be tightened slightly without losing meaning.

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

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

Despite lacking an output schema, the description fully documents return values for both modes: for single-market (top_of_book, vwap_fill_price, slippage_pp, etc.) and basket (theoretical_sum, realizable_sum, capture_ratio, profit_usd, thin_legs, etc.). It also covers edge cases like forced_directional_risk. The tool is complex, and the description is complete.

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

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

Even with 100% schema coverage, the description adds meaning: explains default size_usd (1000), clamp range (10-1,000,000), how size_usd is interpreted differently for single-market vs basket, and the auto-detection logic for side in basket mode. This significantly enriches 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 precisely states the tool checks 'realizable-vs-theoretical edge against live CLOB order-book depth'. It clearly distinguishes between single-market and basket modes, and specifies the exact use cases (e.g., before acting on arbitrage signals). This leaves no ambiguity about what the tool does and how it differs from siblings.

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

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

Explicit guidance is provided: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500'. It also explains why (theoretical overround not capturable on thin books, partial basket fills create unhedged directional risk). This is exemplary usage context.

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

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

Annotations declare read-only, open-world, idempotent, non-destructive. The description adds extensive behavioral detail: compatibility_warning conditions (non-equivalent bet shapes, unrelated events), temporal_alignment field, and skipped_cross_type/cross_subtype counters. 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 lengthy but well-structured with bold headers and bullet points. It front-loads the core purpose and then details safety fields. Every sentence adds value, though could be slightly more concise.

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

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

Without an output schema, the description explains the response structure (leg-by-leg prices, top_spreads_pp, safety fields) and edge cases (compatibility_warning, temporal_alignment). It is complete for a tool of this complexity.

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

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

Schema coverage is 100% with descriptions for all three parameters. The description adds value by explaining how parameters interact (explicit overrides topic) and providing context for mode selection. Examples in schema further aid understanding.

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

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

The description clearly states the tool computes cross-venue spread between Kalshi and Polymarket for the same resolving question. It specifies two distinct modes (topic shortcuts and explicit tickers) and explains the response includes spread values. This differentiates it from sibling tools 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 gives explicit guidance on when to use each mode: topic mode for 10 pre-mapped macros, explicit mode for custom pairings. It warns that most pre-mapped topics currently return compatibility_warning, so pre-mapped ≠ tradeable. It also explains when spreads are meaningless (e.g., temporal misalignment) via safety fields.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. Description adds scoping to identifier and pairing with remember/forget, providing useful context beyond annotations. 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?

Efficient, well-structured three sentences. Front-loaded with purpose, then usage details. 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 simple tool with one optional parameter and no output schema, the description fully covers usage, scoping, and relationship to siblings.

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 optional key parameter. Description adds that omitting key lists all keys, which is not in schema description, adding significant 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 saved via remember or lists all keys, distinguishing it from sibling tools (remember, forget).

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

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

Explicitly states when to use (look up context stored earlier) and mentions pairing with remember/forget. Lacks explicit when-not or alternatives, but the context is clear enough.

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

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

The description states that setting mark_read=true flags events as read, modifying state. However, annotations declare readOnlyHint=true and idempotentHint=true, indicating no state change. This is a direct contradiction, leading to a score of 1 and annotation_contradiction=true.

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

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

The description is three concise sentences, starting with the main purpose. Each sentence adds essential information: return fields, filtering, mark_read behavior, and alternative access. 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?

Given no output schema, the description sufficiently explains the return structure (source, citation_uri, raw payload). It covers key behaviors like mark_read and unread_only. Missing details on default ordering or error conditions are minor given the tool's simplicity.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the effect of mark_read and providing examples like 'sec_8k' for type. This enhances understanding beyond the schema descriptions.

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

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

The description clearly states the tool 'pulls fired events from your subscription feed.' It specifies the resource (fired events/alerts) and action (pull), and distinguishes from siblings like 'list_subscriptions' which lists subscriptions rather than events.

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: filtering by type and since, managing read status with mark_read, and mentions an alternative URL for scripts and dashboards. It lacks explicit when-not-to-use compared to other tools, but the context suggests it's for reading existing alerts.

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

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

Annotations provide readOnlyHint, openWorldHint, idempotentHint, destructiveHint false. The description adds substantial behavioral context: it makes one parallel call, fans out to multiple sources, soft-fails for patents due to API sunset, accepts ISO date or relative shorthand, returns structured changes grouped by source. 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 moderately long but efficient. It front-loads with example queries, then concisely details behavior, parameters, and return structure. Every sentence adds value. A very minor reduction for slight verbosity in the source listing, but 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 details return structure: 'changes[] grouped by source + total_changes count + pipeworx:// citation URIs'. It also mentions soft-fail for patents and the parallel call behavior. For a tool with multiple data sources and no output schema, this is complete enough 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?

Schema description coverage is 100%. The description adds meaning beyond the schema: explains `type` is limited to 'company', `value` can be ticker or CIK, and `since` accepts ISO date or relative shorthand with a recommendation ('30d' or '1m'). It also clarifies the window semantics in 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 starts with concrete example queries ('What's new with X', 'latest on Y'), then clearly states it's a 'change feed for a company in the last N days/weeks/months in ONE parallel call'. It specifies data sources (SEC EDGAR, GDELT→GNews, USPTO) and explicitly distinguishes from sibling `entity_profile`. The purpose is unmistakable.

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

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

The description explicitly tells when to use `entity_profile` instead ('when you want the static profile... regardless of window'). It also clarifies the tool handles multiple sources in one call, with fallback behavior (GDELT→GNews). No mention of when not to use beyond the sibling alternative, but that is sufficient for clear 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 indicate idempotentHint=true and destructiveHint=false, and the description adds behavioral context: key-value storage, scoping by identifier, and retention details (persistent for authenticated users, 24 hours for anonymous). 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 a single paragraph that covers purpose, usage, paired tools, and retention. It is reasonably concise and front-loaded with the main function, though it could be slightly more terse.

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

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

With only two simple required parameters and no output schema, the description adequately covers the tool's behavior: it explains what it stores, how it is scoped, and how it integrates with other tools. 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% (both parameters described). The description adds value by providing example keys (e.g., 'subject_property', 'target_ticker') that clarify usage beyond the schema's generic descriptions.

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

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

The description clearly states the tool's purpose: saving data for reuse across conversations and sessions. It provides specific examples (resolved ticker, target address, user preference) that distinguish it from sibling tools like 'forget' and 'recall'.

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

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

The description explicitly advises using the tool when discovering something worth carrying forward and mentions pairing with 'recall' and 'forget'. It differentiates persistence between authenticated and anonymous sessions, offering 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 indicate read-only, idempotent, open-world, non-destructive behavior. The description adds valuable context: graceful degradation when LEI/FIGI sources are unavailable, explicit 'unresolved' identifier disclosure, and internal multi-endpoint cascading. These details enrich understanding beyond the annotations.

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

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

The description is long but densely packed with useful information and well-structured with sections for supported types, enrichment behavior, and fallback guarantees. It starts with user queries and a clear directive. While slightly verbose, every section contributes contextual value 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?

Given the tool's complexity and lack of output schema, the description explains returned identifiers, unresolved handling, and fallback behavior. It covers key edge cases (ISIN, non-US issuers) and sets expectations for internal behavior. This is sufficient for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 100%, but the description significantly extends parameter meaning. It details accepted input formats for 'value' (ticker, CIK, ISIN, name), explains special cases like ISIN resolving to legal entity via GLEIF, and describes what 'drug' returns. This is far beyond the schema's short descriptions.

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

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

The description clearly states the tool resolves user-spoken names to official identifiers, using specific verbs and examples like 'resolve a user-spoken NAME to the canonical/official identifiers'. It distinguishes from siblings by emphasizing 'Use FIRST whenever you have a name but need an ID' and listing supported entity types.

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 use this tool first when a name is known but an ID is needed. It also notes that internal cascading replaces 2-3 manual lookups, which clarifies efficiency. However, it does not explicitly mention when not to use it or name alternative tools for situations when an ID is already known.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description adds behavioral context: probes each entity with ai_visibility_check, returns ranked list with score, confidence, signal density. This enriches understanding beyond annotations.

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

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

Two sentences, front-loaded purpose, no wasted words. Every sentence adds value: main action, internal method, example use case, output 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 4 parameters, no output schema, and rich annotations, the description covers the tool's purpose, internal behavior, and output format. It explains the probing mechanism and return metrics, which is sufficient without an output schema.

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

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

Schema description coverage is 100% with each parameter described. The description adds extra meaning: first entity treated as 'subject' for narrative, rest as competitors. Provides example for 'context' parameter. Adds value beyond schema alone.

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

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

The description clearly states the tool compares AI visibility across multiple entities side-by-side, with specific verb and resource. It distinguishes from sibling tool ai_visibility_check by focusing on multiple entities and ranking. Example use case enhances clarity.

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 it's useful for competitive AI-marketing audits and explains when to use (comparing your brand + N competitors). It lacks explicit when-not-to-use or alternative mentions, but the context is clear enough for an agent.

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

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

Annotations already mark the tool as read-only, open-world, idempotent, and non-destructive. The description adds substantial behavioral context: it fans out to two external services, returns a structured summary block with specific fields, per-advisory details, links, and recent alternative versions. It also discloses that bundlephobia's first measurement can take 5-30 seconds and that sources_failed will list timeouts gracefully.

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

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

The description is well-structured and front-loaded with the core purpose. Each sentence adds value: high-level purpose, details of what is checked, usage examples, ecosystem limitation, and failure behavior. No redundant information.

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

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

Given the tool's complexity (fans out to two services, returns structured data, handles partial failures), the description covers all necessary aspects: exact return fields (summary block), advisory details, links, recent versions, timing on bundlephobia, and fallback for other ecosystems. Since there is no output schema, the description adequately explains the return format.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds value by mentioning that scoped packages (e.g., @types/node) are accepted for the package parameter, and that the version parameter defaults to the latest published version. This extra context justifies a score above the baseline of 3.

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

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

The description clearly states the composite check for npm packages, specifying it fans out to deps.dev and bundlephobia for license, advisories, version history, bundle size, dependency count, and ESM/tree-shake support. It distinguishes from siblings by noting the npm ecosystem limitation and fallback for other ecosystems, making the purpose specific and actionable.

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 given: 'Use whenever an agent asks is X safe / popular / small or what does adding lodash cost me.' It also specifies when not to use it (non-npm packages) and points to the alternative fallback (deps.dev:version directly). Partial failure handling is clearly explained.

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: specifies search domain (SG stats), keyword-based search, and output format. Annotations already cover safety and idempotency, so description enhances behavioral understanding.

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 with no filler. Efficiently conveys core functionality and relationship to sibling tools.

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

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

Simple tool with complete annotations and schema. Description explains output and ID usage. No need for more given low complexity.

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

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

Schema coverage is 100% with descriptions for both parameters. Description provides examples but adds limited new meaning beyond 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?

Description clearly states it searches Singapore official statistics tables by keyword, returns resource ids and titles, and distinguishes from siblings by mentioning table_data and table_metadata.

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?

No explicit when-to-use or when-not-to-use for alternatives, but implies use to get resource IDs for table_data and table_metadata. Lacks guidance on when to prefer this over other search tools.

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

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

Annotations already mark the tool as read-only, idempotent, etc. The description adds technical details: BGE embeddings, 500-char windows, 200K char cap with truncation flagging, providing behavioral context beyond annotations.

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

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

The description is two sentences plus a technical note, front-loaded with the core action and use case. Every sentence serves a purpose without redundancy.

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

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

Given no output schema, the description adequately explains return content (passages with offsets and scores) and notes technical limits. It covers the main context needed for correct invocation.

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

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

Schema coverage is 100%, and the description adds value with default/range for limit, examples for query, and a constraint on text size (200K chars). This goes beyond the schema descriptions.

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

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

The description clearly states the tool's purpose with a specific verb ('search'), resource ('inside a fetched record'), and details on output (passages with offsets and scores). It distinguishes from siblings by mentioning the pairing with ask_pipeworx_grounded.

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

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

The description explicitly advises using when the record is too large for the prompt and explains how it reduces context usage. It also notes pairing with ask_pipeworx_grounded, though it does not explicitly list 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 indicate readOnlyHint=false, destructiveHint=false, idempotentHint=true. Description confirms it creates a subscription (write, non-destructive, idempotent). It adds behavioral details: webhook secret returned only once, auto-disable after 10 failures, SMS cap, phone verification requirement. 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 well-structured: first sentence states purpose and return value, then requirements, then type-specific details, then delivery channels. Every sentence adds value without redundancy. Front-loaded with key information.

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

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

Given no output schema, the description explains the return value ('new subscription id'). It covers all parameters with examples, side effects (webhook secret one-time), and constraints (sms cap, phone verification). The tool's complexity (multiple types, delivery channels) is fully addressed.

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 goes far beyond: it explains each type's params with syntax examples, delivery channel options with constraints, webhook signing mechanics, and phone verification requirement. This adds significant value beyond the schema.

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

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

The description clearly states 'Create a proactive monitoring subscription to a live-data event stream' and 'Returns the new subscription id.' It distinguishes itself from sibling tools like list_subscriptions and unsubscribe by focusing on creation. The scope (types, delivery channels) is explicit.

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

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

The description specifies when to use (creating a subscription for live data events) and requirements (Pipeworx OAuth account). It gives detailed type examples. While it doesn't explicitly state when not to use, the context and sibling tool names imply alternatives for modification and listing.

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 and non-destructive, so tool is safe. Description adds useful context about returning live example questions with exact tool calls, but doesn't add new behavioral constraints. 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 packed with information but front-loaded with user queries. Slightly long but every part is useful; minor improvement could trim redundant phrasing.

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 discovery tool with one optional param and no output schema, description explains return structure (category-bucketed examples with tool calls) adequately. Could mention output format type but overall sufficient.

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

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

Schema coverage is 100% and description adds value by listing example values for topic and explaining omission behavior, going beyond the schema description.

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

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

Description clearly states it's an onboarding entry point that returns category-bucketed example questions, distinguishes from sibling tools like ask_pipeworx by being the first-use tool. Includes specific verbs and examples.

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 this FIRST when you do not yet know what Pipeworx can do for you' and gives context for when to call (agent just connected). Mentions alternatives implicitly via 'meta-tools'.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds value by detailing the return structure (Data with row array of series containing dated columns). 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 three sentences: first sentence gives core purpose and data structure, second explains filtering, third covers pagination. It is front-loaded and concise with no unnecessary words.

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

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

Despite no output schema, the description explains the return format (Data with row array of series containing dated columns). It covers filtering and pagination. Parameter count is 7 but required only 1, and schema provides descriptions. The description is sufficient for correct 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 description coverage is 100%, so all parameters are described in the schema. The description mentions timeFilter and between specifically but does not add substantial meaning beyond 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 states it fetches time-series data rows for a Singapore statistics table by resourceId, distinguishing it from sibling tools like search_tables (which retrieves IDs) and table_metadata (likely metadata). It also describes the returned data structure.

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 (after getting resourceId from search_tables) and how to filter time periods with timeFilter or between and paginate with offset/limit. It does not explicitly state when not to use or provide alternatives, but the context is clear.

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

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

Annotations already declare readOnly, idempotent, non-destructive. The description adds behavioral detail: the result location under 'Data.records' and the specific fields returned (theme, subject, frequency, period coverage, variables/series). This adds value beyond annotations, though it could mention error handling or data limits.

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. The first sentence captures the core purpose and required input, the second tells where to find the result. No superfluous words, well-structured.

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

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

Given the tool's simplicity (1 parameter, no output schema, but rich annotations), the description is fairly complete. It lists the types of metadata returned and the location. Missing details like data format or pagination, but these are minor for such a 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 description coverage is 100% for the sole parameter 'resourceId', with a clear description and example. The tool description repeats the example but does not add new semantic information. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states the verb 'Get' and the resource 'structure/metadata for a Singapore statistics table'. It also tells how to obtain the required resourceId from the sibling tool 'search_tables', making the purpose unambiguous.

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

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

Explicitly instructs to 'get ids from search_tables', which tells the agent when to use this tool (after obtaining a resourceId). It does not explicitly state when not to use, but the context is clear. A more detailed exclusion would improve it further.

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 non-destructive (destructiveHint false). Description adds valuable detail: deactivation (not deletion) preserves historical events via recent_alerts, enriching behavioral understanding 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 efficiently convey main action, constraints, and behavioral nuance. No redundant information; every sentence earns its place.

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

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

Covers key aspects: ownership, soft-deletion, and linkage to recent_alerts. No output schema needed for this simple idempotent tool. Could mention error handling or return value, but overall complete for the use case.

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

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

Schema covers 100% of parameters with a clear description ('Subscription id (uuid) returned by subscribe'). Description does not add further parameter semantics, so baseline score of 3 is appropriate.

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

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

The description clearly states the action (Cancel) and resource (subscription by id). It distinguishes from siblings like subscribe and list_subscriptions by specifying ownership enforcement and soft-deactivation behavior.

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

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

Explicitly states ownership enforcement (only cancel own subscriptions), providing clear usage boundaries. Lacks explicit mention of alternatives, but the context is sufficient for agent decision-making.

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, openWorldHint, idempotentHint), the description discloses the two-pipeline routing (SEC EDGAR for financial claims vs. grounded pipeline for others), the exact verdict options, and the critical distinction between 'could_not_verify' and 'unsupported'. It also explains the verification_error payload and how to interpret non-results, which is essential 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 longer than the ideal two-sentence example but front-loads the purpose with concrete examples and use cases. Each subsequent section (pipeline routing, verdict types, error semantics, efficiency claim) earns its place with actionable details. It is well-structured and avoids repetition, though it could slightly trim redundant phrasing.

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

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

Given the tool's complexity (two pipelines, nuanced verdicts, error states) and the absence of an output schema, the description thoroughly covers return values, verdict semantics, and error handling. It also states the efficiency advantage over sequential calls, making it self-contained for an agent to invoke and interpret results.

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

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

The schema already provides descriptions for both parameters (100% coverage). The description adds significant nuance: tolerance_pct overrides the wording-implied tolerance with a default cap of 5, and is explicitly useful for hallucination detection where material errors must be refuted. It also explains claim routing based on claim content, enriching the semantic understanding of the 'claim' parameter.

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

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

The description explicitly states it performs natural-language claim verification against authoritative sources, using specific verbs like 'fact check' and 'verify the claim'. It distinguishes from sibling tools by focusing on factual claim checking and noting it replaces 4–6 sequential calls, making its purpose unambiguous.

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

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

It provides clear usage context: 'Use whenever the agent needs to check whether something a user said is factually correct.' It also differentiates between company-financial claims and other claims, and describes when to use a custom tolerance for hallucination detection. However, it does not explicitly name alternative sibling tools or state when not to use it beyond the general claim focus.

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