Nasa

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds value by specifying the return format (per-model object with score, confidence, signals, raw_response + combined view) and the cost implication of using Anthropic (BYO key, pay Anthropic). This complements the annotations well.

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 dense sentences, no wasted words. The core action and output are front-loaded (first sentence). Additional details about models, API key, and return format are efficiently packed. Every sentence earns its place.

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

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

For a tool with 4 params, no output schema, and annotations covering safety, the description is complete enough. It covers use case, parameter selection, and return structure. One could imagine mentioning pagination or rate limits, but the tool appears to return a combined view without pagination, so it's adequate.

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

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

Schema coverage is 100%, so the schema already documents parameters. The description adds meaningful context: default model identity (Workers AI Llama-3.3-70b), that it's free, that `_apiKey` is only needed for Anthropic, and that `context` disambiguates common names. This goes beyond the schema descriptions.

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

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

The description clearly states the tool probes LLMs for knowledge about a business/brand/product/topic and scores visibility (0-100) per model. It specifies the default model and optional Anthropic probe, distinguishing it from sibling tools like 'entity_profile' or 'scan_competitor_ai_presence' which focus on entity resolution or competitive scanning rather than AI model awareness.

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 mentions utility for AI-marketing audits, pre-launch brand checks, and competitive monitoring. It explains when to use the free Workers AI model and when to provide an API key for Anthropic. While it does not explicitly list alternatives or exclusions, the context is clear and practical.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds context: routes across 5,501 tools, fills arguments, returns pipeworx:// citation URIs, and works on every tier. This goes beyond annotations without contradicting them.

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

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

The description is detailed but somewhat redundant, repeating 'prefer over web search' and 'START HERE' ideas. It is front-loaded with key guidance but contains a long list and some promotional phrasing like 'one fast call' that could be trimmed.

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

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

Given the tool's complexity and lack of output schema, the description adequately explains purpose, scope, alternatives, and return format (structured answer with citations). It covers the broad data categories and gives examples, though it doesn't detail error cases or what happens if no tool matches.

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

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

Schema covers all parameters with aliases and descriptions. The description adds value by providing example questions and specifying 'natural language' input, which helps the agent correctly fill the `question` parameter. Baseline 3 is raised due to the extra guidance.

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

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

The description clearly states the tool's function: routes questions to specialized tools across thousands of sources and returns structured answers with citations. It distinguishes itself from web search and sibling tools like ask_pipeworx_grounded and deep_research.

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

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

Provides explicit guidance on when to use this tool versus alternatives: prefer over web search, use for factual questions, step up to ask_pipeworx_grounded for verbatim evidence, deep_research for broad questions, and notes news feed handling. Includes concrete examples.

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 that this is a beta with potentially active routing improvements, currently no candidate is active (as of 2026-07-26), and that it is a full working router despite the beta label. This adds context beyond the annotations, which already declare readOnly/idempotent/openWorld. It does not contradict the annotations.

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

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

The description is about 70 words across four sentences, each carrying distinct information: beta status, current state, usage instruction, and reassurance it's fully functional. It is well-structured and front-loaded with the tool's identity.

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 (a universal router with 5,501 tools), the description covers its identity, current state, usage, and result comparison. It notes the same response shape as ask_pipeworx, compensating for the lack of an output schema. No major gaps are apparent.

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

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

The input schema already documents all six parameters with 100% coverage, including aliases for 'question'. The description adds no parameter-specific details beyond saying 'same arguments' as ask_pipeworx, so it meets the baseline but doesn't elevate it.

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

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

The description clearly identifies the tool as a beta version of ask_pipeworx, an identical universal router with the same 5,501 tools, arguments, and response shape. It distinguishes it from the stable ask_pipeworx by noting candidate routing improvements and its experimental edge. The verb 'use' and resource 'router' make the function clear.

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 instructs to use it exactly like ask_pipeworx when you want the newest routing, and explains that results are compared against the stable router to decide merges. This provides a clear trigger (experimental routing) and implies not to use it for stable/production needs. It doesn't mention ask_pipeworx_grounded but adequately differentiates from the primary sibling.

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

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

Beyond annotations, the description discloses refusal behavior with specific refusal_reason values, return structure details, and cost of one extra LLM call. It clarifies that answers are extracted only from tool results, adding meaningful context not present 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 dense but efficiently packed with essential information: purpose, behavior, return format, usage guidance, and cost comparison. Each sentence adds value, though it is longer than minimal; slightly more concise would earn 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?

With no output schema, the description fully explains the return structure on success and failure, including nuanced refusal reasons. It covers high-stakes use cases, alternative tool, cost, and routing details, making the tool self-contained and complete for an agent to invoke correctly.

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

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

Schema coverage is 100% and all parameters are aliases for the same 'question' field, with the schema already describing it as 'Your question in natural language.' The description adds no additional parameter semantics beyond what the schema provides, so 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 clearly states this is a 'Hallucination-resistant answer mode' that extracts answers using only tool results, explicitly distinguishing it from sibling ask_pipeworx by noting 'Same routing as ask_pipeworx' and the extra LLM call cost. The purpose is specific and differentiates the tool from other siblings.

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

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

Provides explicit when-to-use guidance: 'Use whenever an answer will be quoted, cited, or acted on...' and lists example high-stakes domains. It also names the alternative: 'prefer ask_pipeworx for casual lookups,' offering clear direction 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?

The description extensively covers behavioral traits beyond annotations: resolution confidence, market matching, closed market handling, wide spread warnings, resolution-rule risk, and safety short-circuits. All align with readOnlyHint and non-destructive hints.

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

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

Very long, dense paragraph without section breaks. While packed with value, it could be more scannable with headers or shorter sentences. Some redundancy exists (e.g., resolution risk details).

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

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

Given the complexity (3 parameters, no output schema), the description covers input formats, classifiers, fan-out, response shapes, resolver contract, parent events, news fallbacks, safety, closed markets, spreads, and cancellation rules. Very thorough.

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 significant meaning: market can be slug, URL, or text; depth enum explained; include_raw with payload size guidance. This goes beyond the schema alone.

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

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

The description clearly states it researches Polymarket bets by pulling Pipeworx data. It specifies the verb 'Research' and the resource 'Polymarket bet', and distinguishes from sibling tools like polymarket_arbitrage by focusing on data gathering and edge analysis.

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

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

Explicit usage cases are given: 'should I bet on X', 'what does the data say about Y', 'is there edge in Z'. It provides examples of fan-out for different bet types, but lacks explicit when-not-to-use instructions.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds rich behavioral context: for company type, it pulls latest 10-K data from SEC EDGAR/XBRL with correct fiscal year handling; for drug type, it pulls FAERS, FDA, trial counts; results sorted by primary metric; returns paired data with citation URIs. 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 a single paragraph that efficiently front-loads usage patterns and key details. Every sentence adds value, with no redundancy or fluff. It is concise yet comprehensive.

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

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

Given the simple schema (2 parameters, no output schema), the description fully explains the return format (paired data, citation URIs, sorted), data sources, and behavior per entity type. It compensates for the lack of output schema and provides all necessary context for correct invocation.

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

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

Schema has 100% coverage with descriptions for both parameters (type enum and values array). The description adds further semantics: explains that for company, values are tickers/CIKs; for drug, values are names; and provides examples. This goes 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 purpose: side-by-side comparison of 2–5 companies or drugs in one parallel call. It lists trigger phrases like 'Compare X and Y', 'which is bigger', etc., and distinguishes from sequential lookups, which is also a sibling tool (entity_profile).

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

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

Explicitly says 'ALWAYS PREFER over sequential single-pack lookups when comparing entities.' and notes it replaces 8–15 sequential lookups. This provides clear when-to-use guidance and implies when not to use (single entity lookups).

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

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

Annotations already declare readOnly/openWorld/idempotent/non-destructive, and nothing here contradicts that. The description adds substantial behavioral context: account requirement with paid tier for thorough, findings packet structure with gaps[] and contradictions[], fetchable citations, semantic excerpting of large records, depth-specific hop behavior, and latency estimates.

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 and dense—roughly 300 words in one block—and repeats ask_pipeworx comparisons three times. It is front-loaded with the critical account/signup requirement, but the over-verbosity and lack of sectioning make it harder for an agent to parse quickly. Not as concise as it could be, though no sentence is purely filler.

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 covers the return structure (verbatim evidence, confidence, source, fetched_at, pipeworx:// citations, gaps[], contradictions[]) and operational expectations (latency, prerequisites, failure modes). There is no significant missing context for an agent to decide, invoke, and interpret results 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 both parameters are described, but the description adds practical nuance: clarifies that the question can be broad/multi-part, explains depth variants ('quick' single-hop, 'standard' adds gap recovery and contradictions, 'thorough' is paid and iterative), and links depth to the number of facets. This enriches the schema rather than merely repeating it.

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

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

Specific and explicit: it states the tool performs grounded multi-source research across 1,441 structured data sources in one call, decomposing questions into facets and routing to 5,501 tools in parallel. It clearly distinguishes from siblings by noting it is NOT open-web search and naming ask_pipeworx as the single-lookup alternative.

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 comprehensive when-to-use and when-not-to-use guidance: best for broad/multi-part structured-data questions; use ask_pipeworx for single lookups, breaking/current-news topics, or when not signed in. It even notes the failure mode (empty gaps[]) for topics not in the structured catalog.

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 and idempotentHint=true, indicating safe, non-destructive reads. The description adds behavioral value beyond annotations: it explains that each result includes full input schemas with curated examples, ready to call directly without a second lookup. 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?

Description is moderately long but well-structured: core purpose first, then usage context, then return details, then call guidance. Every sentence adds value. Could be slightly tightened 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 (discovery among many siblings) and absence of output schema, the description sufficiently explains what is returned (top-N tools with names, descriptions, and full input schemas with examples). It covers the key aspects an agent needs to understand the tool's role.

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% (6 parameters all described). The description adds meaning by clarifying that query accepts natural language and multiple aliases (q, task, description, search) are interchangeable. It also mentions default and max limit values (20, 50), which are present in the schema but reinforced.

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

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

The description starts with 'Find tools by describing the data or task,' providing a specific verb and resource. It clearly distinguishes this discovery tool from the many sibling tools (e.g., get_asteroids, get_mars_photos) by stating it returns the top-N most relevant 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 states 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' This provides clear context on when to use it. While it doesn't explicitly list when not to use, the recommendation to use it first implies its role as a navigational 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 declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. Description adds details: fans out across multiple sources, returns specific fields, notes soft-fail for patents (USPTO API sunset). 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?

Description is somewhat long but well-structured. Front-loaded with examples and key guidance. Each 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?

No output schema, but description thoroughly explains return fields (cik, recent_filings, fundamentals, patents, news, LEI) and limitations (names unsupported, patents soft-fail). Complete for a complex multi-source 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 100%, baseline 3. Description adds beyond schema: clarifies value must be ticker or CIK (not names), gives examples, and notes type is only 'company' for now.

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

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

The description clearly states the tool provides a full cross-source profile of a US public company, with multiple example queries. It distinguishes itself from siblings 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?

Explicitly states when to use (holistic view) and when not (if only a name, use resolve_entity first). Also says 'ALWAYS PREFER' over alternative approaches.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true. Description adds context about clearing sensitive data but does not detail other behaviors like permissions or error handling. Adds some value beyond annotations.

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

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

Two concise sentences: first states action, second provides usage guidance. No fluff, front-loaded with purpose.

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 simplicity (1 param, no output schema) and good annotations, description covers purpose, usage, and pairing. Missing detail on reversibility or non-existent key behavior, but acceptable for a simple destructive 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 covers the single parameter 'key' with clear description. Description does not add extra semantic meaning beyond what the schema provides; baseline 3 is appropriate.

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

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

Description uses specific verb 'Delete' and resource 'previously stored memory by key', making purpose clear. It mentions pairing with remember and recall but does not explicitly differentiate when to use each sibling.

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 usage contexts: 'when context is stale, the task is done, or you want to clear sensitive data'. No explicit when-not-to-use or alternatives, but the pairing hint partially covers guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds behavioral context: it fetches a page, performs extraction, and emits markdown. There is no contradiction with annotations and the added detail clarifies expected side effects (none beyond a network fetch).

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: three sentences covering action, process, and use cases with no redundant content. Information is 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 the low complexity (2 params, no output schema) and comprehensive annotations, the description fully covers the tool's purpose, behavior, and output format (single text blob). No gaps remain for an AI agent to select or invoke this tool correctly.

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

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

Schema description coverage is 100% for both parameters (url and max_links), so the baseline is 3. The description does not add new parameter-level meaning beyond restating the schema's descriptions, though it frames the use context. No additional enumerations or constraints are provided.

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 resource 'llms.txt file', specifies the purpose ('so AI crawlers can index the site cleanly'), and details the process (fetches page, extracts title/description/key links). It is well distinguished from sibling tools, none of which generate llms.txt.

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 three explicit use cases (getting a client's site indexed, drafting for own project, auditing competitor) which guide when to use. It does not explicitly state when not to use or name alternative tools, but the guidance is clear enough for an AI agent.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the description's addition of 'with explanation' and the example add context but do not significantly enhance behavioral understanding beyond annotations. No contradictions.

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

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

Two sentences plus an example, with no wasted words. The most critical information (what it does and the optional date) is front-loaded.

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

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

Given the existence of an output schema (handling return values), the description completely covers what an agent needs to know: it retrieves APOD with explanation, optionally for a date. Examples further aid understanding.

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 reinforces optionality and provides an example, but does not add new meaning beyond the schema's descriptions.

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

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

The description clearly states the tool retrieves the NASA Astronomy Picture of the Day with an explanation, and the name and title reinforce this. It is distinct from sibling tools like get_asteroids or get_mars_photos, which focus on different NASA 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 get APOD) and mentions the optional date parameter. However, it does not explicitly state when not to use it or provide alternatives, though siblings are sufficiently different that guidance is less critical.

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, and non-destructive behavior. The description adds that it returns size, velocity, and miss distance, which is consistent and provides extra behavioral context without contradicting annotations.

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

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

The description is two sentences plus an example, with no unnecessary words. It is front-loaded with the purpose and constraints, making it highly 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 annotations covering safety and idempotency, the output schema, and the description mentioning return fields, the tool definition is fully complete for an AI agent to select and invoke correctly.

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

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

Schema coverage is 100%, so the description adds value by providing an example call and clarifying the date range constraint. This goes beyond the schema's property 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 specifies the verb 'get', the resource 'near-Earth asteroids', and the constraints 'within a date range (max 7 days)'. It also lists key return fields, making it distinct from siblings like get_apod or get_mars_photos.

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

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

The description states the maximum date range of 7 days and provides an example, giving clear usage context. However, it does not explicitly mention when not to use this tool or suggest 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 read-only, open-world, idempotent, non-destructive. Description adds keyless access, image resolution details, and capture time fields, enriching the behavioral context without contradiction.

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

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

Front-loaded with query examples, but slightly verbose. Every sentence adds value, though a minor trim could improve conciseness.

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

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

For a query tool with an output schema, the description fully covers input, constraints, and examples. No missing context for an agent to invoke correctly.

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

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

Schema coverage is 100%, and description adds context like default limit, short forms for cameras, and explanation of sol meaning. Examples further clarify usage.

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

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

The description clearly states the tool retrieves raw images from NASA's Perseverance rover with filtering by sol and camera. It distinguishes itself from siblings like search_nasa_images by specifying it covers only Perseverance.

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 query examples and guidance on when to omit parameters. Explicitly excludes other rovers (Curiosity, Opportunity, Spirit), telling the agent 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 (readOnlyHint, idempotentHint, destructiveHint) already indicate safe, read-only behavior. Description adds no behavioral details beyond the annotations, but does not contradict them.

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

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

Two sentences, no fluff. First sentence states purpose and return data, second provides usage examples. Efficient and 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?

Covers what is returned and typical use cases. Lacks mention of default date ranges (handled by schema). Overall complete for a simple read-only tool.

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

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

Schema coverage is 100%, and description does not add parameter details beyond the schema. Baseline score of 3 applies per rules.

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

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

Description clearly states the tool gets recent solar flares from NASA DONKI data, lists returned fields (class, times, source region, active region number), and provides example queries. Differentiates from siblings like get_apod and get_asteroids by focusing on space-weather data.

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

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

Explicitly describes when to use (e.g., 'recent solar flares', 'is there solar activity / a solar storm'). Does not mention when not to use or alternative tools, but context makes it clear this is for space-weather queries.

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, effectively communicating safety. The description adds details about returned fields but does not disclose additional behavioral traits such as pagination or rate limits. With strong annotations, a baseline score is appropriate.

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

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

Two sentences with no wasted words. Front-loaded with purpose, then return fields, then usage guidance. 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 simplicity (one optional parameter, no output schema needed), rich annotations, and full schema coverage, the description is complete. It sufficiently explains what the tool does and when to use it.

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

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

Schema coverage is 100% with a clear description for the only parameter, include_inactive. The description does not add further semantics beyond the schema, so a baseline score of 3 is suitable.

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 'list the caller's active subscriptions'—a specific verb (list) and resource (subscriptions) with scope ('caller's active'). It also enumerates return fields, distinguishing it from siblings like subscribe and unsubscribe.

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

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

Provides explicit when-to-use guidance: 'Use this to review what you're monitoring before adding more or to find an id to cancel.' Does not explicitly mention when not to use or alternatives, but the context among sibling tools like subscribe/unsubscribe makes this acceptable.

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 all-false annotations, the description discloses the claim_token return behavior ('Filing without an account returns a `claim_token`'), rate limiting ('Rate-limited to 5 per identifier per day'), and cost semantics ('Free; doesn't count against your tool-call quota'). These are behavioral traits not visible in annotations or schema.

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 the purpose, then compactly covers exclusions, claim-token workflow, and rate limits. Every sentence carries distinct operational information with no filler, despite being a single dense paragraph.

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 still explains the key return behavior (claim_token), limitations, and scope. Combined with the rich optional schema, an agent has enough context 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 coverage is 100%, giving a baseline of 3. The description adds practical context for the message field ('don't paste the end-user's prompt') and the claim_token workflow (pass it back as pipeworx_feedback({claim_token:"pwfb_…"}) to check status), which the schema only partially conveys.

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 first sentence, 'Tell the Pipeworx team something is broken, missing, or needs to exist,' states a specific verb and resource, clearly distinguishing it from sibling research/query tools. It also enumerates feedback categories (bug, feature/data_gap, praise) and scopes it to Pipeworx connection 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?

It explicitly says 'Use when a tool returns wrong/stale data (bug)...' and provides a hard exclusion: 'ONLY for tools served by this Pipeworx connection' — with the alternative of filing with the other MCP server. This is clear when-to-use vs. when-not-to-use guidance.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive. The description adds valuable context: self-aggregating signal, derived from CF analytics-engine, no PII, and caching details (5min-1h). 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?

Three sentences, no fluff. Front-loaded with main output and immediate use cases. Every sentence earns its place with actionable information.

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

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

Given no output schema, the description adequately explains return structure (top tools, packs, call volume) and caching. It could mention count or format details for completeness, but overall sufficient for a simple read 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 covers the single parameter (window) with enum and 100% description coverage. Description adds behavioral nuance: shorter windows show hot now, longer windows show steady-state demand, which aids selection.

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

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

The description clearly states it returns top tools, top packs, and total call volume over a window. Specific verbs like 'returns' and use cases (discovering hot data, confirming canonical choice) make the purpose distinct from sibling tools.

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

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

Explicitly lists three use cases and explains how window choice affects results. However, it does not mention when not to use this tool or name specific alternatives, leaving room for improvement.

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

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

Annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint) match the scanning nature. The description adds rich behavioral context: monotonicity checks, partition logic, semantic anchor, fill check mechanics, and response structure. No contradictions.

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

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

The description is thorough but slightly verbose. It uses section-like structure (monotonicity, semantic anchor, partition filter, fill check) and front-loads the core purpose. Every sentence adds value, though some details could be streamlined.

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

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

Despite no output schema, the description comprehensively details the response structure (opportunities[], partition_check, fill check results) and covers edge cases (skipped_low_similarity, placeholders filtered, thin_legs). References related tool for custom sizing.

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

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

Schema coverage is 100%, but the description adds meaning beyond field names: explains each mode's behavior, gives example values ('fed-decision-may-2026'), and describes default behavior when no arguments are passed.

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 specifies three modes (default, event, topic) and distinguishes from sibling tools, none of which perform arbitrage.

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

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

Explicitly tells when to use each argument: no args for trending scan, 'event' for a specific market slug, 'topic' for cross-event scanning. Includes guidance on when not to trade (fill check yielding realizable_edge_pp <= 0).

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 read-only, open-world, idempotent, non-destructive behavior. The description goes far beyond by detailing caching, edge calculation, slippage, model families, diagnostics, and knob effects, leaving no behavioral ambiguity.

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 numbered segments and bolded terms, but it is verbose. While the detail is useful, it could be trimmed to improve conciseness without losing crucial 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 complex behavior, 9 parameters, and no output schema, the description covers output structure, caching, knob effects, and diagnostic information, making it complete for an agent to use effectively.

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

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

Schema coverage is 100%, but the description adds significant nuance to each parameter—e.g., explaining slippage context, min_kelly filtering rationale, and tradeable-edge knobs. This extra context is valuable for proper tool invocation.

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

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

The description clearly states that the tool scans Polymarket markets to find opportunities where Pipeworx data disagrees with market price, using a specific verb-resource pair. It distinguishes itself from siblings by detailing its unique model families and 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?

The description positions the tool for 'what should I bet on today' and explains the segments and knobs, providing clear usage context. However, it lacks explicit guidance on when not to use it or direct comparison to sibling tools, which would improve clarity.

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 show readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds valuable context: it uses daily snapshots, tracks time-series, notes gaps from cache-misses, and discloses limitations like 60-day TTL and daily close decay. 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?

Description is well-structured: purpose first, then parameters, response details, limitations. It is thorough but slightly verbose; every sentence adds value but 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?

No output schema exists, so description fully explains return structure: tracked[], expired[], snapshot_dates[] with field meanings and examples. Covers limitations and edge cases (gaps, TTL). Complete for a time-series analysis 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%, baseline 3. Description adds default values and clamp for days, and default window, but these are already in schema. No additional meaning beyond schema.

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

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

The description clearly states the tool provides edge persistence and decay telemetry from daily snapshots. It answers a specific question about edge age and narrowing, distinguishing it from the sibling tool polymarket_edges by focusing on time-series analysis rather than current edges.

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

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

The description explains when to use it: to assess whether an edge is fresh or old, with the example that a 3-week-old wide edge is different. It implies the alternative is polymarket_edges for current edges, but does not explicitly list when not to use it.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, etc.), the description reveals internal behavior: it walks the order-book ladder, computes VWAP fill price, slippage, and returns a verdict. It warns about thin books and forced directional risk. This adds significant behavioral context that annotations alone 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 well-structured with clear section headers (SINGLE-MARKET, BASKET) and uses capitals for key requirements. It is somewhat verbose but every sentence adds necessary detail for a complex tool. It could be slightly more terse but remains effective.

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

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

Given the tool has no output schema, the description thoroughly explains return fields (top_of_book, vwap_fill_price, etc.) and covers edge cases like thin_legs and forced_directional_risk. It also mentions usage context (above ~$500, arb signals). The description is complete for an agent to understand inputs, outputs, and risks.

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 dual-mode interpretation of side (auto for baskets) and clarifying that size_usd is settlement notional for baskets. 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 opens with a precise verb+resource: 'Realizable-vs-theoretical edge check' against 'live CLOB order-book depth'. It distinguishes itself from siblings by explicitly stating to use this before acting on polymarket_arbitrage or polymarket_edges signals, and it outlines two distinct modes (single-market and basket) with clear definitions.

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

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

The description provides explicit when-to-use guidance: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500'. It also explains the rationale (partial basket fills convert arb into unhedged directional position) and states the required parameters (market or event), effectively telling the agent when to choose this tool over 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 goes far beyond annotations by detailing behavioral traits: typical spread range (2-25pp), handling of non-equivalent bet shapes, all safety fields (compatibility_warning, temporal_alignment, skipped_cross_type/subtype), and the real-world rarity of actionable spreads. No contradictions with annotations (readOnlyHint, openWorldHint, etc.).

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?

While long, every sentence provides essential context for a complex tool. The description is front-loaded with purpose and modes. It could benefit from clearer sectioning (e.g., modes, safety, response format), but it earns its length by covering edge cases and warnings.

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

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

Given the complexity and absence of an output schema, the description adequately explains the response structure (leg-by-leg prices, matched spreads, safety fields) and error conditions. However, it does not fully specify the JSON structure of the response beyond mentioning top_spreads_pp, leaving some ambiguity for the agent.

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

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

Schema coverage is 100% with descriptions for all three parameters. The description adds significant value by explaining the override behavior between topic and explicit parameters, listing the 10 shortcut values, and providing examples. This exceeds the baseline 3 expected when schema coverage is high.

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

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

The description clearly identifies the tool as computing cross-venue spread between Kalshi and Polymarket for the same resolving question. It uses specific verbs ('computes','compares') and resource ('spread'), distinguishing it from sibling tools like polymarket_arbitrage which focus on single-venue arbitrage.

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

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

The description explains two modes (pre-mapped topic shortcuts vs explicit tickers) and includes warnings about when spreads are not meaningful (compatibility_warning cases, temporal misalignment). It implicitly guides use by cautioning that most pre-mapped topics currently return warnings. However, it does not explicitly state when NOT to use the tool or compare to siblings like polymarket_edges.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds beyond this by stating the scope ('Scoped to your identifier...') and the dual behavior of retrieval vs. listing. No contradiction with annotations.

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

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

Two sentences front-load the core action, include context, and mention related tools. No fluff; every sentence is informative and necessary.

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

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

Given the simple tool (1 optional parameter, no output schema), the description covers behavior, scoping, and relationship to siblings completely. No gaps remain for effective agent use.

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

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

Schema coverage is 100% with a description for the 'key' parameter. The description largely restates schema info but adds the context of listing when key is omitted. Since schema does heavy lifting, extra value is minimal but present.

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 'Retrieve[s] a value previously saved via remember, or list all saved keys' with a specific verb and resource. It distinguishes itself from siblings like remember and forget by explicitly naming them, providing clear scope.

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 look up context the agent stored earlier... without re-deriving it from scratch') and mentions pairing with remember/forget. It does not explicitly exclude alternatives, but the context is clear enough for an AI agent.

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

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

The description adds behavioral details beyond the annotations: it specifies returned fields (source, citation_uri, raw payload), explains the 'mark_read' behavior, and mentions the feed is persisted. Annotations already indicate readOnly and idempotent, so the description complements without contradiction.

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

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

The description is concise: two sentences, front-loaded with purpose, and each word adds value. No redundancy, efficient structure.

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

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

Given no output schema, the description covers return fields and key behaviors (mark_read, polling). It could mention ordering (most recent) but lacks details on pagination behavior for 'limit'. Still, it is largely complete for a read-only tool.

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

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

The input schema has 100% description coverage, so the baseline is 3. The description adds value by providing usage examples (e.g., filter by type 'sec_8k', use ISO timestamp for 'since', and set 'mark_read:true') that clarify how parameters are used together.

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 pulls fired events from the subscription feed and returns recent alerts. It uses specific verbs like 'pull' and 'returns', and identifies the resource ('subscription feed'). However, it does not explicitly distinguish itself from sibling tools, leaving some ambiguity.

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 usage context: 'Polls work fine' and mentions an alternative endpoint for scripts/dashboards. It implies this tool is appropriate for polling, but does not explicitly state when not to use it or compare with other tools like 'subscribe' or 'list_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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, but the description adds rich behavioral detail: fan-out to multiple sources, GDELT→GNews fallback, USPTO soft-fail, and grouping of results. No contradictions with annotations. This exceeds what annotations alone 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 front-loaded with example queries, making the tool's intent instantly clear. Despite its length, every sentence adds necessary detail about sources, fallbacks, parameter formats, and return structure. No redundant or vague statements.

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 3 parameters, 100% schema coverage, no output schema, and no nested objects, the description is remarkably complete. It explains the tool's multi-source behavior, parameter options, output structure (changes[], total_changes, citation URIs), and provides sibling differentiation. No additional details are needed for an AI agent to invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is high. The description adds value by explaining accepted formats for 'since' (ISO date or relative shorthand like '7d', '30d', '3m', '1y') and providing a concrete monitoring recommendation. It reinforces the 'value' parameter can be ticker or CIK, and the 'type' enum is limited to 'company'. This aids parameter utilization 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 provides a 'change feed for a company in the last N days/weeks/months' and lists specific data sources (SEC EDGAR, GDELT→GNews, USPTO). Example queries like 'what's new with X' and 'latest on Y' make the purpose immediately recognizable. It explicitly distinguishes from sibling tool 'entity_profile', which provides static profiles.

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 strong guidance on when to use this tool versus entity_profile: 'Use entity_profile instead when you want the static profile.' It also gives example queries and parameter hints (e.g., '30d' for typical monitoring). However, it doesn't explicitly state when not to use it beyond the sibling comparison.

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 idempotence and non-destructiveness. Description adds key behavioral details: scoped by identifier, authentication-based persistence (persistent vs 24-hour TTL), and storage as key-value pair. 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?

Four tight sentences front-loading purpose, followed by usage context, behavioral details, and tool pairing. No wasted words.

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

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

For a simple 2-param tool with no output schema, the description fully covers purpose, usage patterns, persistence details, and relationships to sibling tools. Complete and self-contained.

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

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

Schema covers both parameters with descriptions. Description adds real-world examples (ticker, address, preference) and clarifies value is free text, enhancing the schema's explanation.

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 'Save data the agent will need to reuse later', specifying a verb (save) and resource (key-value pair). It distinguishes from sibling tools like recall and forget, which are retrieval and deletion respectively.

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: 'when you discover something worth carrying forward'. Mentions pairing with recall and forget, but does not explicitly exclude scenarios like transient data requiring no persistence.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior. Description adds useful context about internal cascading lookups, auto-disambiguation, and citation URIs, enhancing transparency without contradicting annotations.

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

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

The description is well-structured, opening with natural-language triggers, then usage directive, then supported types with output specifics. Each sentence provides distinct information without redundancy, and the length is appropriate for a two-type lookup 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?

Even without an output schema, the description specifies return fields for both company (ticker, CIK, company_name, citation) and drug (RxCUI, ingredient, brand, citation). It also discloses internal cascade behavior, making it fully complete for choosing and invoking the 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 detailed type enum and value descriptions. Description adds semantic nuance like 'auto-disambiguated' and reiterates accepted formats, which helps clarify ambiguous company name inputs beyond the schema.

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

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

Clearly states it resolves user-spoken names to canonical/official identifiers. Provides specific trigger examples ('What's the ticker for…', 'find the CIK for…') and distinguishes from siblings by noting other tools require these IDs as input.

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 FIRST whenever you have a name but need an ID' and notes it replaces 2-3 manual lookups. Gives clear context on supported types and input formats, but does not mention when-not cases or alternatives beyond this directive.

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 false, so safety is clear. The description adds behavioral details: it probes each entity with ai_visibility_check, ranks by score, surfaces most/least recognized, and returns score, confidence, signal density. This meaningfully extends 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 sentences that front-load the core action and result. The example question adds flavor but is not essential. Could be slightly more concise, but overall efficiently communicates purpose and output.

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

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

No output schema, but the description explains the return format (ranked list with score, confidence, signal density). It covers purpose, input constraints (2-8 entities), and integration with ai_visibility_check. Some behavioral details like ordering or tie-breaking are missing, but sufficient for an aggregation tool.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds minimal parameter meaning beyond the schema (e.g., 'first entry treated as subject for narrative'). It does not elaborate on 'models' or '_apiKey' beyond schema descriptions, so no significant added value.

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

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

The description clearly states the tool compares AI visibility across multiple entities, probes each with ai_visibility_check, and ranks them. It uses specific verbs ('Compare', 'Probes', 'ranks') and distinguishes from the sibling ai_visibility_check (single entity) and compare_entities (generic comparison without AI focus).

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 a concrete use case ('competitive AI-marketing audits') and an example question. It implicitly differentiates from single-entity probing but does not explicitly state when not to use or name alternatives. The sibling list includes ai_visibility_check and compare_entities, which are related but unaddressed.

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

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

Beyond annotations (readOnlyHint, idempotentHint, etc.), the description discloses latency (bundlephobia first measurement 5-30s), graceful degradation (sources_failed lists timeouts), and return format (summary block, advisories, links, alternatives). No contradiction with annotations.

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

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

The description is detailed and well-organized, front-loading purpose and then details. It is slightly verbose but every sentence contributes value, earning a 4.

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 return values (summary block, advisories, links, alternatives). It also covers limitations, partial failures, and default behavior, making it complete for its 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 description coverage is 100% for both parameters. The description adds meaning: scoped packages accepted for 'package', and default behavior for 'version' (defaults to latest).

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: a composite check for npm packages using deps.dev and bundlephobia. It specifies the verb 'check', the resource 'npm package', and distinguishes from sibling tools by limiting to npm ecosystem v1.

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 examples are given ('is X safe / popular / small' or 'what does adding lodash cost me'). It also specifies when not to use (non-npm packages) and directs to alternative ('fall under deps.dev:version directly').

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 to annotations by stating return fields (title, description, date, NASA ID, media type, thumbnail URL) and the fact it requires no API key ('Keyless'). Annotations already declare read-only, idempotent, non-destructive behavior. 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?

Two sentences, front-loaded with purpose. Second sentence combines usage hint and return info. Efficient but could be slightly more structured to separate return details.

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

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

For a simple search tool with 3 parameters and no output schema, description covers key aspects: scope, usage examples, return fields, and keyless access. Lacks details on pagination or error conditions, but is sufficient for straightforward use.

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

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

Schema coverage is 100% with clear parameter descriptions. Description adds 'Keyless' but that is about authentication, not parameter meaning. Baseline 3 is appropriate as description does not significantly add to parameter semantics.

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

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

Description clearly states it searches the NASA Image and Video Library for images/videos of any subject, with specific examples like planets and missions. The verb 'Search' and resource 'NASA Image and Video Library' are specific. It distinguishes itself from sibling tools by being a specialized image search tool.

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?

Includes 'PREFER for' with concrete query examples, guiding appropriate use. Does not explicitly state when not to use or mention alternatives, but the context is clear given it's a niche tool among diverse 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds significant details: embedding model (BGE-base-en), chunking strategy (500-char overlapping windows), char cap (200K chars with truncation flag), and return format (passages with character offsets and similarity scores). 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?

Single paragraph with front-loaded purpose, no wasted words. Each sentence adds distinct value: purpose, usage guidance, pairing suggestion, technical details. Perfectly balanced for an AI agent to quickly parse.

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

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

With only three parameters and no output schema, the description covers all necessary aspects: what the tool does, when to use it, how it works internally (embeddings, windowing, truncation), and what output to expect (passages with offsets/scores). No gaps remain for an AI agent to infer.

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

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

Schema coverage is 100%, providing basic descriptions for all three parameters. The description enhances this with example queries for 'query' (e.g., 'supply-chain risk'), clarifies the max length for 'text' (200K chars), and specifies the default and range for 'limit' (1-20, default 5). While schema already covers structure, the description adds contextual value.

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

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

Description uses specific verb+resource: 'semantic search INSIDE a fetched record'. Provides concrete examples like 'SEC 10-K body, an article, a long tool result' and distinguishes from sibling tools by stating it saves context and returns passages with offsets.

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

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

Explicitly states when to use: 'when the record is too big to cram into the prompt'. Also gives a clear alternative/partner tool: 'Pairs with ask_pipeworx_grounded: fetch with the gateway, ground over the relevant passages instead of the whole document.' This leaves no ambiguity about usage context.

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

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

Annotations already indicate idempotentHint=true and readOnlyHint=false. The description adds essential behavioral details: authentication requirement, return value (subscription id), webhook auto-disable after 10 failures, and SMS rate limit (10/day). This enriches understanding beyond the annotations.

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

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

The description is thorough and well-structured, starting with the core purpose, then prerequisites, then detailed type and delivery information. It is slightly long but every sentence adds value. No redundancy.

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

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

Given the tool's complexity (multiple subscription types and delivery channels) and no output schema, the description covers all critical aspects: creation behavior, authentication, type-specific parameters, delivery options, failure handling, and rate limits. It is fully sufficient for an agent to use the tool correctly.

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

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

Schema coverage is 100%, but the description adds substantial value: it provides concrete examples for each type and its params (e.g., sec_8k with items codes, polymarket_edge with topic), and explains delivery channels with constraints (phone verification, webhook signing). This goes far beyond the schema descriptions.

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

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

The description clearly states the tool's purpose: 'Create a proactive monitoring subscription to a live-data event stream. Returns the new subscription id.' It specifies the resource (subscription to event streams) and the action (create), and distinguishes from siblings like list_subscriptions, unsubscribe, and recent_alerts by focusing on creation.

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 includes important usage context: requires a Pipeworx OAuth account (anonymous and BYO cannot persist), and details delivery channel options. It does not explicitly contrast with sibling tools but the context is sufficient to infer when to use subscribe (for creation) versus list_subscriptions or 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?

Annotations indicate readOnly, openWorld, idempotent, non-destructive. Description adds that it returns category-bucketed example questions with exact tool+argument shape, and mentions calling with no arguments or a topic. 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?

Description is a single dense paragraph with all key information front-loaded. It includes examples and details about output. Could be slightly more structured, but not overly verbose.

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

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

For a simple tool with one optional parameter and no output schema, the description fully explains purpose, usage, parameters, and return value (category-bucketed example questions with tool+argument shape).

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 has one optional parameter 'topic' with description. Description adds context: omitting topic gives full spread, passing topic focuses. Schema coverage is 100%, but description enriches meaning beyond schema.

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

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

The description states it is an onboarding entry point that returns category-bucketed example questions, distinguishing it from sibling tools like ask_pipeworx which handle actual queries. It clarifies the verb 'suggest questions' and resource 'Pipeworx capabilities.'

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 this FIRST when you do not yet know what Pipeworx can do for you, or to learn how to call the meta-tools.' Provides clear context for when to use, though does not explicitly list when not to use or alternatives beyond implication.

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

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

Description explains that the row is deactivated (not deleted) and historical events remain available via recent_alerts. This adds valuable context beyond annotations, which indicate non-destructive and idempotent behavior. No contradictions.

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

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

Two sentences with no wasted words. Front-loaded action and clear purpose.

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

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

For a simple tool with one parameter and no output schema, the description covers purpose, ownership constraint, and side effects completely. Annotations support the description.

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

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

Single parameter 'id' is described as 'Subscription id (uuid) returned by subscribe,' which adds context beyond the schema's basic description. Schema coverage is 100%.

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 'Cancel a subscription by id,' which is a specific verb+resource. It clearly distinguishes 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?

Description explicitly states ownership enforcement ('you can only cancel your own subscriptions'), which is a key constraint. It does not explicitly mention when not to use, but the purpose is clear.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and no destructiveness. The description adds rich behavioral detail: exact percent-delta math for financial claims, fallback to a grounded pipeline with verbatim evidence, and that the tool replaces 4-6 sequential calls. It also explains the return structure (verdict, actual value, citation). This completely aligns with and extends the annotations without contradiction.

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

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

The description is longer than average but packs dense, useful information: natural-language trigger phrases, pipeline differentiation, verdict types, and efficiency claims. It is front-loaded with examples and structured logically. However, it could be slightly trimmed without losing meaning, earning a 4 rather than 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 lacking an output schema, the description fully specifies the return values (verdict categories, actual value with citation, reasoning). The description covers both financial and non-financial paths, the two parameters, and the behavioral implications. Combined with the annotations, the tool is completely understandable without needing additional context.

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

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

Schema description coverage is 100%, so the parameters are already well-documented in the input schema. The description adds no new parameter semantics beyond restating the tolerance_pct's override behavior, which is already in the schema. Thus, the description provides marginal added value over the schema, meeting the baseline for high coverage.

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

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

The description clearly states the tool's purpose: verify natural-language factual claims against authoritative sources. It provides specific query examples ('Is it true that...', 'fact check') and distinguishes between company-financial claims (SEC EDGAR + XBRL path) and all other claims (grounded pipeline). It also lists the possible verdicts, making the tool's function unambiguous and distinct from siblings like ask_pipeworx_grounded or deep_research.

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

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

The description explicitly instructs to use when checking factual correctness of a user statement. It explains the routing logic for financial vs. other claims. While it does not explicitly list when not to use or compare to sibling tools, the context implies it is for factual verification, not exploratory research. This provides clear guidance but could be stronger with explicit exclusions.

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