Scb Se

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

Annotations already indicate safe, idempotent, non-destructive behavior. The description adds value by detailing the return structure (per-model score, confidence, signals, raw_response + combined view) and cost implication for Anthropic calls.

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 with no fluff. The main purpose is stated first, followed by model options, return format, and use cases. 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?

The description covers return values despite no output schema, and explains model selection and parameter details. It could clarify what 'signals' includes, but overall it is sufficiently complete for a 4-param 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 context beyond schema, especially for _apiKey (BYO key, direct payment) and context parameter (disambiguation). This extra info justifies a higher 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 probes LLMs for visibility scoring (0-100) per model, using a specific verb and resource. It distinguishes from siblings like 'scan_competitor_ai_presence' by focusing on multi-model brand visibility audits.

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 default free model, optional paid Anthropic probe via _apiKey, and lists use cases (AI-marketing audits, pre-launch checks). It lacks explicit exclusion guidance or alternative tool mentions but provides clear context.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, no destruction. The description adds behavioral details: routing to 3,436 tools, filling arguments, returning citations. 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 with key message front-loaded, examples, and clear scope. Slightly lengthy but every part 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 simple input and no output schema, the description explains routing and citation output. Covers use cases, trigger phrases, and examples. Lacks edge case handling but sufficient 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% with 6 aliases for a single question parameter. Description confirms natural language input but adds little 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?

The description clearly states the tool answers factual questions about real-world data with citations, explicitly preferring it over web search. It provides specific examples and distinguishes itself from siblings by its broad coverage of authoritative 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?

The description gives clear guidance on when to use (prefer over web search for structured data) and trigger phrases ('what is', 'look up'). It lacks explicit exclusion of sibling tools but provides strong contextual cues.

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

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

Annotations indicate safe, read-only, idempotent behavior. Description adds extensive detail: market resolution, classification, parallel fan-out, evidence packet, safety mechanisms (low-confidence, closed markets), resolver contract, parent event extraction, news fallback, and tradeability notes. No contradiction with annotations.

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

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

Description is lengthy but well-organized into labeled sections (CLASSIFIERS, FAN-OUT EXAMPLES, etc.). Front-loaded with core purpose. Every section adds value given tool complexity. Minor redundancy in explanation of resolver behavior.

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 details response shapes (result.market, result.analysis, result.evidence) with specific fields. Covers edge cases: low-confidence, closed markets, wide spreads, news fallback. Fully compensates for lack of 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 covers all 3 parameters with descriptions. Description adds significant extra context: explains market input types (slug, URL, question), depth default 'thorough', include_raw default false with recommendation. Provides examples of inputs and explains how each parameter affects behavior.

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

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

Clearly states the verb 'research', the resource 'Polymarket bet', and the action 'pulling Pipeworx data'. Provides multiple input types and distinguishes itself from siblings like polymarket_edges by offering comprehensive research.

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 suggests use cases ('should I bet on X', 'what does the data say', 'is there edge'). Provides examples of fan-outs but does not explicitly state when not to use it versus siblings, though the comprehensive nature implies uniqueness.

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, openWorldHint, idempotentHint, and destructiveHint. The description adds behavioral details like data sources (SEC EDGAR/XBRL, FAERS), fiscal year handling, and sorted results, which are beyond the annotations.

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

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

The description is a single, information-dense paragraph that front-loads the purpose and usage. It is efficient but could benefit from clearer separation of ideas.

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 two entity types, multiple data sources, sorting, and output format (paired data with citation URIs), the description is thorough and compensates well for the lack of an output schema.

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

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

Schema coverage is 100%, so baseline is 3. The description adds significant meaning by specifying what data each type returns (financial metrics for company, adverse events for drug) and clarifying input formats (tickers/CIKs 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 clearly states the tool compares 2–5 entities (companies or drugs) in one call, with specific query patterns like 'X vs Y', and explicitly positions itself as preferable over sequential lookups, differentiating it from siblings.

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

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

It explicitly advises when to use the tool ('ALWAYS PREFER over sequential single-pack lookups') and provides examples of input formats, enhancing 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 already declare readOnlyHint=true and idempotentHint=true, so safety is covered. The description adds useful behavioral details: returns 'top-N most relevant tools with names, descriptions, and full input schemas (with curated examples)' and notes results are 'ready to call directly, no second schema lookup needed.' This goes beyond annotations, providing output behavior.

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

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

The description is a single concise paragraph that front-loads the action. It efficiently conveys purpose, usage, and key features without redundancy. Could be slightly tighter, but overall it's well-structured at moderate length.

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

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

Given the tool's discovery nature and the absence of an output schema, the description adequately explains what the tool returns: names, descriptions, schemas, and examples. It also mentions readiness for direct calls. For a tool with 6 parameters and no output schema, this is sufficient without needing excessive detail.

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

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

Schema description coverage is 100%, with all parameters documented (query and its aliases, limit). The description adds examples ('look up FDA drug approvals') but those are also in the schema examples. The description emphasizes the role of the query parameter but doesn't add substantial new meaning. 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 the tool's purpose: 'Find tools by describing the data or task.' It specifies the verb ('find'), resource ('tools'), and action ('describe'). It also distinguishes from siblings by advising to 'Call this FIRST when you have many tools available,' making its discovery role 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 explicitly tells when to use the tool: 'Use when you need to browse, search, look up, or discover what tools exist for' and 'Call this FIRST... to see the option set.' It provides concrete examples of domains, giving clear context. However, it doesn't explicitly mention when not to use it or list alternatives, though the directive 'FIRST' implies it's a preliminary step.

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

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

Annotations declare readOnly, openWorld, idempotent, non-destructive. Description adds specifics: fans out across multiple sources, returns fields with details (e.g., recent_filings URIs, fundamentals sorted), notes patent API sunset soft-fail, and mentions fallback behavior. 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 front-loaded with example queries and core purpose. It is verbose but every sentence adds value given the tool's complexity. Could be slightly more concise, 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?

With no output schema, the description thoroughly explains return values: cik, company_name, recent_filings (with URIs and limit), fundamentals (sorted), patents (with caveat), news (with fallback), LEI. Also notes limitations (only US companies, no names). Complete for its purpose.

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 reinforces the parameter meanings (ticker or zero-padded CIK, names not supported) but does not add significant new semantics beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description uses action-oriented phrases like 'full cross-source profile' and specifies the scope (US public company). It contrasts with chaining single-pack lookups, clearly distinguishing from sibling tools like resolve_entity.

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 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view' and instructs to use resolve_entity for name inputs. Provides clear when-to-use and when-not-to-use guidance.

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

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

Annotations already declare destructiveHint=true, so the description's mention of 'Delete' confirms destructive behavior. Does not add significant 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?

Three concise sentences with no extraneous information. Every sentence adds value: function, usage guidance, and pairing advice.

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 is sufficient. It includes purpose, usage context, and sibling tools, covering essential 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 one parameter key described as 'Memory key to delete'. Description adds no additional meaning 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?

Description clearly states the verb 'Delete' and the resource 'previously stored memory by key'. It distinguishes from siblings like remember and recall, which are listed in the description.

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: 'context is stale, the task is done, or you want to clear sensitive data'. Mentions pairing with remember and recall, but does not explicitly state when not to use.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, so the agent knows it's safe. The description adds that it fetches and extracts content, which is helpful. However, it does not disclose error handling, timeouts, or site accessibility requirements.

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: 4 sentences, each carrying meaning. It defines the tool, the process, output format, and use cases without redundancy.

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

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

The description provides all necessary context: what it does, how it works, output format, and use cases. No output schema exists, but the description explains the output is a text blob in standard llms.txt format. For a simple tool, this 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?

Schema coverage is 100%, so the parameters are well-documented in the schema. The description reiterates that max_links controls link entries but adds no new semantics. Score 3 because the schema does the work.

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 generates an llms.txt file for AI crawlers, outlines the process (fetch, extract, emit), and lists use cases. It is distinct from sibling tools which focus on checking AI visibility or scanning competitors.

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

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

The description provides three explicit use cases (client indexing, own project drafting, competitor auditing). It does not state when not to use or mention alternative tools, but the use-case specificity is helpful.

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 full burden. It discloses that the tool is rate-limited to 5 per identifier per day, free and doesn't count against quota, and that feedback signals affect the roadmap. This goes well beyond the annotations and provides essential behavioral context.

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

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

The description is concise, well-structured, and front-loaded. It starts with the purpose, then provides usage rules, and ends with behavioral notes (rate limits, quota). 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?

Given the tool is a simple feedback channel with no output schema, the description covers all necessary aspects: what it does, when to use it, how to format feedback, and what happens after submission (digests, roadmap). 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?

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the enum values for 'type' (e.g., 'bug = something broke...') and instructs users to describe issues in terms of Pipeworx tools/packs, avoiding end-user prompts. It also mentions the 2000 char limit. This meaningful addition justifies a 4.

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

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

The description starts with a clear verb+resource: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' This immediately clarifies the tool's purpose and distinguishes it from the sibling tools that are mostly data retrieval or analysis tools.

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

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

The description explicitly states when to use the tool ('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)') and provides explicit guidance on what not to do ('don't paste the end-user's prompt'). It also mentions rate limits and quota, giving clear context on usage constraints.

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, and idempotentHint. The description adds valuable behavioral context: aggregation method (CF analytics engine), no PII, caching (5min-1h), and that it's self-aggregating signal. 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 defines output, followed by bulleted use cases, then technical notes. Every sentence adds value with no redundancy or fluff. 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?

Despite no output schema, the description explicitly lists what is returned (top tools, top packs, total call volume) and covers source, PII, caching, and use cases. Complete for a simple read-only trending 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% and the schema description details the enum values. The description adds context for window choice ('shorter windows surface what's hot right now; longer windows show steady-state demand'), enhancing beyond the schema.

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

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

The description clearly states the tool returns top tools, top packs, and total call volume over a recent window. It uses specific verbs and resources, distinguishing it from siblings like 'discover_tools' by focusing on aggregated trending data from other agents.

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

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

The description provides three explicit use cases (discovering hot sources, confirming canonical tool, checking alignment) which guide when to use it. It lacks explicit alternatives or when-not-to-use guidance, but the use cases are practical.

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 many behavioral traits beyond annotations: it walks child markets, checks date-axis/threshold-axis ordering, computes partition_check with deviation threshold, uses Jaccard similarity >=0.30 for cross-event pairs, drops placeholder slugs, and details response structure. Annotations indicate readOnly, openWorld, idempotent, and non-destructive, which are consistent with the description. 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 with clear sections (requirement, purpose, mode details, filters, response). However, it is quite verbose; some details (e.g., exact Jaccard threshold, partition filter fraction) could be moved to schema or output documentation. Still, every sentence adds value and 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?

Given the complexity (two modes, multiple checks, filters) and no output schema, the description thoroughly explains the response structure (opportunities[], partition_check{}) and key behavioral details. It covers all necessary context for an AI agent to use the tool correctly, including edge cases like placeholder filtering.

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 'event' and 'topic'. The description adds significant value: it gives examples of event slugs and topic questions, explains the effect (single-event vs cross-event mode), and mentions that full Polymarket URLs are accepted. This goes well beyond the schema's basic type/description field.

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

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

The description clearly states the tool's purpose: 'Find arbitrage opportunities on Polymarket via monotonicity violations + partition-sum checks.' It distinguishes between single-event and cross-event modes and explains what each does. The verb 'find' with resource 'arbitrage opportunities' is specific, and the mention of two modes differentiates it from siblings like 'polymarket_edges' or 'polymarket_kalshi_spread'.

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 requires one of 'event' or 'topic', stating that calling with no args fails. It recommends 'event' for a specific market and explains when to use each mode, including what cross-event mode catches that single-event misses. This provides clear when-to-use and implicitly when-not-to-use 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 indicate read-only, open-world, idempotent behavior. The description adds extensive context beyond annotations: explains model families, response structure (by_segment, diagnostics), caching (1h KV-level), Fed bet exclusion, and move warnings. No contradiction with annotations.

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

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

The description is thorough but verbose (~400 words), containing detailed model explanations and parameter behaviors. While well-structured with clear sections, it could be more concise for quick scanning, earning a 3.

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

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

Despite no output schema, the description comprehensively covers return structure (segments, diagnostics, Fed note), caching, filtering logic, and caveats (e.g., why segments might be empty). It is fully complete for effective tool 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%, so baseline is 3. The description adds significant value by explaining parameter interactions (e.g., min_kelly as tradeable-edge filter, min_partition_leg_kelly's behavior for partition arbs) and providing usage guidance, justifying a 4.

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

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

The description explicitly states the tool scans top Polymarket markets for opportunities where Pipeworx data disagrees with market price, designed for daily betting discovery. This clearly distinguishes it from sibling tools like polymarket_arbitrage and polymarket_kalshi_spread.

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 positions the tool as a daily opportunity finder, providing clear context for its use. However, it does not explicitly delineate when to use this tool over its siblings, lacking exclusionary 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 (readOnlyHint, openWorldHint, idempotentHint) are consistent. Description adds rich behavioral context: compatibility_warning conditions, temporal_alignment, skipped_cross_type counters. It honestly reveals that most topic shortcuts produce warnings, setting correct expectations for a real-world tool.

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 verbose with multiple paragraphs and bold sections. While well-structured, it contains redundant emphasis (e.g., repeating the modes and warning about tradeability). Could be more concise without losing clarity. Earns a 3 for being functional but not minimal.

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

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

For a tool with no output schema, the description thoroughly explains response fields: leg-by-leg prices, top_spreads_pp, compatibility_warning, temporal_alignment, skipped counts. This is sufficient for an agent to understand and parse results. Minor gaps exist but overall complete given 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 each parameter. Description adds interaction semantics: topic auto-fetches events, explicit tickers override topic. This goes beyond the schema, providing guidance on parameter combinations and precedence. A score of 4 is appropriate given the schema already covers basic needs.

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 computes cross-venue spread between Kalshi and Polymarket for the same resolving question. It distinguishes from siblings like polymarket_arbitrage by focusing on cross-platform comparison. Two modes (topic shortcuts and explicit tickers) are described, making 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?

Provides explicit guidance on when to use: via pre-mapped topics or explicit tickers. Warns that most pre-mapped topics return compatibility_warning and are not tradeable. Details the safety fields that indicate when spreads are invalid (non-equivalent bet shapes, temporal misalignment). This helps the agent avoid misuse.

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 this tool as read-only, idempotent, and non-destructive. The description adds that the body is a 'PxWeb query object', which provides additional behavioral context but does not disclose any other important traits (e.g., rate limits, result size).

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

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

The description is very short (one sentence), which is concise but lacks structure. It front-loads the main action but omits key details that would warrant a higher score.

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 an output schema, the description does not explain what data is returned, how to interpret results, or error handling. The tool's scope (which tables, how to find paths) is absent, making it incomplete for effective 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?

The description adds that 'body is a PxWeb query object', which extends the schema's property description. However, the 'path' parameter lacks any description in both schema and description, leaving its meaning ambiguous. With 50% schema coverage, the description partially compensates.

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

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

The description states 'Pull data from a table' which clearly indicates a read operation, but does not differentiate from the sibling tool 'table_meta' which likely provides metadata. Lacks specificity about which tables are accessible.

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 guidance on when to use this tool versus alternatives like table_meta. No mention of prerequisites, context, or exclusions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds context about scoping to identifier and listing behavior, which is useful 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?

Three sentences, no wasted words. Front-loaded with the primary action, then use case, then context. 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 simplicity (one optional param, no output schema, good annotations), the description is largely complete. It could mention error handling (e.g., key not found) but not essential.

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 schema describing the key parameter. The description reinforces this and adds concrete examples of keys (ticker, address, notes), adding meaning 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 it retrieves a value saved via remember or lists all keys if no argument is given. It clearly distinguishes from siblings remember and forget, with specific verb and resource.

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: 'Use to look up context the agent stored earlier without re-deriving it from scratch.' Mentions pairing with remember to save and forget to delete, giving clear situational guidance and alternatives.

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

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

Annotations declare readOnlyHint, idempotentHint, and destructiveHint, indicating safe read-only behavior. The description adds significant behavioral context: fan-out to multiple APIs, fallback logic, soft-fail for patents, and return structure (changes grouped by source, total_changes count, citation URIs). No contradiction with annotations.

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

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

The description is well-structured, starting with example queries to immediately convey purpose, then detailing functionality, parameter usage, and an explicit alternative. Every sentence adds value without redundancy, making it efficient and easy to parse.

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

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

Given the tool's complexity (multiple sources, fallback) and absence of an output schema, the description adequately covers the return structure (changes grouped by source, counts, citation URIs) and notes the soft-fail for patents. However, it could briefly mention error handling or behavior when all sources fail, which would enhance completeness.

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

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

Schema coverage is 100%, providing basic descriptions for each parameter. The tool description adds value beyond the schema by explaining accepted formats for 'since' (ISO date or relative shorthand), providing examples, and recommending typical values. It also clarifies that 'type' only supports 'company' and 'value' accepts ticker or CIK.

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 change feed for a company over a time window, specifying it fans out to SEC EDGAR, GDELT/GNews, and USPTO. It distinguishes itself from the sibling tool entity_profile, which is for static profiles regardless of window.

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 this tool vs. entity_profile, explains the fallback behavior between GDELT and GNews, and recommends typical values for the 'since' parameter ('Use "30d" or "1m" for typical monitoring'). It also presents example queries like 'what's new with X'.

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 idempotent and non-destructive; description adds scoping by identifier, persistence details for authenticated vs anonymous users, and pairing with recall/forget. 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 compact, front-loaded with main purpose, and efficiently conveys all necessary information without 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?

For a simple store tool with no output schema, description covers purpose, usage, storage details, and pairing. Lacks mention of overwrite behavior or response, 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 descriptions are already good; description adds context of typical uses (ticker, address, preference) and scoping, enhancing semantic understanding beyond schema.

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

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

Description clearly states the tool saves data for reuse across conversations/sessions, and distinguishes from siblings recall and forget. It uses specific verb 'save' and resource '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?

Explicitly says use when discovering info worth carrying forward, and pairs with recall/forget. Could mention when not to use but given sibling list, it's 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 declare readOnly, openWorld, idempotent, non-destructive. Description adds that it cascades through multiple endpoints internally, replacing manual steps. No contradictions; extra context about internal mechanics.

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

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

Single paragraph with natural language examples leading into structural details. No redundancy or wasted words; front-loaded with purpose and examples.

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

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

Fully describes both entity types with return fields, citation URIs, and disambiguation. No output schema, but description compensates with detailed output expectations. Sufficient for an agent to decide when and how to invoke.

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 types and enums. Description adds concrete examples (AAPL, ozempic) and clarifies input variations (ticker, CIK, name) and expected output per type, enhancing schema detail.

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?

Explicitly states the tool resolves user-spoken names to canonical identifiers, supported types (company, drug), and what each returns (ticker, CIK, RxCUI). Examples like 'what's the ticker for…' clarify intent. Distinguishes from siblings by uniquely addressing entity resolution.

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?

Directs to use FIRST when name-to-ID mapping is needed, replacing 2-3 manual lookups. No explicit when-not-to-use or alternatives, but the context makes the primary use case 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, openWorldHint, idempotentHint, destructiveHint. The description adds behavioral context: it probes each entity with ai_visibility_check, treats the first entity as the 'subject' for narrative, and returns a ranked list with score, confidence, signal density. 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 three sentences with no wasted words. It front-loads the primary action, explains the process, and gives a use case. 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?

Given the complexity (4 parameters, no output schema), the description covers purpose, process, output format (ranked list with score, confidence, signal density), and entity role (first as subject). It is sufficient for an agent to select and use the tool correctly.

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

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

Input schema has 100% coverage with descriptions for all 4 parameters. The description adds little beyond the schema; it mentions the first entity as subject (already in schema) and says 'ranks by score' (output, not parameter). Baseline 3 is appropriate for high coverage with minimal added value.

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

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

The description clearly states the tool compares AI visibility across multiple entities side-by-side, probes with ai_visibility_check, ranks by score, and surfaces most/least recognized. It includes a specific use case ('competitive AI-marketing audits') and implicitly distinguishes from siblings like ai_visibility_check (single entity) and compare_entities (generic comparison).

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

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

The description provides a clear use case ('does Claude know about us as well as our competitors?') and implies it is for comparing multiple entities. However, it does not explicitly state when not to use it or directly compare with sibling tools like compare_entities.

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, and non-destructive. The description adds details about composite fan-out, graceful degradation on bundlephobia timeout, and specific return structure (summary block, per-advisory detail, links, alternatives). No contradiction with annotations.

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

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

The description is dense but efficient, front-loading the purpose and then detailing behavior. It is somewhat long due to the complexity, but every sentence adds value. Could be slightly more concise, 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?

Given the complexity of a composite scan with multiple sources and partial failures, the description covers ecosystem scope, return fields, failure behavior, and version defaults. Without an output schema, the description compensates by listing the return block fields. Lacks explicit mention of error handling for deps.dev failures, but overall 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 the schema already documents both parameters. The description adds minimal extra meaning: for 'package' it restates that scoped packages are accepted, and for 'version' it repeats the default behavior. Thus, 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 the tool is a composite check for npm packages, fanning out to deps.dev and bundlephobia, and lists the returned data. It distinguishes from siblings by specifying the npm-only scope, which is not covered by other tools.

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

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

Explicitly tells when to use ('whenever an agent asks...') and when not to use ('NPM ecosystem only'; for other ecosystems, use deps.dev:version directly). Also warns about partial failures and timeout behavior.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, etc., covering safety. The description adds little beyond 'navigate', not disclosing behaviors like whether it returns only immediate children or full subtree, if pagination exists, or authentication needs. With high annotation coverage, the description's contribution is minimal.

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 extremely concise (3 words), front-loading the core purpose. Every word is necessary, though it could be slightly expanded to improve clarity without losing conciseness.

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

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

With an output schema present, the description does not need to detail return values. However, the tool is simple (one optional param) and the description gives minimal context. It feels adequate but not rich; a bit more about what 'navigate' means would improve completeness.

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, describing the 'path' parameter as 'Sub-path under /ssd/ (default empty = root).' The description does not add extra meaning to the parameter, so it meets the baseline. It does not compensate for gaps since there are none.

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 'Navigate the subject tree' states the action (navigate) and resource (subject tree) but lacks specificity about what navigation entails (e.g., listing children, fetching details). It is not a tautology but could be clearer, especially since sibling tools like 'query_table' or 'entity_profile' might overlap.

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 guidance on when to use this tool versus alternatives. For example, it does not explain if this tool is for exploring hierarchy while 'query_table' is for searching. The description only implies usage context (navigating) without exclusions or comparisons.

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, so the safety profile is clear. Description adds 'dimensions, valid values' as return hints but lacks further behavioral details like rate limits or auth requirements. Adequate given 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?

Extremely short (one phrase) but under-specified. It's concise but at the expense of clarity. Every word earns its place, but more detail would improve 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?

Output schema exists, so description need not detail return format. For a simple tool with 1 param, description covers the basics but could elaborate on what 'dimensions' and 'valid values' entail. Adequate but not rich.

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

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

Schema coverage is 100%, so the schema already documents the single parameter 'path' with an example. Description repeats 'Table definition' but does not add semantic meaning beyond what's in the schema. Baseline 3.

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

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

Description states 'Table definition (dimensions, valid values)' which hints at returning metadata like columns and constraints. However, it is vague and doesn't clearly specify what exactly is returned, failing to provide a precise action verb and resource.

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 guidance on when to use this tool vs siblings like 'query_table'. The description does not indicate scenarios or prerequisites for using table_meta.

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 and idempotentHint. The description adds details about the return types (verdict, structured form, citation) and data sources (SEC EDGAR + XBRL), providing behavioral context beyond annotations without contradiction.

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

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

The description is a single dense paragraph but is efficient and free of fluff. It front-loads key information with trigger phrases and usage context. A slightly more structured format (e.g., bullet points) would improve scannability.

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

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

The tool is simple with one parameter and no output schema. The description covers purpose, input, output, and data source. It does not address error handling or limitations, but for a well-annotated tool this is 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?

The single parameter 'claim' has full schema coverage (100%). The description adds examples and clarifies the nature of acceptable claims, but this is incremental. Baseline 3 is appropriate as schema already describes the parameter 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 specifies the tool's purpose clearly with trigger phrases like 'fact check' and 'verify the claim'. It identifies the domain (company-financial claims for public US companies) and distinguishes from siblings by noting it replaces multiple 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?

The description tells when to use the tool: whenever the agent needs to check factual correctness. It mentions the current scope (company-financial claims) but does not explicitly list when not to use it or direct to specific alternatives, though the sibling list is available.

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