Openligadb

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description adds value by noting that the default call is free (Workers AI) and that Anthropic calls require a user-provided key (BYO key with direct payment). It also reveals the return shape (per-model fields + combined view), which is not in 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 four sentences, each adding distinct information: core action, optional key, return structure, and use cases. No filler or repetition. Front-loaded with the verb 'Probe' and the key output (score 0-100).

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 accounts for the tool's complexity: it covers all 4 parameters (entity, models, _apiKey, context), explains the return format (per-model objects with score, confidence, signals, raw_response plus combined view), and gives behavioral context (free default, BYO key for Anthropic). The 100% schema coverage complements this completeness.

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

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

The input schema has 100% description coverage, so the baseline is 3. The description adds meaning beyond schema: it explains the default model when models is omitted, clarifies that _apiKey is only needed for Anthropic, and provides examples for entity (e.g., 'Pipeworx'). This extra context justifies a score of 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 specifies a concrete action: probing LLMs for knowledge about an entity and scoring visibility. It names the default model (Workers AI Llama-3.3-70b) and the optional Anthropic provider, distinguishing this tool from siblings like ask_pipeworx 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 lists clear use cases (AI-marketing audits, pre-launch brand checks, competitive monitoring). It also explains when to pass _apiKey (Anthropic models) and the default model choice. However, it does not explicitly state when not to use this tool or compare to 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 non-destructive. The description adds behavioral context beyond that: it routes across 5,529 tools, fills arguments, returns structured answers with pipeworx:// citation URIs, works on every tier, and covers live news. This is useful disclosure not present in annotations.

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

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

The description is long but front-loaded with the most important guidance and uses examples and explicit alternatives. Some redundancy exists (e.g., 'PREFER OVER WEB SEARCH' and 'START HERE' repeat similar points), but the structure with examples and escalation rules 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?

Given the tool's broad scope and lack of output schema, the description is thorough: it lists covered domains, gives query examples, explains output format (structured answer with citations), states tier compatibility, and distinguishes when to escalate. It fully equips an agent to decide when and how to invoke 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?

Schema description coverage is 100%, with the required 'question' parameter clearly documented including aliases. The description adds examples of valid queries but does not add additional parameter semantics beyond the schema. Baseline 3 is appropriate since the schema already carries the parameter burden.

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 routes questions to a network of verified sources and returns structured answers with citations, using a specific verb ('routes', 'returns'). It clearly distinguishes itself from siblings like ask_pipeworx_grounded and deep_research by positioning itself as the default entry point.

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

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

Provides explicit when-to-use guidance: 'PREFER OVER WEB SEARCH', 'Use whenever the user asks...', and 'START HERE for most questions'. It also names alternative tools for specific cases (ask_pipeworx_grounded for verbatim evidence, deep_research for broad/multi-part questions), giving clear rules for when not to use this tool.

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

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

Annotations already declare readOnly, openWorld, and idempotent hints, so the safety profile is covered. The description adds valuable behavioral context: candidate routing improvements may be enabled live, it is currently identical to ask_pipeworx, and it is a full working router with no fallback. This goes beyond annotations by explaining the experimental nature and comparison process.

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 and front-loads the key fact that it is a beta version. It provides necessary context about current state and routing improvements without excessive fluff. The phrase 'Falls back to nothing' is slightly awkward and could be clearer, but overall the structure is efficient and informative.

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

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

Given no output schema, the description explains that the response shape is identical to ask_pipeworx and mentions the 5,529 tools. It also covers the current candidate state and comparisons for merges, which is essential for a beta tool. It relies somewhat on knowledge of ask_pipeworx, but for a sibling variant this is acceptable and complete enough for an agent to use it correctly.

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

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

The input schema provides 100% coverage with all parameters documented as aliases for 'question'. The description says the tool takes 'the same arguments' as ask_pipeworx but adds no parameter-specific meaning beyond what the schema already states. According to the rubric, a high schema coverage 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?

Purpose is clearly stated as a beta version of ask_pipeworx, an identical universal router with the same tools and response shape. It distinguishes itself from the stable ask_pipeworx by being the experimental edge with candidate routing improvements. The description lacks a single explicit verb like 'answers questions', but the schema and references to ask_pipeworx make 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 explicitly states when to use this tool: 'Use it exactly like ask_pipeworx when you want the newest routing' and contrasts it against the stable router. It also clarifies the current state (no candidate active, identical to stable) and mentions that results are compared against the stable router, giving clear guidance on its role relative to 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 the annotations (readOnly, openWorld, idempotent, non-destructive), the description discloses the refusal mechanism with specific refusal_reason values, the strict use of tool result verbatim evidence, and the extra LLM call cost. This meaningfully adds 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 dense but every sentence earns its place: purpose, routing, return shape, refusal reasons, use cases, and cost tradeoff. It is front-loaded with the key differentiator and avoids 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 fully explains the return structure (answer, evidence, confidence, source, etc.) and refusal reasons, which is essential for an agent to interpret results. It also covers when to use, cost implications, and relationship to siblings, making it highly complete.

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

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

The input schema already covers 100% of parameters with descriptions and aliases, so the description need not add parameter details. It does mention 'fills arguments' as part of routing behavior, which is a small extra context, but no parameter-specific semantics are added.

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

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

The description specifies a distinct verb+resource ('Hallucination-resistant answer mode') and clearly differentiates from ask_pipeworx by emphasizing extraction-only answers with evidence and refusal handling. It states the tool's core function and its unique scope for high-stakes reads.

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 when to prefer the alternative ('prefer ask_pipeworx for casual lookups'), while naming the sibling tool and explaining the cost tradeoff. This is model usage guidance.

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

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

The description extensively discloses behavioral traits beyond annotations: market resolution, classification, fan-out, response shapes, safety mechanisms (low-confidence blocking, closed markets, wide spreads), resolution-rule risk parsing. All align with annotations (readOnlyHint, idempotentHint). 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 verbose (multiple paragraphs) and packs extensive detail, which reduces conciseness. However, it is well-structured with front-loaded purpose, followed by classifiers, fan-out examples, response details, and safety notes. While informative, it could be more succinct.

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

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

The description is exceptionally complete for a 3-parameter tool without an output schema. It covers input variations, classification, fan-out examples, response fields (market, analysis, evidence, resolver contract, parent_event, news fields), and edge cases (low confidence, closed markets, illiquidity, cancellation rules). 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?

With 100% schema coverage, the description adds significant value: explains 'market' accepts slug, URL, or question text; clarifies 'depth' enum (quick vs thorough) with defaults; details 'include_raw' usage (summarized vs full payloads, size implications). This enriches the schema beyond basic 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 clearly states the tool's purpose: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies the verb (research), resource (Polymarket bet), and outputs (evidence packet + market-vs-model comparison). It differentiates from siblings by detailing the resolve-classify-fan-out process.

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 use cases: 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z".' It provides clear context but does not explicitly exclude alternative tools like polymarket_edges, which might lead to some ambiguity.

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 significant context beyond annotations: describes data sources (SEC EDGAR/XBRL, FAERS), handles off-calendar fiscal years, sorted by primary metric, returns paired data + 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?

Description is dense but well-structured, front-loaded with example queries and key instructions. Every sentence adds value, though could be slightly more concise.

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

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

Covers entity types, data sources, sorting, and return format (paired data + citations) despite no output schema. Provides enough context for correct usage.

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

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

Schema coverage is 100%, but description adds examples and clarifies behavior (e.g., tickers/CIKs for companies, drug names, handling of fiscal years). Adds value beyond schema descriptions.

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

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

Description clearly states side-by-side comparison of 2–5 companies or drugs in one parallel call, with example natural language queries. Distinguishes from sibling tools by emphasizing it replaces 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?

Explicitly instructs to prefer over sequential lookups when comparing entities, and gives specific use cases (financials for companies, adverse events for drugs). Lacks explicit when-not-to-use, but context is clear.

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

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

Annotations (readOnlyHint, idempotentHint, openWorldHint) already declare the tool's safe, non-destructive, and idempotent behavior. The description adds that it returns 'results/scores', which provides some output detail beyond the annotations. It does not contradict annotations, but the additional transparency is modest given the rich annotation set.

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, clear sentence that efficiently conveys the tool's purpose, includes a concrete example, and is front-loaded. No unnecessary words, though it could potentially be broken into two sentences for slightly better readability.

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

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

For a simple tool with one parameter and no output schema, the description adequately covers what it does and what it returns (results/scores). It is complete enough given the low complexity, though it does not explicitly state that it only returns one matchday or how to handle leagues without a current matchday.

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

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

The single parameter 'league' is fully described in the schema with examples and explanation of shortcuts, so the description adds no additional meaning beyond the schema. With 100% schema coverage, baseline score of 3 is appropriate.

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

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

The description clearly states the tool retrieves current matchday matches for a specified league, with example 'this week's Bundesliga fixtures'. It distinguishes from sibling tools like 'get_matches' (which likely handles other matchday queries) and 'get_table' (standings), making its specific 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 indicates the tool is for current matchday fixtures, but it does not explicitly state when to avoid using it or mention alternatives among siblings. Usage context is implied but clear, lacking explicit guidance on exclusions or when another tool would be more appropriate.

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

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

Beyond annotations (readOnly, idempotent, openWorld), the description discloses extensive behavioral traits: account requirements, depth levels affecting hops and contradictions scan, expected latency, gapped[] for unanswered facets, 'never invented' claim, and semantic excerpting behavior. It also details citation_uri fetchability—richer than anything 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?

Long but dense, earning its length given the tool's complexity. Front-loads account requirement and key 'NOT open-web search' disambiguation. However, some repetition around citation fields and findings packet could be tightened.

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

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

Covers prerequisites, use cases, limitations, output format details, and performance expectations. With no output schema, the description thoroughly explains return structure (findings packet, gaps[], contradictions[], hop, citation_uri) and edge behaviors (empty gaps for off-catalog topics, semantic excerpting). Exceptionally complete for the tool's complexity.

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

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

Schema coverage is 100%, but the description adds practical depth semantics: 'depth:"standard" re-angles unanswered gaps' and 'thorough additionally chases the best leads', which goes beyond the schema enum descriptions. For the 'question' parameter, it clarifies broad/multi-part questions are acceptable, adding useful 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?

Description states a specific verb+resource: 'Grounded multi-source research across Pipeworx's 1455 STRUCTURED data sources' and explains it decomposes questions into facets and routes to 5,529 tools. It explicitly distinguishes from siblings: 'this is NOT open-web search' and contrasts with ask_pipeworx for single 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?

Explicit when-to-use: 'Best for broad/multi-part questions over structured data'. Explicit when-not-to-use with alternatives: 'For a single lookup use ask_pipeworx', 'For BREAKING or colloquial CURRENT-NEWS... prefer ask_pipeworx', and 'If you are not signed in, use ask_pipeworx instead'.

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

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

Annotations already provide safety profile (readOnly, idempotent, non-destructive). Description adds useful behavioral details like returning full schemas with examples and being ready to call directly, but no major behavioral revelations beyond that.

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 main purpose and usage guidance. The list of example domains is a bit lengthy but still efficient. Minor verbosity prevents a 5.

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 what is returned (names, descriptions, full schemas with examples) and the tool's purpose. For a discovery tool with many aliases but only one required param, it is complete.

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

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

Schema coverage is 100%, so the schema already documents all parameters including aliases. Description does not add significant meaning beyond the schema (e.g., when to use each alias). Baseline 3 is appropriate.

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

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

The description clearly states it finds tools by describing the data or task, listing many domains. It distinguishes itself from sibling tools (which are specific research tools) by being a meta-tool for discovering other tools.

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

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

Explicitly says 'Call this FIRST when you have many tools available and want to see the option set (not just one answer),' providing clear when-to-use guidance and implying 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, idempotentHint, and destructiveHint, making the safety profile clear. The description adds valuable behavioral context: parallel fan-out across multiple sources, return structure, and the patent API sunset condition. 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 front-loaded with example queries and provides comprehensive detail in a single paragraph. While slightly dense, every sentence adds value. It could be more structured (e.g., bullet points) but remains 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 (multiple data sources, potential failures), the description covers all necessary aspects: what sources are queried, what data is returned, limitations (patents sunset, only companies, names not accepted), and the parallel execution model. No output schema exists, but return values are described adequately.

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 coverage is 100%, so baseline is 3. The description adds extra meaning beyond the schema: for 'type', it notes only 'company' is supported; for 'value', it re-explains ticker/CIK and advises using resolve_entity for names. This enriches parameter understanding.

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

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

The description clearly states the tool's purpose: providing a full cross-source profile of a US public company in one parallel call. It lists specific data returned (CIK, filings, fundamentals, etc.) and explicitly distinguishes itself from sibling tools by advising preference over chaining 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 when-to-use guidance ('ALWAYS PREFER over chaining...when the user asks for a holistic view') and when-not-to-use ('if you only have a name', use resolve_entity first). It also warns about potential soft-fail for patents, offering clear context for decision-making.

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

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

Annotations already indicate destructiveHint=true, but the description adds context about clearing sensitive data and when to use, which is consistent and informative.

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

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

Two sentences, front-loaded with the main purpose, 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?

Simple tool with one parameter, no output schema, and annotations fully cover destructiveness. The description provides sufficient context for usage and behavior.

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

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

Schema coverage is 100% with clear description of 'key' parameter. The description doesn't add additional meaning beyond what the schema provides, so baseline score applies.

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

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

Description states 'Delete a previously stored memory by key' using a specific verb and resource, and 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 says 'Use when context is stale, the task is done, or you want to clear sensitive data' and suggests pairing with remember and recall, though no negative cases are mentioned.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds that it fetches the page and outputs a single text blob. It does not contradict annotations and provides sufficient behavioral context beyond the structured fields.

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 with no wasted words. It front-loads the verb and resource, then explains the process, output format, and use cases. 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?

For a tool with two input parameters, no output schema, and clear annotations, the description covers input, process, output, and use cases completely. An AI agent has all the information needed to decide 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?

Schema coverage is 100% with both parameters described (url required, max_links with default 25 and max 50). The description does not add meaning beyond the schema; thus baseline 3 is appropriate.

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

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

The description clearly states the verb 'Generate' and the resource 'llms.txt file for any URL'. It details the process: fetch page, extract title/description/key links, emit standard markdown. No sibling tool overlaps with this functionality, so it is well-distinguished.

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: getting a client's site indexed, drafting for own project, or auditing competitor visibility. While it does not explicitly state when not to use, the use cases are clear and no sibling tools compete, so the guidance is adequate.

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 confirm read-only, idempotent, non-destructive. The description adds context about returned fields (teams, kickoff, score, finished status), which is helpful 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?

Two-sentence description efficiently states the core function, optional narrowing, and return data. No extraneous words; 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?

Although there is no output schema, the description lists the key return fields. For a simple read-only tool, this is sufficient to set expectations.

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

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

Input schema covers 100% of parameters with clear descriptions and examples. The description does not add significant new meaning beyond what the schema provides, so 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 retrieves football/soccer match results, scores, and fixtures for a league and season. It specifies return fields (teams, datetime, score, status) and distinguishes from siblings like list_leagues or get_table.

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 scope (single matchday) but does not provide explicit guidance on when to use this tool over alternatives like current_matchday or bet_research.

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, covering safety and behavior. The description adds value by detailing the return fields (position, played, won, draw, lost, goals, goal difference, points), which aids the agent in understanding expected output.

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

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

The description is a single, well-structured sentence. It is front-loaded with the core purpose, includes an example, and lists return fields efficiently without 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's low complexity (2 params, no output schema, simple data retrieval), the description is complete. It explains the output fields and provides an example, which compensates for the absence of an output schema.

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

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

The input schema has 100% coverage with clear descriptions for both parameters, including examples for 'league'. The description adds minimal extra semantics beyond restating the purpose. Baseline 3 is appropriate as schema does the heavy lifting.

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

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

The description uses specific verbs ('Get') and clearly states the resource ('league table / standings for a football / soccer league and season'). It includes an example (Bundesliga) and distinguishes from siblings like 'get_matches' or 'current_matchday' by focusing on standings 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 clearly indicates when to use the tool (to obtain league standings) and implicitly excludes other data types (matches, matchdays). While it does not explicitly state when not to use it, the purpose is distinct enough given the sibling tool names.

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. Description adds value by specifying return fields (id, name, shortcut, season, sport) and scope (German leagues plus others). 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 sentence, front-loaded with action and resource, no unnecessary words. Perfectly 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?

Given zero parameters, no output schema, and rich annotations, the description fully covers what an agent needs: what it returns and that it lists all leagues. Complete for this tool's simplicity.

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

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

No parameters exist; schema coverage is 100%. With zero parameters, baseline is 4. Description adds no parameter info because none are needed.

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

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

Description clearly states 'List all available football / soccer leagues and seasons', specifying the verb 'List' and the resource. It gives examples (e.g., Bundesliga) and distinguishes from sibling tools like get_matches or get_table, which deal with different 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 when you need a list of leagues. No explicit when-not or alternatives, but the tool has zero parameters and a clear purpose, so context is sufficient.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds that it returns only active subscriptions by default, with an option to include inactive ones, and lists the specific fields returned, enriching 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 two sentences: first states purpose and output, second gives usage guidance. No unnecessary words, well 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?

The description covers the main purpose, return fields, and usage guidance. Given no output schema, it provides a helpful summary of what's returned. It lacks details on pagination or limits, but given the simple parameter set, it is sufficiently complete.

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

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

Schema coverage is 100% with the single parameter 'include_inactive' clearly documented. The description does not add extra semantics beyond the schema, so a 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 explicitly states 'List the caller's active subscriptions' with a clear verb and resource. It specifies returned fields, and distinguishes from sibling tools like 'subscribe' and 'unsubscribe' by being a list operation.

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 using this tool to 'review what you're monitoring before adding more or to find an id to cancel,' providing explicit context for when to use it relative to alternatives (subscribe/unsubscribe).

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

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

The description discloses many behaviors beyond the annotations: rate-limited to 5 per identifier per day, free and doesn't count against quota, the claim_token flow for tracking, and the instruction not to paste the end-user's prompt. It also explains what happens after submission (team reads digests daily, signal affects roadmap). This is rich behavioral context that the annotations (all false) do not 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 dense but well-structured. It front-loads the core purpose, then flows into usage conditions, scope exclusions, submission guidelines, claim_token behavior, and rate limits. Every sentence adds information, though it could be slightly tightened (e.g., the 'broken, missing, or needs to exist' phrasing is then expanded into the type enum categories). Overall, efficient for the complexity.

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

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

With no output schema, the description fully explains the return behavior (claim_token, how to read status and resolution). It also covers the full lifecycle: what to submit, how to track, what happens after (read daily, affects roadmap). For a feedback tool with no other output constraints, this is complete and self-sufficient.

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

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

The schema already covers 100% of parameter descriptions, so baseline is 3. The description adds value with the claim_token usage semantics ('pass it back later as pipeworx_feedback({claim_token:"pwfb_…"}) to read whether it was fixed and what changed') and the guidance to describe issues in terms of Pipeworx tools/packs rather than pasting user prompts. This goes beyond the schema's basic field descriptions, earning 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 action: tell the Pipeworx team something is broken, missing, or needs to exist. It distinguishes from siblings by emphasizing it is ONLY for tools served by this Pipeworx connection, and it enumerates categories (bug, feature, data_gap, praise) that map to the tool's purpose.

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

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

Explicit 'Use when' conditions for each feedback type, plus a clear exclusion: if the tool came from a different MCP server, file with that server instead. Provides a concrete alternative ('file it with that server instead') and clarifies which tools are in scope ('Pipeworx tool names are the ones this connection lists').

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=true, destructiveHint=false, and idempotentHint=true. The description adds valuable context: data source (CF analytics-engine), caching behavior (5min-1h), and privacy (no PII). This goes beyond annotations and helps the agent understand trade-offs.

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 (5 sentences) and front-loaded with the most important information (what it returns). Every sentence adds value without redundancy. Ideal length for quick comprehension.

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

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

Given the tool's simplicity (1 parameter, no output schema), the description adequately covers purpose, behavior, and output. It briefly mentions what is returned (top tools, packs, volume) but could be more explicit about the structure of the response. Still, it's sufficient for an agent to understand and use correctly.

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

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

Schema coverage is 100%, and the description enriches the sole parameter (window) by explaining the semantic difference between short and long windows ("what's hot right now" vs. "steady-state demand") and clarifying the default value (24h).

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 ("returns") and clearly defines the output: top tools, top packs, and total call volume. It distinguishes itself from sibling tools by focusing on trending data, not other functionalities like searching or asking questions.

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

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

Three concrete use cases are provided, along with guidance on selecting the window based on desired insight (short-term vs. steady-state). Lacks explicit when-not-to-use or alternatives, but the use cases are clear enough for most 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 indicate readOnlyHint=true, idempotentHint=true, etc. The description adds extensive behavioral context: walking child markets, date-axis/threshold-axis ordering, partition_check with sum of YES prices, fill check against live CLOB depth, semantic anchor with Jaccard similarity, partition filter for placeholder slugs. No contradictions with annotations.

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

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

The description is thorough but somewhat lengthy. It is well-structured with clear sections for each mode and details on fill check, semantic anchor, etc. Every sentence adds value, though minor trimming could improve conciseness without losing information.

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

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

Given the tool's complexity (multiple modes, fill check, semantic anchor, partition filter) and no output schema, the description is highly complete. It explains return format, edge cases (null arb signal, realizable_edge_pp ≤ 0), and how the fill check works, enabling the agent to understand usage and outcomes.

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

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

Schema description coverage is 100%, but the description adds significant meaning: event mode accepts slugs or full URLs, topic mode uses seed questions for cross-event scanning. It provides usage context and examples beyond the schema.

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

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

The description clearly states the tool finds arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It distinguishes three modes (no args, event, topic) with specific verbs and resources, and is distinct from siblings like polymarket_edges and 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 with recommendation, topic for cross-event. Explains why cross-event mode is beneficial and warns when not to trade (realizable_edge_pp ≤ 0). Provides clear alternatives and 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?

The description adds extensive behavioral context beyond annotations: caching at KV level keyed on knobs, diagnostic responses for empty segments, tradeable-edge knobs, and detailed model behavior (e.g., placeholder-slug filter, partition-longshot conditions). Annotations declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, which are consistent with a read-only scanning tool.

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

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

The description is structured with clear sections (MODEL_DRIVEN, STRUCTURAL_ARBITRAGE, CONCENTRATED_LONGSHOT) and front-loads the purpose. However, it is quite dense with technical details; some sentences could be streamlined for conciseness while retaining key information.

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

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

Given 9 parameters, no output schema, and high complexity with three response segments and diagnostics, the description is exceptionally complete. It explains how callers can interpret empty segments via diagnostics, caching behavior, and the edge calculation methodology.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds high-level context like 'TRADEABLE-EDGE KNOBS' and explains how parameters like min_partition_leg_kelly work in the overall framework, providing 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 clearly states the tool scans Polymarket markets to find opportunities where Pipeworx data disagrees with market price, targeting the use case 'what should I bet on today'. It distinguishes from sibling tools like polymarket_arbitrage and polymarket_edge_tracker by focusing on edge detection with specific model families.

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

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

The description explicitly frames the tool for discovering opportunities without paging hundreds of markets, and the detailed model/segment breakdown implies when to use it. However, it does not explicitly state when not to use or compare against alternatives like polymarket_arbitrage for pure 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint true and destructiveHint false. The description adds significant context: it reads from daily snapshots, computes trend/decay, handles gap days, and explains the 60-day TTL history depth. 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 detailed but front-loads the core question. Each sentence adds value, covering purpose, response format, and limitations. Slightly long but well-structured; no wasted words.

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

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

Given the tool's complexity (time-series analysis, computed fields), the description fully explains the response structure (tracked, expired, snapshot_dates), limitations (60-day TTL, snapshot gaps), and parameter semantics. Schema covers all params, so description compensates for lack of output schema.

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

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

Schema coverage is 100% for both parameters (days, window), so baseline is 3. The description adds meaningful context about days (clamp 2-30) and window (snapshot family), and elaborates on the response structure, which is useful given no output 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 specifies a clear verb+resource: it provides edge persistence and decay telemetry from daily snapshots. It directly answers a specific trading question ('how long has this edge existed and is it shrinking?'), which distinguishes it from sibling tools like polymarket_edges that likely provide raw snapshot data.

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

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

The description explains when to use the tool – to differentiate fresh vs. old wide edges – and implicitly advises against using it for intraday data via the LIMITS section. It does not explicitly name alternative tools, but the sibling context suggests polymarket_edges as the underlying source.

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, so the safety profile is clear. The description adds behavioral detail: it walks the order book ladder, returns verdicts (clean|degraded|cannot_fill), and explains the risk of partial basket fills creating unhedged directional positions. This goes beyond annotations, though rate limits or data latency are not mentioned.

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

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

The description is fairly long but well-structured with clear headings (SINGLE-MARKET, BASKET) and a usage directive at the end. Every sentence adds information; no filler. It could be slightly more concise but is acceptable for a complex tool.

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

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

Despite no output schema, the description lists all return fields (top_of_book, vwap_fill_price, etc.) and explains the behavior in both modes. It covers default values, edge cases (thin legs, forced directional risk), and the context of when to call. For a 4-parameter tool, this is comprehensive.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the difference between single-market and basket modes for parameters like side and size_usd, and provides defaults and constraints. It also clarifies what the tool returns (top_of_book, vwap_fill_price, etc.), which the schema omits.

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: 'Realizable-vs-theoretical edge check against live CLOB order-book depth.' It distinguishes two modes (single-market and basket) and explicitly targets pre-trade validation for arb signals and edges above $500, differentiating it from siblings like polymarket_arbitrage and polymarket_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 explicitly states when to use this tool: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500.' It also implies when not to use (small trades) and warns against partial basket fills converting arb into directional positions, providing clear alternatives and context.

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

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

Annotations declare readOnlyHint, idempotentHint, and non-destructive. The description adds extensive behavioral context beyond annotations: it explains the compatibility_warning conditions (shape mismatch, semantic disconnection), temporal_alignment, skipped cross-type/subtype counters, and the real signal vs equivalence check. No contradictions with annotations.

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

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

The description is lengthy but well-structured: purpose first, then modes, response structure, and safety fields each in separate sections. Every sentence adds meaningful information. Could be slightly more concise, but 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 no output schema, the description thoroughly explains the response (leg-by-leg prices, top_spreads_pp, safety fields) and covers edge cases (compatibility_warning in two scenarios, temporal alignment). It is complete for a complex tool with zero required parameters.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the override behavior (explicit tickers override topic-mapped sides), enumerating the 10 topic values, and clarifying that the topic parameter is pre-mapped. This exceeds the baseline.

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

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

The description clearly defines the tool as a cross-venue spread between Kalshi and Polymarket for the same resolving question. It distinguishes itself from siblings by focusing on cross-venue comparison and explicitly mentions two modes (topic and explicit) to cover different use cases.

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 on when to use each mode (topic shortcuts vs explicit tickers) and sets expectations by noting that most pre-mapped topics return compatibility warnings. It implies when not to use (if compatibility warning fires), but does not explicitly list sibling 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 indicate readOnlyHint, idempotentHint, and destructiveHint. The description adds valuable behavioral context: scoping to identifier (anonymous IP, BYO key hash, account ID) and pairing with remember/forget. No contradictions.

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

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

Three sentences, no wasted words. First sentence states core function, second gives examples, third adds scoping and pairing. Front-loaded and efficient.

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

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

Given one optional parameter, no output schema, and thorough annotations, the description fully covers what an agent needs: purpose, usage, scoping, and relationships with siblings.

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

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

Schema coverage is 100% with a description for the key parameter. The description adds examples of use cases (user's target ticker, address, prior research notes), providing meaning beyond the schema. Baseline 3, plus 1 for added context.

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

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

The description clearly states the tool retrieves a value saved via remember or lists all keys when key is omitted. It specifies the verb (retrieve/list) and resource (saved values/keys), and distinguishes from siblings remember and forget.

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

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

The description explains when to use (look up context stored earlier) and how to use (omit key to list all). It references sibling tools remember and forget for lifecycle, but does not explicitly state when not to use or provide alternative tools.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false. The description adds that mark_read affects subsequent calls by tracking reads, which provides useful 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?

Every sentence is valuable and efficiently communicates purpose, filters, behavior, and alternative access. No fluff, well 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?

Despite no output schema, the description lists returned fields (source, citation_uri, raw payload) and mentions polling suitability and an HTTP alternative. Complete for a read-only filter tool.

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

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

Schema coverage is 100%, so baseline is 3. The description adds examples (e.g., 'sec_8k') and clarifies the effect of mark_read, enriching the meaning beyond the schema.

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

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

Description opens with a specific verb+resource: 'Pull fired events from your subscription feed.' It clearly states the tool retrieves recent alerts with specific fields and filtering options, distinguishing it from siblings like list_subscriptions.

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

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

Provides context for polling and points to an alternative via HTTP API for scripts/dashboards. However, it does not explicitly state when not to use this tool versus other sibling tools, lacking exclusion guidance.

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

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

Describes multi-source fan-out, fallback mechanism (GDELT to GNews), soft-fail for USPTO due to API sunset, and return structure. Adds substantial behavioral context beyond annotations (readOnlyHint, idempotentHint, destructiveHint) which already indicate safe, idempotent operation.

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 moderately long but well-structured with example queries upfront, followed by source details and parameter explanations. Each sentence adds value; minimal redundancy. Slight wordiness in the fallback description could be tightened.

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

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

For a tool of this complexity (multiple sources, fallback, soft-fail, flexible date format), the description covers all key aspects: supported inputs, behavior, error handling, and output structure (changes grouped by source, total count, citation URIs). No output schema exists, but description compensates adequately.

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

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

Input schema has 100% coverage, so baseline is 3. Description enhances parameter semantics by clarifying `since` accepts ISO dates and relative shorthand (e.g., '7d', '30d'), `type` is limited to 'company', and `value` can be a ticker or CIK. This provides practical usage details beyond the schema.

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

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

Description clearly states it provides a change feed for a company, enumerating specific data sources (SEC EDGAR, GDELT/GNews, USPTO). Distinguishes from sibling entity_profile, which is for static profiles, making the purpose unambiguous.

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

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

Explicitly states when to use (for 'what's new' queries) and when not to (use entity_profile for static profile). Provides clear alternatives and example queries, guiding the agent on appropriate invocation.

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 value beyond annotations by explaining persistence behavior (authenticated vs anonymous users) and scoping by identifier. Annotations provide idempotentHint=true and destructiveHint=false, which are consistent. However, the description does not explicitly state whether calling with an existing key overwrites the value.

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, front-loaded with purpose, followed by usage guidelines and behavioral details. No redundant or unnecessary information. 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?

For a simple tool with two parameters and no output schema, the description covers purpose, usage, persistence, and pairing with recall/forget. It provides sufficient context for an agent to understand when and how to use it correctly.

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

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

Schema description coverage is 100% with clear parameter descriptions. The description adds context with example key values and states the value is 'any text', but does not significantly expand beyond the schema's own descriptions. 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's purpose: 'Save data the agent will need to reuse later' with a specific verb ('save'), resource ('data'), and context ('across this conversation or across sessions'). It distinguishes from sibling tools like recall and forget by explicitly pairing with them.

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

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

The description provides explicit guidance on when to use the tool: 'when you discover something worth carrying forward' with concrete examples. It mentions pairing with recall and forget, but does not explicitly state when not to use it or alternative tools for different 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?

The description goes well beyond the annotations. It explains that identifiers are labeled with their source, that unresolved identifiers are explicitly listed under 'unresolved', and that LEI/FIGI enrichment degrades gracefully when GLEIF/OpenFIGI are unavailable. It also mentions internal cascading lookups, providing valuable behavioral context.

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

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

The description is well-structured and comprehensive, with a clear opening, supported types, and fallback behavior. Every sentence contributes useful information, and the format is organized for readability. There is no redundancy or fluff.

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

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

For a tool with two simple parameters and no output schema, the description is remarkably complete. It covers entity types, identifiers returned, source labeling, unresolved handling, graceful degradation, and its role relative to other tools. It offers enough detail for an agent to invoke it correctly in a variety of scenarios.

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

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

The input schema already provides 100% coverage for both parameters, including examples and accepted formats. The description mirrors this information without adding significantly new parameter-level meaning. It adds context about return values rather than parameter semantics, so 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: resolving a user-spoken name to canonical/official identifiers required by other tools. It uses a specific verb (resolve) and resource (name to identifiers), and distinguishes itself from siblings by positioning itself as the first-step lookup tool. The supported entity types are explicitly listed.

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

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

The description gives explicit guidance: 'Use FIRST whenever you have a name but need an ID.' It also includes example queries to illustrate usage. However, it does not explicitly state when not to use the tool or name alternative tools, though the phrase 'other tools require as input' implies it is the entry point.

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

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

Annotations already declare readOnlyHint, idempotentHint, etc. The description adds that it internally probes using 'ai_visibility_check' and returns a ranked list with score, confidence, signal density. No contradictions.

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

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

Three sentences cover function, use case, and output. Front-loaded with main action. No unnecessary words, though could be slightly more compact.

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 output fields (score, confidence, signal density) and internal call to ai_visibility_check. Input parameters are well-covered. Minor gap: exact ranking logic not detailed, but sufficient.

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

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

Schema coverage is 100%. The description adds context: entities array 2-8 items, first is subject rest competitors; models default is workers-ai; context disambiguates names. Adds value beyond schema.

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

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

The description clearly states the tool compares AI visibility across multiple entities side-by-side, ranks them, and surfaces most/least recognized. It distinguishes from sibling tool 'ai_visibility_check' by focusing on multiple entities.

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

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

The description provides a use case example and notes the first entity is treated as the subject. It implies use for competitive audits, but could explicitly mention when not to use it (e.g., single entity check) compared to siblings.

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

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

Beyond annotations (readOnly, openWorld, idempotent, not destructive), the description adds critical behavioral details: partial failures degrade gracefully, bundlephobia timeout (5-30s), and sources_failed list included. No contradictions with annotations.

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

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

The description is dense but front-loaded with purpose and key details. It could be slightly trimmed, but every sentence adds meaningful information. No fluff or repetition.

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 (composite call, multiple sources, partial failures) and lack of output schema, the description fully covers return summary block, error handling, version defaults, and ecosystem restrictions. 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 already describes parameters adequately. The description adds marginal value (e.g., scoped packages accepted), but mostly repeats schema info. Baseline 3 is appropriate.

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

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

The description clearly states it performs a composite check for npm packages, covering license, advisories, version history, and bundle size. It specifies the verb-resource combination and distinguishes itself from siblings by being a single-call aggregation.

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 guides when to use: 'when an agent asks is X safe / popular / small' or 'what does adding lodash cost me'. Also clarifies NPM-only scope for v1 and mentions fallback to deps.dev:version for other ecosystems, preventing misuse.

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

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

Annotations already declare readOnlyHint, idempotentHint, etc. The description adds behavioral details beyond annotations: 200K char cap with truncation and flag, BGE-base-en embeddings with cosine similarity over 500-char windows, and return of offsets and similarity 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?

The description is concise (4 sentences) and front-loaded with purpose and usage. Each sentence adds unique value, though it could be slightly tighter. Still, it efficiently conveys key information.

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

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

Despite no output schema, the description explains return values (passages with offsets and scores) and technical details (embedding model, window size). For a 3-param tool, this is fully complete and anticipates agent needs.

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 good descriptions. The description adds value by showing example queries and explaining the limit range (1-20, default 5). This exceeds the baseline 3 expected for high schema coverage.

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

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

The description uses a specific verb ('search inside') and resource ('a fetched record'), clearly distinguishing it from siblings like ask_pipeworx_grounded. It explicitly states that it performs semantic search over a previously fetched text with a natural-language query.

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: use when the record is too large for the prompt, and pairs with ask_pipeworx_grounded. It gives a clear use case and alternatives.

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

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

The description discloses key behaviors: the subscription is created (non-read-only), requires authentication, supports specific types with example parameters, and delivery channels (feed always on, optional email/SMS with limits, webhook with HMAC signing). It adds value beyond annotations, which only hint at idempotency and open-world.

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

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

The description is thorough but not overly verbose. It front-loads the primary purpose and returns type, then details types and delivery. Every sentence adds value, though some repetition with schema descriptions could be trimmed. Still, it is efficiently structured.

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

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

Given the tool's complexity (nested objects, three parameters, no output schema), the description compensates fully. It covers all subscription types, parameter constraints, delivery channels with limits and prerequisites, and even mentions a signing secret. No significant 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?

Although the input schema provides 100% coverage with property descriptions, the tool description adds significant context: it provides concrete examples for each subscription type (e.g., sec_8k with items:['5.02']) and elaborates on delivery channel semantics (SMS cap, webhook signing process, phone verification requirement).

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: 'Create a proactive monitoring subscription to a live-data event stream. Returns the new subscription id.' It uses a specific verb ('create'), identifies the resource ('subscription'), and 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 explicit context for when to use this tool (proactive monitoring of live events) and outlines requirements (Pipeworx OAuth account). It does not directly specify when not to use it or list alternatives, but the detail on supported types and delivery channels helps the agent decide.

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, which the description does not contradict. The description adds useful behavioral context: it returns category-bucketed example questions with tool+argument shapes from the live catalogue, providing insight into the output structure.

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

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

The description is front-loaded with user intents and provides a clear, structured explanation of output and usage. It is reasonably concise, though slightly verbose with the list of categories; no wasted 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 the single optional parameter, full schema coverage, and no output schema, the description provides sufficient context for usage and output. It could mention that the tool is safe (read-only, idempotent) but annotations cover that, so it's not a gap.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning by explaining the effect of omitting topic (full spread) and passing topic (focus), and contextualizes the parameter's role. This goes beyond the schema's simple enumeration.

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 as an onboarding entry point for new users, providing example questions and tool calls. It distinguishes itself from sibling tools like ask_pipeworx and compare_entities by positioning itself as the first tool to use when the agent doesn't know what Pipeworx can do.

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 to use this FIRST when unsure of Pipeworx's capabilities and explains how to invoke it (no arguments for full spread, or pass topic for focus). It does not explicitly state when not to use it, but the guidance is clear enough for correct selection among siblings.

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

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

The description adds important behavioral context: 'The row is deactivated (not deleted) so its historical events stay available via recent_alerts', which goes beyond the annotations' hints (destructiveHint=false, idempotentHint=true).

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

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

The description is two sentences long, front-loaded with the action, 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?

For a tool with one parameter, no output schema, and comprehensive annotations, the description fully covers the behavior, side effects, and retention of historical data, leaving 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?

The input schema already covers the single parameter 'id' with a clear description ('Subscription id (uuid) returned by subscribe'), and the description adds no further parameter details. With 100% schema coverage, the 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 specifies the verb 'Cancel' and the resource 'a subscription by id', clearly distinguishing it from sibling tools like 'subscribe' and 'list_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?

It explicitly states that ownership is enforced ('you can only cancel your own subscriptions'), guiding when to use the tool and indicating that it cannot be used for others' subscriptions.

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

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

Beyond the annotations (read-only, idempotent, etc.), the description discloses crucial behaviors: the use of a structured SEC EDGAR + XBRL fast path with exact percent-delta math, automatic fallback to a grounded pipeline for other claims, the specific verdict types returned, the 'pipeworx:// citation', and the critical distinction between 'could_not_verify' (check did not happen) and 'unsupported' (no source). It also warns callers not to display 'could_not_verify' as evidence. This is far 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?

Although the description is long, it is efficiently packed with actionable information. It is front-loaded with trigger phrases and the core purpose, then logically expands into routing, outputs, verdict semantics, and a caller warning. Every sentence earns its place; no fluff or 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?

With no output schema, the description fully compensates by detailing the return verdicts (confirmed, approximately_correct, refuted, inconclusive, unsupported, could_not_verify), the grounded/structured actual value with citation, and the reasoning. It also covers error semantics for 'could_not_verify' with verification_error{stage,detail}. For a tool of this complexity, the description is complete.

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

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

Schema coverage is 100%, and the description adds substantial semantic value. 'claim' is explained with natural-language examples and format expectations; 'tolerance_pct' is given a full behavioral explanation (overrides implied tolerance, range, default cap of 5, and use case for hallucination detection). This goes well beyond the bare 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 uses a specific verb ('validate', 'check', 'verify') and clearly identifies the resource (factual claims against authoritative sources). It is explicitly distinguished from sibling tools by focusing on natural-language claim verification, and it provides concrete trigger phrase examples making the purpose unmistakable.

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

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

The description explicitly states when to use it: 'Use whenever the agent needs to check whether something a user said is factually correct.' It further explains the two distinct routing paths (SEC EDGAR for company-financial claims, grounded pipeline otherwise) and emphasizes that 'could_not_verify' means the check did not happen and should not be treated as evidence. It also positions the tool as a replacement for 4–6 sequential calls, giving clear operational guidance.

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