Bitfinex

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

Annotations (readOnlyHint, idempotentHint, destructiveHint) already indicate safety and idempotency. The description adds context about the probing process, cost implications (free vs BYO key), and the structure of the return value. No contradictions with annotations.

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

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

The description is a single coherent paragraph, front-loaded with the core action and output. It is concise but could be slightly more structured (e.g., bullet points) for clarity. No extraneous sentences.

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

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

Given no output schema, the description explains the return format ('per-model {score, confidence, signals, raw_response} + a combined view') adequately. It covers all parameters and provides sufficient context for an agent to use the tool without ambiguity.

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

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

Schema coverage is 100% (all 4 parameters described). The description adds value beyond the schema by providing examples ('E.g. "Pipeworx"', 'E.g. "Boston restaurant"'), clarifying the purpose of the 'context' parameter for disambiguation, and explaining the 'models' parameter defaults.

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

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

The description uses specific verbs: 'Probe one or more LLMs' and 'score visibility (0-100) per model', clearly indicating the tool's function and output. It distinguishes itself from sibling tools like 'scan_competitor_ai_presence' by focusing on individual entity visibility scoring.

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

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

The description provides explicit use cases: 'AI-marketing audits, pre-launch brand checks, competitive monitoring'. It clarifies when an API key is needed ('pass _apiKey to also probe Anthropic') and defaults to a free model. However, it does not explicitly state when not to use the tool or mention alternatives.

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

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

Annotations already declare the tool read-only, idempotent, and non-destructive. The description adds valuable behavioral context: it routes to 4,774 tools across 1242 sources, returns structured answers with stable citation URIs, works on every tier, and is a single fast call. 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 well-structured and front-loaded with the key instruction 'PREFER OVER WEB SEARCH'. It efficiently covers use cases, examples, and alternatives. However, it is somewhat verbose with repeated phrases like 'works on every tier, one fast call' and could be slightly trimmed without losing clarity.

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

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

Given the tool's complexity (routing to thousands of sources), the description is remarkably complete. It covers purpose, usage, alternatives, examples, and behavioral traits (citations, speed, tiers). Without an output schema, it still describes the return format as 'structured answer with stable pipeworx:// citation URIs'.

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 each parameter is described. The description clarifies that all parameters (q, text, input, query, prompt, question) are aliases for the same natural language question, adding meaning beyond the schema. The schema's description of 'question' is adequate, but the alias explanation is helpful.

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: 'PREFER OVER WEB SEARCH for questions about ...' and lists numerous domains (SEC filings, FDA drug data, etc.), distinguishing from siblings like ask_pipeworx_grounded and deep_research. It uses specific verbs like 'routes' and 'returns', making the resource and action 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 provides usage context: 'Use whenever the user asks ...' with examples, and gives clear alternatives: 'Step up only when needed: for a hallucination-resistant single answer ... use ask_pipeworx_grounded; for a broad/multi-part question ... use deep_research'. It also advises against using web search first.

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 (readOnlyHint, idempotentHint, etc.), the description adds critical behavioral details: costs one extra LLM call, returns specific response structure with refusal reasons, and explains the extraction process. No contradictions.

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

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

Single paragraph front-loads purpose, then explains mechanics and use cases. Informative without excessive wordiness. Could be slightly tighter but very good.

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

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

Given no output schema, the description fully compensates by detailing the return shape (answer, evidence, confidence, etc.) and refusal reasons. Also covers when to use and cost implications. Complete for a complex 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?

Input schema has 6 parameters all aliases for 'question', with 100% coverage. Description adds only 'Your question in natural language', which does not enrich meaning beyond schema. Adequate 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 it is a 'hallucination-resistant answer mode for high-stakes reads' and explains the exact mechanism (routes like ask_pipeworx, extracts answer only from tool result). This distinguishes it well from sibling ask_pipeworx.

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

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

Explicitly states when to use: 'whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts'. Also provides alternative: 'prefer ask_pipeworx for casual lookups'. Includes context for high-stakes domains.

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

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

Annotations already mark the tool as read-only, idempotent, and non-destructive. Beyond that, the description discloses a wealth of behavioral traits: low-confidence short-circuits, closed-market handling, wide-spread warnings, resolution-rule risk parsing, parent event extraction, news fallback mechanics, and the resolver contract. This far exceeds annotation coverage.

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: it opens with the core purpose, then layers usage, classification, examples, response shapes, safety, and edge-case behavior. Every section adds value, and the front-loading of the main action helps agents quickly assess relevance. Minor redundancy exists (e.g., market slug example repeated), but overall it earns its length.

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

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

Despite having no output schema, the description fully compensates by meticulously detailing the response structure (result.market, result.analysis, result.evidence, result.market_match_* fields, parent_event, news metadata). It also covers all major edge cases (low confidence, closed markets, wide spreads, cancellation rules) and explains fan-out logic by category. No gaps remain.

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. The description adds meaning by detailing the 'market' parameter's three accepted formats, how 'depth' defaults and affects fan-out rigor, and the practical recommendation for 'include_raw' (false to keep responses small; true for full payloads when recomputing deltas).

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

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

The description opens with a clear, specific verb-resource pairing: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies input types (slug, URL, question) and output (evidence packet + comparison). The tool's niche is distinct from siblings like 'validate_claim' or 'deep_research', as it is tightly scoped to Polymarket bets.

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 typical use cases: 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z".' It also provides numerous category-specific fan-out examples to guide usage. However, it does not contrast with or mention when to use sibling tools instead, missing an opportunity to exclude alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds value by specifying what data is returned (price levels, size, count) and the format (like 'tBTCUSD'), which goes beyond the annotations. 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?

The description is only two sentences, with the core purpose front-loaded. Every word contributes meaning, covering what it returns and use cases, with no superfluous text.

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 (order book) and presence of output schema, the description adequately covers the purpose, key parameters (symbol, precision), and use cases. Could mention length parameter explicitly, 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 description coverage is 0%, so the description must compensate. It explains the symbol parameter via example ('tBTCUSD') and mentions precision, but does not explain the length parameter. Partial coverage; adequate but not comprehensive.

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 the order book (bids + asks) for a crypto pair, which distinguishes it from siblings like candles, ticker, and trades. It specifies the resource (crypto pair) and the data (price levels with size and count).

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 for live depth-of-book analysis, spread, market microstructure,' providing clear context for when to use. However, it does not include explicit when-not-to-use advice or alternative tools, though siblings are listed in 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 readOnly, openWorld, idempotent, non-destructive. The description adds minimal behavioral context beyond stating return fields (timestamped OHLC + volume). No contradictions with annotations. With annotations covering safety, a score of 3 is appropriate.

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 concise, consisting of two sentences that front-load key information: source (Bitfinex), data type (OHLC candles), timeframes, return fields, and use cases. Every sentence adds value with no waste.

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

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

Given 7 parameters (3 required) and an output schema, the description covers source, data type, timeframes, and use cases but omits important parameter details like 'section' (last vs hist) and sorting. It is sufficient for simple queries but incomplete for advanced usage.

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

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

Schema coverage is 0%, so description must compensate. It clarifies timeframe (1m-1M) and symbol (crypto pair) but fails to explain 'section', 'start', 'end', 'limit', and 'sort' parameters. Examples provide some context but description itself lacks sufficient meaning for all 7 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 provides Bitfinex crypto OHLC candles, specifies return fields (open/high/low/close + volume) and timeframes (1m through 1M). It distinguishes from siblings like ticker and trades by explicitly mentioning 'candles' and use cases like charting, technical analysis, backtesting.

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 states it is for charting, technical analysis, and backtesting on Bitfinex, providing clear context. However, it does not explicitly mention when not to use this tool or alternatives like ticker or trades for real-time data.

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, but the description adds significant behavioral context: it explains how off-calendar fiscal years are handled, what metrics are pulled for each type (company: 10-K data, drug: FAERS, FDA approvals, trials), and that results are sorted by primary metric. This goes beyond what annotations provide.

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

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

The description is comprehensive yet efficiently structured, starting with example queries, then clear instructions, then detailed behavior per type. It is not overly verbose, though some minor redundancy (e.g., 'side-by-side comparison' and 'parallel call') could be trimmed.

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 entity types, multiple data sources, sorting) and the absence of an output schema, the description is complete. It describes returned data (paired data + pipeworx:// citation URIs) and explains sorting behavior ('largest/most/biggest reads off the top').

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

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

Schema coverage is 100%, but the description adds meaning beyond the schema by explaining what each 'type' value retrieves (company pulls 10-K revenue/net income/cash/debt; drug pulls FAERS adverse-event counts, FDA approvals, trial counts). For 'values', it clarifies acceptable formats (tickers/CIKs for company, names for drug) and limits (2-5 items).

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 performs side-by-side comparison of 2-5 companies or drugs, using example queries like 'X vs Y'. It distinguishes itself from sequential lookups by explicitly noting 'ALWAYS PREFER over sequential single-pack lookups'.

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

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

The description provides explicit guidance on when to use: 'ALWAYS PREFER over sequential single-pack lookups when comparing entities.' It also specifies the input types and behaviors for 'company' and 'drug', helping the agent choose correctly.

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=true. The description adds critical context: account requirement, paid plan for 'thorough' depth, that it is not open-web search, expected duration (15-60s), and the structural output (findings packet with gaps). 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 relatively long but dense with information. It front-loads the critical account restriction and alternatives. Every sentence contributes to understanding the tool's behavior and constraints, making it efficient for an AI agent 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 (2 parameters, no output schema, many siblings), the description covers purpose, usage guidelines, behavioral traits, parameter details, expected output structure, and timing. It is thoroughly complete for an AI agent to select and invoke the tool correctly.

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

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

Schema coverage is 100% with clear descriptions for both parameters. The description reinforces the meaning of 'depth' by explaining the number of facets for each level, and notes that 'question' is natural language. This adds some value but does not significantly surpass what the schema provides, so a 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 it performs grounded multi-source research across Pipeworx's structured data sources, decomposes questions into facets, and returns a findings packet. It distinguishes itself from ask_pipeworx by specifying that deep_research is for broad/multi-part questions, while ask_pipeworx is for single lookups or breaking news. This meets the 'specific verb+resource, distinguishes from siblings' criterion.

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 deep_research (broad/multi-part questions over structured data) and when not to (breaking news, single lookups). It names ask_pipeworx as the alternative for those cases. This provides clear context and exclusions.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, indicating a safe operation. However, the description adds no behavioral context beyond the annotations, such as handling of parameter keys or result limits.

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

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

The description is very concise but sacrifices clarity and completeness. It fails to provide necessary information, making it under-specified rather than efficiently written.

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 is too minimal. It does not explain what 'perpetual contract status' entails, valid key values, or how the tool interfaces with other tools, leaving significant gaps.

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

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

Schema description coverage is 0%, and the description does not explain the 'keys' parameter's purpose, format, or behavior. The example in the schema is not part of the description, leaving the agent with no 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 is merely a noun phrase 'Perpetual contract status.' It lacks an action verb, making the tool's function vague. It does not distinguish from the sibling tool 'derivatives_status_history' which likely provides historical 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?

No guidance is provided on when to use this tool versus alternatives like 'derivatives_status_history' or other sibling tools. No exclusions or contextual cues are given.

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 behavior. The description adds the 'historical' aspect, which is useful context, but does not disclose default sorting, pagination, or parameter effects. Minimal additional 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?

Three words is concise but lacks structure. The phrase is a fragment, not a proper sentence. Some expansion (e.g., 'Retrieves historical status entries for a derivative') would improve clarity without being verbose.

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

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

Given 5 parameters with no schema descriptions, the description is too brief. Output schema exists, so return values need not be detailed, but parameter usage (especially start, end, sort, limit) is left unexplained, making the tool harder to invoke correctly.

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

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

Schema description coverage is 0%, so the description should compensate. It does not explain any of the 5 parameters (key, start, end, sort, limit). The schema example provides some context (key and limit), but the description itself adds no meaning.

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

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

The description 'Historical derivatives status' is a noun phrase, not a clear verb+resource. It vaguely indicates the tool returns historical status of derivatives, which distinguishes it from sibling `derivatives_status` (current status), but lacks an action verb like 'retrieves' or 'lists'.

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. alternatives. Sibling `derivatives_status` likely provides current status, but the description does not mention this distinction or any 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, idempotentHint, and destructiveHint. The description adds behavioral context: returns top-N tools with full schemas and examples, ready to call directly. 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 detailed but front-loaded with purpose. Every sentence adds value, though slightly verbose. Could be tightened but remains clear.

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

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

Given no output schema, the description adequately explains return content (top-N tools with names, desc, schemas) and includes query examples. Covers the key aspects for a discovery tool.

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

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

Schema describes all 6 parameters with 100% coverage. The description adds value by providing natural language examples for query and mentioning aliases, moving beyond the schema basics.

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

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

The description explicitly states the tool finds tools by describing data or task, lists specific domains (SEC filings, financials, etc.), and distinguishes itself from sibling tools by being a discovery meta-tool meant to be called first.

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 clear guidance on when to use: browser, search, look up, or discover tools. Explicitly says 'Call this FIRST when you have many tools available', helping the agent understand it's for exploration rather than direct data retrieval.

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 details the fan-out across multiple sources, lists returned fields (cik, filings with URIs, fundamentals, patents, news, LEI), and notes the patent API sunset with soft-fail behavior. This goes well beyond annotations which already indicate read-only, idempotent, and non-destructive 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?

Description is comprehensive but somewhat lengthy. However, it is front-loaded with examples and each sentence contributes meaning. Could be slightly more structured but still 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?

No output schema, yet description thoroughly explains all return components (cik, filings with URIs, fundamentals, patents with caveats, news, LEI) and limitations. Provides all necessary context for an agent to understand the tool's output.

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 full coverage. Description adds value by providing examples (e.g., 'AAPL', '0000320193'), clarifying accepted formats, and reiterating that names are not supported. Slight enrichment beyond schema.

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

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

Description starts with multiple example queries and states 'full cross-source profile of a US public company in ONE parallel call.' Clearly identifies the tool's function and differentiates from siblings 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 says 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view' and advises to use resolve_entity for names. Provides clear when-to-use and when-not-to-use instructions.

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 confirms deletion and adds context about clearing sensitive data. Annotations already declare destructiveHint=true and idempotentHint=true, so description adds value but does not go beyond.

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

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

Two concise sentences: first states purpose, second provides usage guidance. 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?

Simple tool with one parameter. Description covers purpose, usage, and relationships to siblings. No missing 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 already fully describes the 'key' parameter with 100% coverage. Description adds no additional parameter detail, so baseline score of 3 is appropriate.

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

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

Clearly states the verb 'Delete' and resource 'previously stored memory by key'. Distinguishes from sibling tools 'remember' and 'recall'.

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

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

Explicitly states when to use: stale context, task done, clearing sensitive data. Mentions pairing with remember and recall, providing alternatives.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, which inform the agent that the tool is safe and non-destructive. The description adds behavioral details beyond annotations, such as fetching the page, extracting title/description/key links, and emitting standard markdown format. This enriches the agent's understanding 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 concise, with no fluff. It starts with a clear purpose statement, then explains the process, output format, and use cases in a logical order. Every sentence adds value, and the length is appropriate for the tool's complexity.

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

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

Given that there are only two parameters, no output schema, and annotations that fully cover safety, the description provides sufficient context. It explains what the output is (a text blob) and where to use it (site-root/llms.txt). It does not explain return values in depth, but the output is described as a single text blob, which is adequate.

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 both parameters (url, max_links) documented in the schema. The description adds minimal additional meaning beyond the schema: it implies the url is the source for the fetch, and it mentions a default and maximum for max_links. This is adequate given the 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 it generates a production-ready llms.txt file for any URL, specifying the output format and listing specific use cases (client indexing, own project drafting, competitor auditing). It is a specific verb+resource combination that distinguishes it from siblings like ai_visibility_check or scan_competitor_ai_presence.

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

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

The description explicitly lists three use cases for the tool, giving clear context on when to apply it. It does not explicitly state when not to use it or mention alternative tools, but the context provided is sufficient for an AI agent to determine appropriate usage.

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

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

The description adds minimal context by stating the output is 'recent' liquidations, but fails to describe behavioral aspects such as how parameters affect results (e.g., date range, sorting, limit) or any side effects. Annotations already cover safety (readOnly, idempotent), but the description does not enhance behavioral understanding.

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

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

The description is extremely concise (two words) but at the expense of clarity and completeness. It omits essential information that an agent needs, making it under-specified rather than efficiently concise.

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

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

Despite having annotations and an output schema, the description fails to provide enough context about what liquidations are, how to filter or sort them, or what fields the output contains. The parameter list and schema are not explained, leaving significant gaps.

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

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

With 0% schema description coverage, the description must compensate by explaining the parameters. It does not. The four parameters (end, sort, limit, start) remain completely undocumented. 'Recent liquidations' does not clarify their meaning, valid values, or usage.

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

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

The description is only two words, 'Recent liquidations,' which does not explicitly state what action the tool performs (e.g., get, list, or fetch). It leaves the agent to infer that it retrieves recent liquidation events, but lacks a clear verb and differentiation from sibling tools like trades or candles.

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 absolutely no guidance on when to use this tool versus any of the 36 sibling tools. No context about typical use cases, prerequisites, or alternatives is given.

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, making the safety profile clear. The description adds that the tool returns specific fields and includes an option for inactive subscriptions, but does not go beyond these basic details.

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

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

The description is two sentences with no extraneous information. It front-loads the purpose and includes necessary details about return fields and use cases, earning 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 tool has only one optional parameter and no output schema, the description sufficiently covers the response structure and use cases. It provides enough context for an agent to understand what the tool does and when to invoke it.

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

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

Schema coverage is 100% for the single parameter, and the description adds context by stating 'active subscriptions' and the default behavior of excluding inactive ones. This is adequate, but the description does not elaborate on parameter usage beyond what the schema provides.

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

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

The description clearly states the action 'List' and the resource 'the caller's active subscriptions', and lists specific return fields (id, type, params, etc.). It effectively distinguishes from sibling tools like subscribe and unsubscribe.

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

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

Explicitly states when to use: 'to review what you're monitoring before adding more or to find an id to cancel'. Provides clear context, though it does not mention scenarios where the tool should not be used or name alternatives beyond the implied 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 discloses rate limits (5 per identifier per day), cost (free, no quota count), and impact (team reads daily, affects roadmap). This goes beyond the minimal annotation hints (all false) to provide useful 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 (4 sentences) and well-structured: purpose first, then use cases, then what to include, then constraints. 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 no output schema, the description adequately covers input semantics, usage guidelines, and behavioral traits. It leaves no ambiguity about when and how to use this tool.

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

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

The description expands on the schema by explaining each enum value for 'type', specifying the message length (1-2 sentences, 2000 chars), and describing the optional context fields. Since schema coverage is 100%, the description adds significant value beyond basic parameter definitions.

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

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

The description explicitly states the tool's purpose: to report bugs, missing features, data gaps, or praise. It distinguishes itself from sibling tools by focusing on sending feedback rather than retrieving information.

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 scenarios for use: when a tool returns wrong data (bug), when a desired tool is missing (feature/data_gap), or for praise. It also advises what not to do (don't paste end-user prompt) and mentions the team's daily review.

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

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

Adds context beyond annotations: self-aggregating from CF analytics-engine, no PII, caching details. No contradiction with annotations.

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

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

Front-loaded with purpose, then use cases, then technical details. Slightly verbose but 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 one parameter, no output schema, and annotations providing safety profile, description covers what it returns, data source, caching, and use cases completely.

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

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

Single parameter window with enum; description explains trade-off between short and long windows, adding value over 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?

Clearly states it returns top tools, top packs, and total call volume over time windows. Distinguishes itself as a trending/discovery tool among many 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?

Explicitly lists three specific use cases (discovering hot data sources, confirming canonical tool, aligning use case with agents' needs). Provides clear guidance on when 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 declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, which already inform the agent of safe, read-only behavior. The description adds no further behavioral details (e.g., what happens, rate limits, or side effects), so it provides minimal added value 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 extremely brief (one sentence with two words), but it is under-specified rather than efficient. It does not earn its place because it adds no useful information beyond the tool name. A concise description for a status tool should still clarify the scope.

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

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

Given the tool has no parameters but has an output schema, the description should hint at what the output contains (e.g., platform health, version, timestamps). The current description is too vague to be complete, even for a simple status check. Sibling tools like 'derivatives_status' might offer more 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?

There are zero parameters, and schema description coverage is 100% (trivially). The description does not need to explain parameters, and the baseline is 4. It does not add any semantics about why there are no parameters or what the tool expects, but that is acceptable given the absence of 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 is essentially a tautology of the tool name, restating 'Platform status' without specifying a verb or resource. It vaguely indicates the tool relates to status but fails to define what status means (e.g., health, version, uptime). It does not distinguish from siblings like 'derivatives_status' that also deal with status.

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 is provided on when to use this tool versus alternatives among the many sibling tools. There is no mention of prerequisites, context, or exclusion criteria, leaving the agent to guess.

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 provides extensive behavioral context beyond annotations, including semantic anchor (Jaccard similarity), partition filter, fill check against live CLOB depth, and what to do when signals fire. Annotations indicate read-only, non-destructive, idempotent behavior, which the description aligns with. 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?

The description is lengthy and contains highly detailed technical explanations. While every sentence adds value, it lacks conciseness and could benefit from bullet points or more structured formatting for easier digestion. Complexity justifies some verbosity, but it's not maximally efficient.

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

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

Given the tool's complexity (two parameters, no output schema), the description is remarkably complete. It covers scanning modes, parameter details, edge cases (Jaccard similarity, placeholder filter), fill check procedure, and references to sibling tools. No important aspect is omitted.

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 documentation covers 100% of parameters, but the description adds substantial meaning: how each parameter mode works, what arguments are accepted (slugs, URLs), and the internal checks performed (partition_check, fill_check). This exceeds the baseline of 3 for high 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?

Description clearly states the tool finds arbitrage opportunities via monotonicity violations and partition-sum checks. It distinguishes between scanning modes (default, event, topic) and explains what each does, differentiating it from siblings like polymarket_edges or polymarket_fill_risk.

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

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

Explicitly tells when to use each mode: no args for trending scan, event for specific market, topic for cross-event. Recommends event mode for specific markets. Also provides a when-not-to-use rule: do not trade if realizable_edge ≤ 0, and suggests polymarket_fill_risk for custom sizing. Clear alternatives are given.

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

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

Annotations already indicate safe read-only idempotent behavior. The description adds extensive behavioral context: caching strategy, model details (e.g., lognormal barrier, GDELT, partition_overround with per-sport alpha), filter mechanics, diagnostic output, and Fed bets exclusion rationale.

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

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

The description is long but well-structured with sections for model families, knobs, and response fields. It is front-loaded with purpose. While verbose, the complexity justifies the length.

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

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

Despite no output schema, the description fully explains the response structure (by_segment, fed_candidates, _diagnostics) and all filters, edge calculations, and caching details. It covers all necessary context for an agent to use the tool effectively.

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

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

Schema coverage is 100%, so parameters are well-documented there. The description adds value by explaining how parameters like min_liquidity and max_spread_pp serve as 'tradeable-edge filters' and clarifying min_partition_leg_kelly behavior for partitions.

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

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

The description clearly states the tool scans Polymarket markets and returns opportunities where Pipeworx data disagrees with market price, specifically for betting discovery. It distinguishes from siblings through unique model families and output segments.

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 ('what should I bet on today') and explains tradeable-edge knobs. However, it does not explicitly state when not to use this tool or compare directly to siblings like 'polymarket_arbitrage'.

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

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

The description adds significant behavioral detail beyond annotations: it explains that it reads from daily snapshots, what the response includes (tracked, expired, snapshot dates), limits like 60-day TTL and conditional gaps, and that decay is based on daily closes of edge_pp_net, not intraday. Annotations already mark it as read-only and idempotent, so the description enriches the safety profile.

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: it starts with a clear purpose, then details the response structure and limits. It is somewhat lengthy but every sentence adds value. Could be slightly more concise, but the front-loading is 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?

Despite lacking an output schema, the description fully explains the return format with fields like tracked[], expired[], and snapshot_dates[]. It covers edge cases (gaps in snapshots, TTL, enablement start) and includes important limitations. This is complete for an agent to understand what the tool does and what it returns.

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

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

The description mentions the two parameters with defaults and constraints, but these details are already covered in the input schema (100% coverage). It adds context like 'lookback' and 'snapshot family' but does not provide new semantics beyond the schema. Baseline of 3 is appropriate.

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

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

The description clearly states the tool provides edge persistence and decay telemetry from daily snapshots. It explicitly answers 'how long has this edge existed and is it shrinking?' which is the core purpose, and distinguishes from the sibling 'polymarket_edges' by focusing on historical trends rather than current edges.

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 strong context for when to use the tool, emphasizing that edge age matters for trade decisions. However, it does not explicitly mention alternatives or when not to use it. The sibling differentiation is implied through the focus on time-series tracking, but no direct 'use this instead of X' guidance is provided.

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, indicating a safe read-only operation. The description adds significant behavioral context: it details the process ('walks the ladder'), specifies return fields (top_of_book, vwap_fill_price, slippage_pp, etc.), and warns about risks ('partial basket fills convert an arb into an unhedged directional position'). No contradiction with annotations.

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

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

The description is well-structured with clear sections: summary, required parameters, single-market details, basket details, and usage guidance. Every sentence adds value. However, it is relatively long; slightly more conciseness could improve quick scanning. Still very 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 tool's complexity (two modes, many return fields) and the absence of an output schema, the description thoroughly covers return values for both modes, including verdicts, profit, thin legs, and directional risk. It addresses edge cases like partial fills and forced directional risk, making it complete for an agent to select and invoke correctly.

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

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

Schema coverage is 100% with descriptions for all 4 parameters. The description goes beyond the schema by explaining default behaviors (e.g., side auto-detection in basket mode), clarifying interpretations (size_usd as target proceeds for sells), and differentiating behavior between single-market and basket modes for the same parameter.

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

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

The title 'Polymarket Fill Risk' and the opening sentence 'Realizable-vs-theoretical edge check against live CLOB order-book depth' clearly state the tool's purpose: assessing fill risk by comparing theoretical and realizable edges. The description further distinguishes between single-market and basket modes, and explicitly differentiates from sibling tools like polymarket_arbitrage and polymarket_edges by stating when to use this tool before acting on those signals.

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 instructs 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500', providing clear when-to-use guidance. It also warns against partial basket fills converting arb into directional risk, implying when not to use (e.g., theoretical overround on thin books). The context signals about sibling tools reinforce differentiation.

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

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

Annotations declare readOnlyHint, idempotentHint, and destructiveHint already. The description adds extensive context: explains compatibility_warning triggers, temporal_alignment, skipped counters, and response structure. This goes well beyond annotations to disclose when spreads 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 dense but well-structured with clear sections (TWO MODES, RESPONSE, SAFETY FIELDS). It is somewhat lengthy but every sentence adds value; could be slightly more concise but 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?

With no output schema, the description fully explains the response format, including leg-by-leg prices, matched spreads, and safety fields. It covers edge cases, temporal alignment, and skipped comparisons, making it completely adequate for such a complex tool.

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

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

Schema coverage is 100%, so the schema already documents parameters. The description adds value by explaining the two modes, overriding behavior, and providing examples, but does not add critical meaning beyond the schema. Baseline 3 applies, with extra context 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 clearly states the tool computes cross-venue spreads between Kalshi and Polymarket for the same resolving question. It distinguishes two modes (topic shortcuts and explicit tickers) and explains what the tool does, setting it apart from siblings like polymarket_arbitrage.

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

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

The description explicitly tells when to use topic mode (10 pre-mapped macro shortcuts) versus explicit mode (custom pairings). It also warns that most pre-mapped topics return compatibility warnings, guiding agents on when not to rely on results.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. Description adds listing behavior when key is omitted, pairing with remember/forget, and scoping information, which enriches understanding beyond annotations.

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

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

Three sentences, front-loaded with action and examples. Efficient but could be slightly tighter (e.g., combine second and third sentences).

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

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

For a simple tool with one optional parameter and no output schema, description fully covers usage: retrieval, listing, scoping, and pairing with remember/forget. No gaps.

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

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

Schema coverage is 100% and description repeats what schema says (omit key to list all keys). No additional semantic value beyond the schema's own description.

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

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

Description clearly states tool retrieves saved values or lists keys, with specific verb-resource pairing (retrieve/list) and distinguishes from siblings like remember and forget.

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

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

Provides clear context on when to use (look up stored context, avoid re-deriving) and scope (scoped to identifier), but does not explicitly exclude scenarios or name alternatives beyond implied sibling distinction.

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 the side effect of mark_read:true (flagging events as read), but annotations claim readOnlyHint=true, creating a contradiction. Without annotations, the description would score higher; with this conflict, trust is reduced.

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 purpose, no filler. Every sentence adds value – purpose, key fields, parameter usage guide, and alternate access method.

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 5 parameters with full schema descriptions and no output schema, the description covers the tool's purpose, response fields, filtering, side effects, and alternative endpoint. Slightly missing explicit mention of unread_only parameter usage.

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

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

Schema coverage is 100%, so baseline is 3. Description adds value by explaining how parameters like type, since, and mark_read are used together, going beyond schema descriptions.

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

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

Clearly states the verb 'Pull fired events' and the resource 'your subscription feed.' It differentiates from sibling tools like list_subscriptions by focusing on retrieving alerts rather than managing subscriptions.

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

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

Provides explicit guidance on filtering by type and ISO timestamp, using mark_read, and mentions polling suitability and an alternative API endpoint. Does not fully exclude misuse cases but offers clear context.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds substantial context: fans out to multiple sources, handles fallbacks, notes USPTO soft-fail condition, and describes the return structure (changes[] grouped by source + total_changes count + pipeworx:// 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 a single dense paragraph but front-loads the purpose with examples. Every sentence adds value. Could be slightly more structured (e.g., bullet points for sources), but it is efficient and not verbose. Loses a point for minor lack of visual structure.

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

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

Given the complexity (multiple data sources, fallback logic, parameter formats, return structure) and the absence of an output schema, the description covers all essential aspects: what sources are queried, how they fall back, what `since` accepts, what the return shape is, and how it differs from `entity_profile`. No gaps.

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

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

Schema description coverage is 100% (all three parameters have descriptions). The description enhances understanding by giving concrete examples for `since` ('7d', '30d', '3m', '1y'), clarifying `type` is only 'company', and explaining `value` accepts ticker or zero-padded CIK. This goes well beyond the schema alone.

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

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

The description starts with concrete example queries and clearly states the tool's purpose: 'change feed for a company in the last N days/weeks/months in ONE parallel call.' It explicitly lists the resources (SEC EDGAR, GDELT→GNews, USPTO) and distinguishes from sibling `entity_profile` by stating when to use that instead.

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

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

The description provides explicit when-to-use guidance through example queries ('What's new with X', etc.), defines the `since` parameter format and typical value ('30d' or '1m' for monitoring), and gives fallback behavior (GDELT preferred, GNews when rate-limited/5xx). It also tells when NOT to use it: 'Use entity_profile instead when you want the static profile...'

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

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

Annotations already provide readOnlyHint=false, idempotentHint=true, destructiveHint=false. The description adds behavioral details beyond annotations: key-value storage, scoping by identifier, and persistence duration (24 hours for anonymous). 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 four sentences long, well-structured, and front-loaded with the main purpose. Every sentence adds value without redundancy, making it concise 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 only 2 parameters, no output schema, and annotations already covering destructive/idempotent hints, the description is complete. It explains scope, persistence, and pairing with other tools, leaving no critical gaps.

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

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

Schema coverage is 100% with both 'key' and 'value' described. The description does not add much beyond the schema's parameter descriptions; it mentions key naming conventions but these are already in the schema examples. 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: saving data for reuse across conversations/sessions. It provides concrete examples (resolved ticker, target address, user preference) and explicitly mentions the key-value pair structure, making the purpose unambiguous.

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

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

The description advises when to use the tool ('when you discover something worth carrying forward') and explicitly pairs it with sibling tools 'recall' and 'forget'. It also explains scoping by identifier and persistence differences (authenticated vs. anonymous sessions), providing clear 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, openWorldHint, idempotentHint, and destructiveHint false, so the safety profile is clear. The description adds valuable context: the tool cascades through multiple endpoints internally, effectively replacing 2-3 manual lookups. It also details the output structure for each entity type, which annotations do not cover. 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 well-structured: examples first, then supported types with detailed outputs. Every sentence adds value; there is no fluff. It is appropriately sized for the tool's complexity and front-loads the core action.

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. It also notes that the tool invokes multiple endpoints internally. Missing details on error handling or edge cases (e.g., ambiguous input), but for a lookup tool with clear parameters and results, this is largely 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% (both parameters described). The description enriches the schema by explaining what each entity type accepts as input (e.g., for 'company': ticker, CIK, or name with auto-disambiguation) and what is returned (ticker, CIK, company_name, citation URI). This goes beyond the basic enum description in the schema.

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

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

The description clearly states the tool's purpose: resolving user-spoken names to canonical/official identifiers. It provides specific examples ('ticker for...', 'CIK for...', 'RxCUI for...') and distinguishes itself from sibling tools by noting it replaces multiple lookups. The verb 'resolve' combined with 'name to identifier' is precise and unambiguous.

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

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

The description explicitly says 'Use FIRST whenever you have a name but need an ID.' This gives clear guidance on when to use it. It also provides examples of queries that trigger the tool. However, it does not explicitly state when not to use it (e.g., if you already have an ID), though this is implied. A bit more nuance on exclusions would push it to 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 (readOnlyHint, idempotentHint, destructiveHint) already indicate safe, non-destructive behavior. The description adds value by detailing that it probes each entity with ai_visibility_check, ranks by score, and returns per-entity metrics (score, confidence, signal density), providing behavioral context beyond annotations.

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

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

The description is three sentences long, each providing essential information: purpose, internal mechanism, use case, and output format. No redundancy or filler, with the most important info front-loaded.

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

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

Given no output schema, the description compensates by specifying the return format (ranked list with score, confidence, signal density). Combined with annotations and schema, it provides sufficient context for agent decision-making.

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% description coverage, but the tool description adds semantic nuance: it explains that the first entity in the array is treated as the 'subject' for narrative and the rest as competitors, which is not captured in the schema. This extra information helps agents use the tool correctly.

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

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

The description clearly states the tool compares AI visibility across multiple entities side-by-side, using ai_visibility_check internally and returning a ranked list. It distinguishes from siblings like ai_visibility_check (single entity) and compare_entities (generic comparison) by focusing specifically on AI presence.

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

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

The description explicitly gives a use case ('competitive AI-marketing audits') with an example question ('does Claude know about us as well as our competitors?'), clearly indicating when to use this tool versus alternatives.

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

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

Beyond annotations, describes partial failures, timeout behavior, and return structure (summary block, advisories, alternatives).

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 and front-loaded, but slightly long due to necessary detail; each 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 complexity (multiple sources, partial failures, no output schema), the description fully covers behavior, limitations, and return fields.

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 100%, description adds value by explaining scoped packages acceptance and default version 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?

Description clearly states it's a composite check for adding an npm package, listing specific sources and checks. Distinguishes from siblings by focus on npm dependency evaluation.

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 asks about safety/popularity/size) and provides exclusion guidance (NPM only v1; other ecosystems via deps.dev).

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. Description adds detailed behavioral traits: uses BGE-base-en embeddings with cosine similarity on 512-char overlapping windows, has a 200K char limit with truncation and flagging, and returns passages with offsets and scores. 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 concise at 4 sentences, front-loaded with purpose, and every sentence provides 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?

Given the tool has 3 params, no output schema, and robust annotations, the description is complete: explains when to use, algorithm details, limitations (200K char cap, truncation flag), return structure (passages with offsets and scores), and complementary tool.

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

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

Schema description coverage is 100%, providing baseline of 3. Description adds meaningful context: for 'text' provides examples of typical inputs (SEC 10-K body, article, long tool result), for 'query' gives example queries, and implies return structure (offsets, scores).

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

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

The description clearly states it performs semantic search inside a fetched record, using a verb-resource pair ('search within') and distinguishes from siblings by mentioning it pairs with ask_pipeworx_grounded and saves context.

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 ('when the record is too big to cram into the prompt') and mentions a complementary tool (ask_pipeworx_grounded), but does not exclude 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 convey read-only, idempotent, and non-destructive behavior. The description adds no extra behavioral information but does not contradict 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 extremely short, but conciseness is achieved at the cost of clarity. It lacks structure and essential 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 having output schema, the description does not explain return values or behavior. With 8 parameters and no parameter documentation, the description is grossly incomplete.

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 does not explain any parameters. With 0% schema description coverage, the description should compensate but provides no semantic meaning beyond the parameter names.

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

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

The description 'Statistics by key' is vague and does not specify what statistics are provided or what 'key' refers to. It fails to distinguish this tool from siblings like candles, ticker, or trades that also provide 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?

No guidance on when to use this tool versus alternatives. The description gives no context about typical use cases or prerequisites.

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=false, idempotentHint=true, destructiveHint=false. The description adds behavioral context: creation is not read-only, requires authentication, delivery limits (10 SMS/day), webhook auto-disable after failures, phone verification. 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?

The description is long but well-structured with bullet-like examples and clear sections. The first sentence immediately states the purpose. Every sentence adds value; however, the length is justified by the tool's complexity.

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

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

Given the complexity (5 types, nested params, multiple delivery channels), the description covers return value, prerequisites, examples, limitations (SMS cap, webhook auto-disable), and account verification. No output schema but description clarifies return of subscription id.

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

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

With 100% schema coverage, baseline is 3, but the description adds significant value: explains type-specific params with examples (e.g., sec_8k with items, polymarket_edge with topic), clarifies delivery options and constraints (phone verification, SMS cap, webhook signing). Goes well beyond schema descriptions.

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

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

The description clearly states 'Create a proactive monitoring subscription to a live-data event stream' and specifies it returns a subscription id. It distinguishes from sibling tools like list_subscriptions and unsubscribe.

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

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

The description provides clear context for when to use (subscribing to alerts) and notes prerequisites (Pipeworx OAuth account). It includes when-not-to (anonymous/BYO cannot persist) but does not explicitly compare to other tools beyond stating its purpose.

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 as true. The description adds context about the output (example questions with tool+argument shapes) and that it draws from a live catalog. No additional behavioral traits are disclosed, but given the annotations, this is 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 front-loaded with common user queries and is well-structured. It covers intent, functionality, and usage instructions in a logical order. While slightly long, 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 no output schema, the description fully explains what is returned (example questions with tool+argument shapes). It covers the single parameter, usage patterns, and purpose. The list of categories and instruction to call meta-tools make it complete for an onboarding 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?

With 100% schema description coverage, the baseline is 3. The schema already describes the optional topic parameter and its values. The description echoes this with examples ('finance', 'pharma', 'betting') but does not add significant new 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 that the tool returns category-bucketed example questions with tool+argument shapes. It lists specific categories and differentiates itself from siblings like ask_pipeworx and discover_tools by positioning itself as the onboarding entry point.

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

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

The description provides clear when-to-use guidance: 'Use this FIRST when you do not yet know what Pipeworx can do for you.' It explains calling with no arguments for full spread or passing topic to focus. However, it does not explicitly state when not to use it.

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

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

Annotations already indicate readOnlyHint, idempotentHint, and non-destructive nature. The description adds behavioral details: the exchange (Bitfinex), live data, and specific return fields (bid/ask, last price, volume, change). No contradictions with annotations.

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

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

The description is a single sentence that efficiently conveys the core purpose, data source, example, and return fields. No redundancy or unnecessary words.

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

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

Given the tool has one parameter and an existing output schema, the description adequately covers what the tool does and what it returns. It provides sufficient context for an agent to understand the tool's role and data.

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 0% (description does not mention the symbol parameter), but the description compensates by providing an example 'tBTCUSD', which implies the format. However, it does not explain the symbols naming convention or required prefix. The single parameter is required, so additional clarity would be beneficial.

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

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

The description clearly defines the tool as a single-pair live ticker from Bitfinex, specifying the return fields (bid/ask, last trade price, 24h volume, change percentage). It distinguishes itself from siblings like 'tickers' and 'ticker_history' by emphasizing single-pair and live 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 states it's for a single-pair live ticker and provides an example. It implies usage for a specific symbol, but does not explicitly state when to use this over siblings like 'tickers' for multiple pairs or 'ticker_history' for historical data. The context is clear but lacks explicit exclusions.

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

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

Annotations already indicate readOnlyHint=true and idempotentHint=true. The description adds that it returns bid/ask/last per timestamp, which is consistent and provides useful behavioral context 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 sentence that efficiently conveys exchange, data type, symbol format, optional parameters, and return format. No wasted words.

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

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

Given the presence of an output schema, the description adequately covers the return values. It could mention pagination but is sufficient for a low-complexity 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?

With 0% schema coverage, the description compensates by explaining symbols as comma-separated with an example, and describes start/end as ms epoch. This adds significant meaning beyond the raw 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 provides historical ticker snapshots from Bitfinex, specifying it handles one or more pairs. This distinguishes it from siblings like ticker, trades, and candles.

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

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

The description mentions optional start/end (ms epoch) and limit, giving clear usage context. However, it does not explicitly state when to avoid this tool or recommend alternatives for real-time data.

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 that it returns live bid/ask, last, daily change, volume per pair, adding behavioral context beyond annotations that already indicate read-only, idempotent, non-destructive.

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

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

Two sentences front-load purpose, then input format, then output summary—no wasted words.

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

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

Given a single parameter, no nested objects, and output schema present, the description covers input format and return fields sufficiently for an agent.

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

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

With 0% schema description coverage, the description fully compensates by specifying the input format (comma-separated or 'ALL') and examples, adding essential meaning beyond the schema's type 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 identifies the tool as providing multi-symbol live tickers for crypto pairs from Bitfinex, distinguishing it from singular 'ticker' and 'ticker_history' siblings.

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

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

The description explains to pass comma-separated symbols or 'ALL', implicitly indicating use for multiple symbols, but lacks explicit when-to-use vs alternatives like singular 'ticker'.

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 no behavioral contradictions and provides context on optional parameters and return fields, which is 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?

Two concise sentences that front-load the exchange and purpose, followed by return fields and optional parameters. No unnecessary words.

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

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

Given moderate complexity and presence of output schema, the description covers the main purpose and parameters. It could mention that the result is an array of trades, but the listed fields imply that.

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

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

With 0% schema coverage, the description compensates by naming parameters (symbol required; start/end as epoch ms; limit and sort order) and providing examples. However, it does not specify exact sort values or defaults.

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

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

The description clearly states it fetches recent trade tape for a specific pair on Bitfinex, listing returned fields (trade ID, timestamp, amount, price). It distinguishes from sibling tools like 'candles' or 'ticker' by specifying raw trade 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 implies usage for individual trade data but does not explicitly state when not to use it (e.g., for aggregated data use 'candles'). However, the examples and context make it clear enough.

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

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

Adds important behavioral details beyond annotations: row is deactivated not deleted, historical events remain via recent_alerts. Annotations are consistent and description provides added context on side effects.

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 efficient sentences: first states purpose and constraint, second explains side effect. No wasted words.

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

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

Tool is simple with one parameter and no output schema. Description covers purpose, constraint, and side effect. Annotations present. Fully adequate.

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 parameter description. Description only briefly mentions 'by id', adding no new semantics. Baseline 3 is appropriate.

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

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

Description clearly states the verb 'Cancel' and resource 'subscription by id'. It distinguishes from sibling tools like 'subscribe' and 'list_subscriptions' by indicating the opposite action.

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

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

Explicitly states ownership enforcement: 'you can only cancel your own subscriptions', implying when not to use. Does not explicitly mention alternatives but context with sibling tools is clear.

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

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

Annotations are rich (readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false). The description adds what the tool returns: verdict types (confirmed, refuted, etc.), extracted structured form, actual value with citation, and percent delta. It also mentions efficiency gains by replacing multiple calls. No contradictions with annotations.

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

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

The description is a single medium-length paragraph that front-loads user intent examples. Every sentence adds value: usage guidance, domain scope, output description, and efficiency note. It is concise without being overly brief.

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 claim verification with structured output, the description covers purpose, usage, domain, input format, output details, and efficiency advantage. No output schema exists, but the description adequately explains the return types and structure.

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 'claim' with schema description coverage 100%. The description goes beyond schema by providing examples of valid claims and explaining the output structure, which adds value beyond the bare parameter 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 starts with clear user intent examples ('Is it true that...', 'fact check') and explicitly states the purpose: natural-language claim verification against authoritative sources. It specifies the domain (company-financial claims) and data sources (SEC EDGAR + XBRL), 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 explicitly says 'Use whenever the agent needs to check whether something a user said is factually correct.' It also sets scope by mentioning v1 supports company-financial claims only. While it doesn't explicitly list alternatives, the context of sibling tools provides that information.

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