Singstat Sg

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

Annotations already indicate safe, read-only, idempotent behavior. Description adds context about default model, optional Anthropic with BYO key, and return structure, providing useful behavioral detail.

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 short, front-loaded with purpose, and every sentence adds necessary detail 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?

Despite no output schema, description adequately explains return values (per-model score, confidence, signals, raw_response + combined view). Parameter count and coverage are fully explained.

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

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

Schema coverage is 100%, but description adds value by explaining default model, optional models array, Anthropic API key usage, and context disambiguation role.

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?

Specific verb 'probe' and resource 'LLMs' clearly state the tool's function. Differentiates from sibling tools like 'scan_competitor_ai_presence' by focusing on visibility scoring across multiple models.

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

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

Describes use cases (AI-marketing audits, pre-launch brand checks, competitive monitoring) but does not explicitly state when not to use or compare with alternatives.

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

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

Description adds behavioral context beyond annotations: routes to 3,272 tools, fills arguments, returns structured answers with citation URIs, consistent with readOnlyHint and idempotentHint.

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

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

Well-structured: preference statement, domain list, routing explanation, usage triggers, and examples. Every sentence is informative, no redundancy.

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

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

For a single-parameter tool with no output schema, the description fully explains input, process, and return value, 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% with aliases explained; description provides helpful examples of valid questions, adding value beyond the schema, though it doesn't detail parameter semantics further.

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 answers factual questions using authoritative structured data with citations, distinguishing it from web search and listing specific domains like SEC filings, FDA data, and patents.

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

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

Explicitly says 'PREFER OVER WEB SEARCH' and provides detailed guidance on when to use, including specific query patterns and examples, though it doesn't explicitly list exclusions.

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

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

The description exhaustively explains behavioral traits: fan-out logic by category, resolver confidence levels with inspection recommendations, parent event extraction, news fallback handling on GDELT 429s, safety mechanisms for low-confidence matches, and status codes for closed markets. This adds significant context beyond the idempotentHint and readOnlyHint annotations. 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 excessively long with multiple paragraphs covering classifiers, fan-out examples, response shapes, resolver contract, parent event extractor, news fields, and safety notes. While detailed, it is not concise and lacks front-loading of the most critical information. It could be streamlined to a few key sentences for quick agent comprehension.

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 (classifiers, fan-out, resolver confidence, parent events, news failures, spread tradeability warnings), the description is remarkably complete. It covers edge cases like low-confidence matches, closed markets, and illiquid spreads, and explains how to interpret the resolver output before trusting analysis. Even without an output schema, the description provides sufficient context for correct invocation.

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

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

The input schema covers all three parameters with descriptions, achieving 100% coverage. The tool description adds value by clarifying the meaning of the 'depth' enum values ('quick = 2-3 evidence sources, thorough = full fan-out') and the behavior of 'include_raw' with size implications. The 'market' parameter is also explained with examples. The description complements the schema well.

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

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

The description clearly states the tool's function: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies the output: evidence packet and market-vs-model comparison. However, it does not explicitly distinguish this tool from siblings like polymarket_edges or polymarket_arbitrage, leaving some ambiguity about when to choose this over those.

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 concrete usage examples: 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z".' It also explains when the tool returns low_confidence_match or market_closed_or_inactive, giving guidance on interpreting results. However, it does not explicitly state when NOT to use this tool or suggest alternative tools for specific scenarios.

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

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

Annotations already indicate idempotent, read-only behavior. The description adds significant behavioral detail: data sources (SEC EDGAR/XBRL, FAERS), the fix for off-calendar fiscal years, sorting order (by revenue or adverse events), and the inclusion of pipeworx:// citation URIs. No contradictions with annotations.

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

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

The description is two sentences with the main purpose front-loaded. The second sentence is dense but structured with semicolons and parentheses, packing a lot of information without excessive verbosity. A slightly more structured format could improve scannability.

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

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

With no output schema, the description compensates by stating that results are 'paired data + pipeworx:// citation URIs per entity' and sorted by primary metric. It covers sources, type-specific outputs, and the fix for fiscal year handling. Missing are error cases or handling of missing data, but overall it's sufficiently complete for a comparison 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 clear enum and array descriptions. The description adds meaning by explaining what data is fetched for each type: for companies, 'LATEST 10-K revenue + net income + cash + long-term debt'; for drugs, 'adverse-event report counts, FDA approval counts, active trial counts'. This enriches the parameter semantics beyond the schema.

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

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

The description opens with the specific action 'Compare 2-5 companies (or drugs) side by side in one call', clearly stating the verb (compare), resource (companies or drugs), and scope. It distinguishes itself from siblings by noting it replaces 8-15 sequential lookups, leaving no ambiguity about its function.

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

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

Explicit use cases are listed: 'compare X and Y', 'X vs Y', 'which is bigger', or 'rank-by-metric questions'. It also contrasts with sequential lookups, providing clear context. However, it does not explicitly state when not to use this tool (e.g., for single entities), so it falls short of a 5.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds useful behavioral info: it returns top-N most relevant tools with full input schemas and curated examples, ready to call directly. 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 three sentences: first states purpose, second lists domains, third gives usage guidance. It is front-loaded, compact, and every sentence adds value.

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

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

Given the tool's complexity (6 parameters, 5 aliases, no output schema), the description is fairly complete. It explains output includes names, descriptions, and full schemas. Could be slightly more detailed about return format, but 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%, so baseline is 3. The description mentions aliases for the query parameter and notes the limit parameter, but doesn't add deeper semantics beyond what the schema already provides.

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

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

The description clearly states 'Find tools by describing the data or task' and enumerates many specific domains (SEC filings, FDA drugs, etc.). It distinguishes itself from sibling tools by being the discovery tool for browsing the available option set.

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

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

The description explicitly says 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' It also lists domains of applicability, providing clear guidance on when to use this tool.

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

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

The description provides extensive behavioral details beyond annotations: it explains the return structure (e.g., URIs for filings, fundamentals from latest 10-K), mentions fallbacks (GDELT→GNews), and notes that patents soft-fail. 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 fairly long but front-loads the main purpose and is well-structured with clear sections for returns and caveats. Every sentence adds value, though it could be slightly tighter without losing 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 thoroughly explains what each returned field contains, including data sources, sorting, and limitations (e.g., patents sunset, fundamentals version). It covers edge cases and provides all necessary context for an agent to use the tool correctly.

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

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

Schema coverage is 100%, and the description adds significant meaning: explains that value can be ticker or zero-padded CIK, that names are not supported, and suggests using resolve_entity first. Also clarifies the type enum only supports 'company'.

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

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

The description clearly states that the tool gets everything about a US public company in one call, specifying the exact data returned (cik, company_name, filings, fundamentals, patents, news, LEI) and limitations. It distinguishes from siblings by noting it replaces calling 10+ pack tools across multiple sources.

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

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

Explicitly tells when to use the tool (user asks "tell me about X", "research Acme", etc.) and when not to (names not supported, use resolve_entity first). Also warns about the sunset of the patents API.

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 destructiveHint:true and idempotentHint:true. Description adds context about clearing sensitive data but does not contradict annotations. It could mention the permanence of deletion, but given annotations, it's sufficient.

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: two sentences, front-loaded with purpose, then usage guidelines. No redundancy.

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

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

For a simple tool with 1 parameter, high schema coverage, and annotations present, the description is complete. It covers purpose, usage, and pairing without needing 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?

Only one parameter 'key' with description 'Memory key to delete'. Schema coverage is 100%, and the description adds no extra meaning beyond the schema. 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 'Delete a previously stored memory by key' with a specific verb and resource. It distinguishes from sibling tools like 'remember' and 'recall' by implying it is for deletion.

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

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

Provides explicit when-to-use scenarios: 'when context is stale, the task is done, or you want to clear sensitive data.' Also suggests pairing with 'remember' and 'recall', guiding the 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 declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds valuable behavioral details: fetching the page, extracting title/description/key links, emitting standard markdown, and output format. No contradictions.

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

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

Three sentences, front-loaded with purpose, then behavior, then use cases. Every sentence adds value without redundancy.

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

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

Despite lacking an output schema, the description fully specifies the output format (single text blob, standard markdown). Combined with annotations and schema, the tool is completely specified for an AI agent.

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

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

Schema coverage is 100%, so params are documented. The description adds context: 'Full URL' and 'Maximum number of link entries to include (default 25, max 50)', which clarifies defaults and limits 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 explicitly states that the tool generates a production-ready llms.txt file for any URL, covering the verb ('generate'), resource ('llms.txt'), and scope ('for any URL'). It lists specific use cases that distinguish it from sibling tools like ai_visibility_check.

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

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

The description provides clear use cases (getting client site indexed, drafting for own project, auditing competitor) but does not explicitly state when not to use it or mention alternatives. However, the context is sufficient for an agent to decide deployment.

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, the description discloses that feedback is free, doesn't count against quota, is rate-limited, and that the team reads it daily. 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 information-dense and well-organized, but the length could be slightly reduced without losing clarity. It efficiently conveys all necessary details.

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

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

Given the tool's parameter count, enum, nested object, and lack of output schema, the description thoroughly covers all aspects: use cases, constraints, and expected format. It is complete for the tool's complexity.

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

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

The description adds concrete examples and constraints for each parameter, such as specifying the message length (2000 chars) and providing examples for context fields (e.g., 'fred_get_series'). This enriches the schema, which already has 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 the tool's purpose: reporting bugs, requesting features, noting data gaps, or giving praise. It explicitly differentiates from sibling tools by focusing on feedback to the Pipeworx team.

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 scenarios for each type, and includes anti-patterns (e.g., don't paste end-user prompts). It also mentions rate limits and that it's free.

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

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

The description adds significant context beyond annotations: it notes the data is 'self-aggregating signal', 'derived from CF analytics-engine, no PII', and 'cached 5min-1h depending on window'. Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, but the description enriches understanding of the data source and caching behavior.

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

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

The description is well-structured with a clear opening sentence, numbered use cases, and technical notes. It is front-loaded with the core purpose. While slightly lengthy, every sentence contributes value.

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

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

Given the simplicity (1 optional parameter, no output schema), the description fully covers what the tool returns, the caching behavior, and the data source. No missing critical information.

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 parameter 'window' having enum and description. The description adds meaning by explaining the implication of shorter vs longer windows ('surfaces what's hot right now' vs 'steady-state demand'), which aids parameter selection beyond the enum values.

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

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

The description clearly states it returns 'top tools, top packs, and total call volume over a recent window'. The verb 'Returns' and resource 'trending tools/packs/volume' are specific. It distinguishes from sibling tools like 'discover_tools' by focusing on aggregated usage data.

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

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

The description explicitly lists three use cases: discovering data sources, confirming popular tools, and seeing alignment. It also explains window options and their purposes. However, it does not explicitly mention when not to use the tool or suggest alternatives among siblings.

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

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

The description adds significant context beyond annotations, detailing algorithmic steps (Jaccard similarity, partition filter), edge cases (skip_low_similarity, placeholder filtering), and the non-destructive nature. No contradiction with annotations (readOnlyHint, idempotentHint).

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

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

The description is well-structured and front-loaded, but could be slightly more concise. Every sentence is informative, though the response section could be streamlined.

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

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

Despite no output schema, the description fully explains the return structure (opportunities fields, partition_check). It covers both modes, filters, and edge cases, making it very complete for the tool's complexity.

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

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

Schema coverage is 100% and the description enriches both parameters by explaining how they enable different analysis modes, including examples. This goes well beyond a baseline of 3.

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

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

The description clearly states the tool's purpose: detecting arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It specifies two modes (event and topic) and uses specific verbs like 'find', 'walks', 'checks'. This differentiates it from sibling tools.

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

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

The description explains when to use each mode, with examples such as cross-event mode catching date threshold patterns. However, it does not explicitly exclude scenarios where this tool is inappropriate, nor compare to closely related siblings like 'polymarket_edges' or 'polymarket_kalshi_spread'.

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 and idempotent behavior. The description goes far beyond by detailing caching (1h at KV level), model algorithms (lognormal barrier, news momentum, partition overround), edge calculation (net of slippage), and diagnostic fields. No contradiction with annotations.

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

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

The description is lengthy but well-structured, front-loading the purpose and then detailing models, knobs, and response format. Each sentence adds value. A slightly tighter edit could improve conciseness, but it remains effective.

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

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

Given the complexity (9 parameters, no output schema), the description is exceptionally complete. It explains output segments (by_segment, diagnostics), caching, model families, and filtering logic. The only minor gap is the exact output format, but top-level fields are described.

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

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

Schema description coverage is 100%, so baseline is 3. However, the description adds substantial meaning by explaining how each knob interacts with the models (e.g., min_partition_leg_kelly applies to per-leg Kelly inside partitions, min_liquidity filters thin books). 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 it scans Polymarket markets and returns opportunities where Pipeworx data disagrees with market price, distinguishing it from siblings like polymarket_arbitrage. It explicitly says 'built for what should I bet on today' and lists three model families.

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 context for when to use the tool ('discover opportunities without paging hundreds of markets') and explains the purpose of each knob. It does not explicitly state when not to use it, but the context signals and sibling tools imply alternatives.

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

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

The description discloses significant behavioral traits beyond annotations, including safety fields, compatibility warnings, temporal alignment checks, and skipped cross-type/subtype counters. Annotations already indicate read-only, idempotent, etc., and the description adds rich context about when results are meaningful.

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 structured with clear sections (TWO MODES, RESPONSE, SAFETY FIELDS) and front-loads the core purpose. However, it is verbose with many technical details (e.g., skipped_cross_type explanations) that could be condensed without losing clarity.

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

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

Given the tool's complexity, high schema coverage, and lack of output schema, the description is comprehensive. It covers all modes, safety fields, temporal alignment, and edge cases (compatibility warnings), enabling an agent to use the tool correctly without additional 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 clear descriptions for each parameter. The description adds extra meaning by explaining how topic overrides explicit tickers and listing the 10 pre-mapped shortcuts. This provides practical context beyond the schema.

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

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

The description clearly states the tool computes cross-venue spreads between Kalshi and Polymarket for the same resolving question. It uses specific verbs like 'cross-venue spread' and distinguishes from siblings like polymarket_arbitrage by focusing on two-venue 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 explains two modes (topic shortcuts and explicit tickers) and provides examples. It also warns that most shortcuts return compatibility warnings. However, it does not explicitly contrast with alternatives like polymarket_arbitrage, so agents may need to infer when to use this tool over others.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds that the tool is scoped to an identifier and pairs with remember/forget, but no major behavioral traits beyond what annotations provide.

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

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

Description is three sentences: first states core function, second gives usage examples, third adds scope and pairing. It is front-loaded, efficient, and contains 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 no output schema, the description implies return values (value or list of keys) but does not explicitly state format. However, for a simple key-value retrieval, it is sufficiently complete with examples and scope clarification.

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 linking the key to 'remember' and explaining the omit-to-list behavior, which enhances understanding beyond the schema's description.

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

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

The description clearly states the tool retrieves a value saved via remember or lists all keys. It provides concrete examples (ticker, address, notes) and distinguishes from sibling tools remember and forget.

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

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

The description explicitly says 'Use to look up context the agent stored earlier' and contrasts with remember and forget. It implies when to use but does not explicitly state when not to use, though the context is clear.

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

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

The description reveals detailed behavioral traits beyond the annotations: parallel fan-out to multiple sources (SEC, GDELT/GNews, USPTO), fallback logic from GDELT to GNews on rate limits, soft-fail for USPTO due to sunset, and structured output with groupings and citation URIs. This adds significant context that is not present in the annotations (readOnlyHint, openWorldHint, etc.). No contradiction found.

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 of five sentences, each adding essential information: purpose, use cases, fan-out details, parameter explanation, and sibling tool differentiation. It is front-loaded with the core task. However, it could be slightly more concise by breaking into separate points or sentences, but overall it is efficient and well-organized.

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

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

Given the tool's complexity (multiple sources, parallel fan-out, fallbacks, sunsetting) and the lack of an output schema, the description provides a comprehensive picture: it explains the return structure (changes[] grouped by source + total_changes + citation URIs), covers parameter details, and addresses error handling (soft-fail for USPTO). This leaves little ambiguity for the agent to 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?

The schema provides 100% coverage (all three parameters have descriptions), but the description adds value by explaining accepted values for 'since' (ISO date or relative shorthand like '30d', '1y') and recommending a default ('Use "30d" or "1m" for typical monitoring'). It also clarifies that 'value' accepts ticker or CIK. This enhances the schema's information sufficiently to merit a score above baseline.

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

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

The description clearly states the tool's purpose: 'What's new with a company in the last N days/months?' and provides specific use cases like 'news on Apple this month'. It also distinguishes itself from the sibling tool 'entity_profile' by explicitly stating when to use that instead, making the purpose unambiguous and well-differentiated.

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

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

The description explicitly states when to use the tool (e.g., 'updates on Y', change-monitoring) and provides an alternative ('Use entity_profile instead when you want the static profile'). It also explains fallback behavior (GDELT→GNews) and sunsetting status (USPTO). However, it does not explicitly list scenarios where the tool should not be used, which would have earned a 5.

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

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

Annotations already indicate idempotent and nondestructive. Description adds scoping by identifier, persistence for authenticated users, and 24-hour retention for anonymous sessions, providing useful 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?

Four sentences, front-loaded with purpose, each sentence adds necessary detail without redundancy.

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

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

For a simple key-value store with no output schema, the description fully covers purpose, usage, scoping, persistence, and sibling tools.

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

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

Schema covers both parameters with descriptions. Description adds examples like 'subject_property' and clarifies value as 'any text', adding marginal practical guidance.

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

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

The description clearly states the tool saves data for reuse, with specific examples like resolved tickers and user preferences. It distinguishes from sibling tools 'recall' and 'forget'.

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

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

Explicitly states when to use ('discover something worth carrying forward') and mentions alternatives: pair with recall to retrieve, forget to delete.

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

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

The description adds significant behavioral context beyond the annotations (readOnlyHint, etc.), including that each call cascades through several lookup endpoints internally, replaces 2-3 manual lookups, and provides specific citation URIs (pipeworx://edgar/company/{cik}, pipeworx://rxnorm/{rxcui}). No contradiction with annotations.

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

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

The description is well-structured with the main purpose first, followed by detailed type-specific breakdowns. It is slightly long but every sentence adds meaningful information. The use of headers (SUPPORTED TYPES) and bullet-style lists improves readability.

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 values for both entity types (ticker, CIK, company name, RxCUI, ingredient, brand, citation URIs). It covers supported input formats and disambiguation. It could be slightly more explicit about the structure of the return, but it is largely complete for a lookup tool.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by giving concrete examples for 'value' (ticker, CIK, or name for company; brand or generic name for drug) and noting auto-disambiguation. It also explains the difference between the two types. This exceeds the schema's minimal 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 canonical/official identifiers, lists supported types (company, drug) with specific return fields, and explicitly says to use it first when you have a name but need an ID. It distinguishes itself from siblings by noting it replaces multiple manual lookups.

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

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

The description gives explicit guidance: 'Use FIRST when you have a name but need an ID.' It also mentions that it replaces 2-3 manual lookups, implying efficiency. However, it does not explicitly state when not to use it or compare to alternatives like search_tables or entity_profile, which could accept IDs.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive. The description adds that it probes each entity, ranks, and returns score/confidence/signal density. It does not reveal any additional behavioral traits like rate limits or auth details beyond the _apiKey parameter.

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 appropriately sized (3-4 sentences), front-loaded with the core purpose, method in second sentence, use case in third, and output in last. Every sentence earns its place, though slightly more concise could be possible.

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

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

The description explains the return value (ranked list with score, confidence, signal density) despite no output schema. It covers how it works (probes with ai_visibility_check), making it complete for a tool with 4 parameters and 1 required.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add significant meaning beyond the schema; it mentions 'your brand + N competitors' aligning with the entities parameter but does not elaborate on other parameters.

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

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

The description clearly states the tool compares AI visibility across multiple entities side-by-side, using ai_visibility_check for each, and ranks them. It distinguishes from the sibling ai_visibility_check (single entity) by explicitly mentioning 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 provides a clear use case ('competitive AI-marketing audits' with example question) and implies this is for multi-entity comparison while ai_visibility_check is for single. However, it does not explicitly state when not to use or list alternatives beyond ai_visibility_check.

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

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

The description adds substantial behavioral context beyond the annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint false). It details partial failure degradation ('sources_failed will list it if it times out'), latency ('bundlephobia first measurement can take 5-30s'), and the composite nature with graceful dependency on external services. No contradiction with annotations; the description aligns with the open-world and read-only hints.

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 of moderate length, but every sentence carries essential information (purpose, when to use, return fields, limitations, failure modes). It could be structured with bullet points or clearer separation for faster parsing, but it remains efficient for the complexity conveyed. No superfluous content.

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

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

For a composite tool with no output schema, the description thoroughly explains the return fields (summary block, per-advisory detail, links, alternative versions), external sources, limitations, and graceful degradation. It covers the full scope of what the agent needs to understand the tool's behavior and results. Given the tool's complexity, this is highly 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?

The input schema already has 100% description coverage (both 'package' and 'version' are described). The description adds value by clarifying that scoped packages are accepted for 'package' and that 'version' defaults to latest, which enhances understanding beyond the schema. This exceeds the baseline of 3 for high schema coverage.

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

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

The description clearly states the composite purpose: 'Composite should I add this npm package to my project check in ONE call', specifying the exact verb (check) and resource (npm package). It distinguishes from siblings by narrowing to npm ecosystem, which is unique among the sibling tools (none other focus on npm dependency analysis).

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 usage context is provided: 'Use whenever an agent asks is X safe / popular / small or what does adding lodash cost me'. This directly guides the agent on when to invoke. Ecosystem limitations are stated ('NPM ecosystem only in v1'), and partial failure handling is mentioned. However, there is no explicit when-not or direct comparison to sibling tools.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false. The description adds context about the data source (Department of Statistics Singapore) and the output format (resource ids and titles), plus the ID usage in sibling tools. 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?

Two sentences, no wasted words. Front-loaded with purpose and output, then efficient linkage 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?

For a simple search tool, the description covers purpose, output, and relationship to other tools. It lacks details on pagination, error handling, or full output structure, but given no output schema, it is reasonably 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?

The input schema already documents both parameters with descriptions (100% coverage). The description adds only an example keyword set ('population', 'gdp', 'cpi'), which is marginal extra value.

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

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

The description clearly states it searches Singapore official statistics tables by keyword and returns resource IDs and titles. It explicitly differentiates from sibling tools table_data and table_metadata by explaining how the ID output is used by them.

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

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

The description implies usage for finding tables given a keyword, but does not explicitly state when to use this tool versus alternatives like table_data or other sibling tools. No exclusions or when-not scenarios are mentioned.

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

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

Annotations already indicate the tool is read-only, idempotent, and non-destructive. The description adds value by explaining the return structure: data is under 'Data' with a '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 two sentences long, front-loading the purpose and return structure, then detailing parameter usage. Every sentence contributes essential information 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?

Despite having no output schema, the description explains the return format sufficiently. It covers all major behaviors: fetching rows, filtering by time periods, and pagination. For a tool with 7 parameters, the description is complete and actionable.

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

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

The input schema covers all 7 parameters with descriptions (100% coverage), so baseline is 3. The description adds further clarity with examples for 'timeFilter' and 'between', and explains pagination semantics, which enhances the schema's content.

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

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

The description clearly states the tool fetches time-series data rows for a Singapore statistics table by resourceId, and it directs users to the sibling tool 'search_tables' to obtain the resourceId. It distinguishes itself from siblings by focusing on data rows rather than metadata or other functions.

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 guidance on how to use the tool, including parameter usage for filtering with 'timeFilter' and 'between', and pagination with 'offset/limit'. It also references the sibling tool for obtaining the required resourceId. However, it does not explicitly mention when not to use this tool or alternatives, which could be improved.

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, covering safety and idempotency. The description adds value by noting 'Result is under Data.records', which helps agents navigate the response structure.

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 the core purpose, no redundant words. Every sentence adds necessary context.

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

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

No output schema exists, but the description compensates by stating where to find results. For a simple tool with one parameter and clear sibling context (search_tables, table_data), this is sufficiently 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% with the single 'resourceId' parameter having a clear description and example. The tool description adds no further parameter details, so baseline 3 is appropriate as the schema already 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?

The description clearly states the verb 'get', the resource 'structure/metadata for a Singapore statistics table', and the key identifier 'by resourceId'. It distinguishes from sibling tool 'search_tables' by referencing it for ID retrieval, and from 'table_data' which likely retrieves actual data.

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

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

The description explicitly directs users to get IDs from search_tables, providing a clear context for when to use this tool. While it lacks explicit 'when not to use' statements, the distinction from data retrieval is implicit in 'metadata'.

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

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

Discloses output details (verdict, structured form, actual value with citation, percent delta) and efficiency (replaces multiple calls). Annotations already indicate readOnly, idempotent, openWorld; description adds value beyond annotations.

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

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

Well-structured, provides purpose, usage, scope, output, and value proposition without fluff. Slightly long but every sentence adds value.

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

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

No output schema, but description fully explains outputs. Covers scope, limitations, and use case. For a single-parameter tool with rich annotations, it 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?

Single parameter 'claim' with schema coverage 100%. Schema description already explains it well. Description reinforces but doesn't add significant new semantics beyond the schema.

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

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

Clearly states it fact-checks natural-language claims against authoritative sources, specifies scope (company-financial via SEC EDGAR), and distinguishes from siblings by noting it replaces 4-6 sequential calls.

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

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

Explicitly says when to use (agent needs to verify a user's factual claim) with example queries. Does not explicitly list sibling alternatives for non-financial claims, but scope limitation is clear.

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