US State DMV

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

Annotations already declare read-only and idempotent. Description adds critical details: default free model, optional Anthropic (BYO key with direct costs), and per-model return shape. 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?

Highly concise: first sentence states core action and output, followed by model options, return structure, and use cases. No wasted words; each sentence earns its place.

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

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

Despite no output schema, description describes return shape (per-model fields + combined view). Covers cost, optionality, and default behavior. Complete for the tool's complexity (4 parameters, 1 required).

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

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

Schema coverage is 100%. Description adds value beyond schema: explains default model behavior, cost implications for _apiKey, and disambiguation purpose for context. Clearly helps agent use parameters correctly.

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

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

Clearly states the tool probes LLMs to score AI visibility (0-100) for a given entity. Distinguishes from siblings like 'scan_competitor_ai_presence' by focusing on multi-model scoring and specific use cases (marketing audits, pre-launch checks).

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

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

Provides clear use cases and explains default model vs. optional Anthropic integration with API key. Lacks explicit when-not-to-use or comparison to similar tools, but context is sufficient for selection.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds that it returns structured answers with citation URIs and is a 'one fast call' that works on every tier. No contradictions. Could mention potential latency for complex multi-hop queries, but overall sufficient.

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

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

The description is efficiently structured: opens with the core directive ('PREFER OVER WEB SEARCH'), then lists domains, explains routing, gives usage guidelines, examples, and escalation paths. Every sentence earns its place with no wasted words. Front-loaded with the most critical information.

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

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

Given the tool's complexity (5,564 tools across 1462 sources) and no output schema, the description is remarkably complete. It covers when to use, what it returns (structured answer with citations), provides examples, and delineates sibling tools. The absence of output schema is mitigated by describing the output format.

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

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

Schema description coverage is 100% (all parameters are aliases for question). The description adds value by providing numerous concrete example questions (e.g., 'current US unemployment rate', 'Apple's latest 10-K') and context on what kinds of factual queries are appropriate, which helps the agent formulate inputs better than 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 the tool's purpose: answering factual questions using authoritative structured data from many sources, with routing to 5,564 tools. It explicitly says to prefer it over web search and distinguishes from siblings like ask_pipeworx_grounded and deep_research, providing a specific verb-resource-action pairing.

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: 'START HERE for most questions', 'PREFER OVER WEB SEARCH', and lists example query types. It also states when to step up to alternatives: for hallucination-resistant answers use ask_pipeworx_grounded; for broad/multi-part questions use deep_research. This gives clear decision criteria.

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 establish safe read-only, idempotent, non-destructive behavior. The description adds significant context beyond annotations: the tool is a full working router under experimental edge, with candidate improvements tested via live comparisons, and currently matches the stable version. It also mentions that previous candidates have been retired based on outcome evidence, which is insightful for trust and predictability.

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 efficiently concise: every sentence adds unique value – identity, current state, usage instruction, fallback behavior. It is front-loaded with the core purpose and structured logically. No redundant or filler content exists.

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 thousands of sub-tools) and the lack of an output schema, the description provides complete context: what it does, its beta nature, current identical state to stable, how to use it, and the rationale for its existence (testing improvements). The agent has all necessary information to decide when and how to 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?

The input schema covers 100% of parameters with clear descriptions, including multiple aliases. The description does not elaborate on parameter meaning beyond what the schema provides – its focus is on tool purpose and usage. With high schema coverage, a baseline score of 3 is appropriate as no additional parameter insights are needed.

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

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

The description clearly identifies the tool as a beta version of 'ask_pipeworx', an identical universal router with candidate routing improvements. It distinguishes itself from siblings like 'ask_pipeworx' by explicitly noting its experimental nature and current identical behavior. The verb 'ask' and resource 'Pipeworx' are unambiguous.

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

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

The description provides explicit guidance: 'Use it exactly like ask_pipeworx when you want the newest routing'. It explains the context (beta, candidate testing) and implicitly contrasts with the stable 'ask_pipeworx'. It also covers current state (no candidate active) and the fallback behavior, fulfilling the 'when/when-not/alternatives' criteria.

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

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

The description discloses key behavioral traits beyond the annotations, including that it returns a specific structured object with 'answer, evidence (verbatim quote), confidence, source, fetched_at, refusal_reason:null' on success, and explicit refusal reasons on failure. It also explains the underlying process: 'picks the right tool from 5,564 across 1462 sources, fills arguments, fetches the data — then EXTRACTS the answer using ONLY what the tool result contains.' This adds context about internal routing and refusal guarantees that annotations alone do not cover.

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 and front-loaded with the key differentiator ('Hallucination-resistant answer mode'). It efficiently conveys purpose, usage, behavior, and cost trade-offs in 6 sentences. Minor deduction for the long list of refusal reasons in the success object, which could be slightly tightened without losing critical info.

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 high-stakes nature, the description comprehensively covers its purpose, behavior (routing, extraction, refusal), usage guidelines, input semantics, and output structure. There is no output schema, so the description appropriately details the exact shape of the response, including refusal reasons. The sibling context confirms differentiation from 'ask_pipeworx' and 'ask_pipeworx_beta' is clear.

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%, and the description provides a thorough explanation of the primary parameter 'question' and its aliases (q, text, input, query, prompt). The description sets clear expectations for input: 'Your question in natural language.' This adds value beyond the schema by detailing the semantics and acceptable aliases.

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: 'Hallucination-resistant answer mode for high-stakes reads.' It specifies the verb ('ask'), resource ('Pipeworx'), and distinct behavior (extracting answers only from tool results). This distinguishes it from siblings like 'ask_pipeworx' and 'ask_pipeworx_beta' by emphasizing groundedness and refusal patterns.

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

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

The description provides explicit guidance on when to use this tool: 'Use whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts' with concrete domains like 'financial verdicts, legal claims, medical lookups, public statements.' It also states when not to use it by noting the cost trade-off: 'Costs one extra LLM call vs ask_pipeworx — prefer ask_pipeworx for casual 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 state readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false. Description adds extensive behavioral context: resolution mechanism, fan-out examples, response shapes, resolver contract, parent event extractor, news fallback, safety for low-confidence matches, closed market handling, wide-spread tradeability, and cancellation rules. 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?

Long but well-structured with labeled sections (RESOLVER CONTRACT, PARENT_EVENT EXTRACTOR, etc.). Every sentence adds value; no redundancy. Could be slightly more concise but density is justified by tool complexity.

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

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

Given no output schema and high complexity, description is fully adequate. Covers all behavioral aspects, edge cases, and what the agent must inspect. No gaps identified.

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 all three parameters documented. Description adds significant value: explains market accepts slug/URL/question text, details include_raw size implications, and briefly describes depth options.

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

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

Explicitly states it researches Polymarket bets by pulling Pipeworx data. Specifies input types (slug, URL, question text) and output summary. Distinguishes from sibling tools by being comprehensive research, while siblings like 'polymarket_edges' are narrower.

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

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

Provides clear use cases: 'should I bet on X', 'what does the data say about Y', 'is there edge in Z'. Does not explicitly state when not to use or compare to alternatives, but the implied usage is clear.

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

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

The description discloses behavior far beyond what annotations provide: exact data sources (SEC EDGAR/XBRL for companies, FAERS for drugs), specific financial metrics, handling of off-calendar fiscal years, sorting by primary metric, and citation URIs. This gives agents full transparency.

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 it easy for agents to recognize matching intents. It is well-structured and each sentence adds value, though it is somewhat lengthy. Still, it earns high marks for clarity and efficiency.

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?

All necessary information for correct invocation is present: purpose, usage guidelines, parameter details, behavioral expectations, and return format. Despite lacking an output schema, the description covers results comprehensively. The tool is complex (two types, multiple entities) but the description is complete.

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

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

Schema coverage is 100% with descriptions for both parameters, but the description adds valuable context: explains what each type does (company vs drug data), gives examples for values (tickers vs drug names), and reinforces constraints (min 2, max 5). 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 tool provides side-by-side comparison of 2-5 companies or drugs in a single call. It lists example queries ('compare X and Y', 'X vs Y', 'which is bigger') and distinguishes itself from sequential lookups, making its purpose unmistakable.

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

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

The description explicitly says 'ALWAYS PREFER over sequential single-pack lookups when comparing entities', providing clear guidance. It also gives example queries that indicate appropriate contexts. It does not explicitly mention when not to use it, but the implication 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?

Beyond annotations (readOnlyHint, openWorldHint, idempotentHint), description adds extensive behavioral detail: parallel decomposition, findings packet format with verbatim evidence, confidence, source, fetched_at, stable citation, gaps array, contradictions on standard/thorough, large records semantically excerpted. Also specifies expected latency (15-60s, thorough up to 90s). 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 fairly long but each sentence adds unique value, front-loading critical prerequisites (account required, alternative tool). Could benefit from slight trimming but earns its length given the tool's complexity.

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

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

No output schema, but the description fully explains return format (findings packet with gaps, contradictions, hop fields, citation_uri fetchability). Covers prerequisites, latency, depth behavior, and what scenarios yield empty results. Complete for a complex multi-source research 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?

Both parameters (question, depth) are fully described in the schema (100% coverage). The description adds valuable context beyond schema: depth values explained with practical details (quick=3 single hop, standard=default with gap recovery, thorough=paid with iterative leads chase) and guidance on multi-part questions for the question parameter.

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

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

The description clearly states the tool does grounded multi-source research across Pipeworx's 1462 structured data sources in one call. It distinguishes from sibling ask_pipeworx (single lookup, breaking news) with specific examples like 'compare X and Y's regulatory + financial exposure'.

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

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

Explicit when-to-use: best for broad/multi-part questions over structured data. Explicit when-not: for single lookups use ask_pipeworx, for breaking news prefer ask_pipeworx. Also mentions account requirements and free vs paid tiers.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. Description adds that it returns 'top-N most relevant tools with names, descriptions, and full input schemas (with curated examples) — each result is ready to call directly'. This provides useful behavioral context beyond annotations.

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

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

Three sentences with zero wasted words. Each sentence adds distinct value: purpose, scope, and usage instruction. Front-loaded with the core action.

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

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

No output schema provided, but the description fully explains what is returned (tool names, descriptions, schemas with examples) and that results are directly callable. Complete for a discovery tool with clear annotations.

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

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

Schema coverage is 100% with descriptions for each parameter. Description adds value by explaining that query accepts multiple aliases (task, q, description, search) and provides natural language examples. Goes beyond the schema's basic 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?

Explicitly states the verb 'Find tools' and the resource 'by describing the data or task'. Clearly differentiates from sibling tools by listing specific domains (SEC filings, FDA drugs, etc.).

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: 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' Also details the use case and domains covered.

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, and destructiveHint=false. The description adds valuable behavioral context: it fans out across multiple sources (SEC EDGAR, XBRL, USPTO, news, GLEIF), mentions patent source sunset (May 2025) and soft-fail behavior, and explains news fallback (GDELT→GNews). No contradictions with annotations.

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

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

The description is well-structured: it starts with example queries, then gives a high-level purpose, then details the fan-out and return fields. It is slightly lengthy but each sentence adds value. Could be slightly more concise, but overall effective.

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

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

Given the complexity of the tool (cross-source, multiple fields), the description is comprehensive. It lists all returned fields (cik, company_name, recent_filings with URIs, fundamentals, patents, news, LEI) and notes limitations and fallback behavior. No output schema exists, but the description sufficiently covers the return structure.

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

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

Schema description coverage is 100% – both parameters have descriptions. The description adds further meaning: for 'type,' it clarifies only 'company' is supported; for 'value,' it specifies ticker or zero-padded CIK, and reaffirms that names are not supported. 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 tool's purpose: 'full cross-source profile of a US public company in ONE parallel call.' It provides specific examples like 'Tell me about X' and 'research Acme,' and distinguishes it from chaining single-pack lookups by saying 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news 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: 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view.' Also specifies when not to use: 'names not supported (use resolve_entity first if you only have a name).' Provides clear alternatives.

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

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

Description aligns with annotations (destructiveHint=true) and adds context about clearing sensitive data. Annotations already cover destructive nature, but description provides nuance on why deletion 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 superfluous information. Front-loaded with purpose and immediately followed by usage guidance.

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 delete tool with one parameter, good annotations, and no output schema, the description fully covers purpose, when to use, and pairing with siblings.

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

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

Schema covers 100% of parameters with a clear description. The tool description adds no extra semantic value beyond what the schema provides, meeting baseline expectation for high coverage.

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

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

Description clearly states 'Delete a previously stored memory by key' with a specific verb and resource, and it distinguishes itself from siblings by name-dropping 'remember' and 'recall' as paired 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 when to use the tool: when context is stale, task is done, or to clear sensitive data. Also implies when not to use by pairing with store/retrieve tools.

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

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

Annotations already declare the tool as read-only, non-destructive, idempotent, and open-world. The description adds behavioral specifics: fetches the page, extracts title/description/key links, and emits standard markdown. This goes beyond annotations by explaining the internal process, though it omits potential limitations like page size or rate limits.

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

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

The description is a single, well-structured paragraph. The core action is stated in the first sentence, followed by a brief explanation of what the tool does internally, and a clear use-cases list. Every sentence is informative and adds value, with 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?

The tool has low complexity (2 parameters, no output schema, annotations present). The description explains the output format (single text blob, standard markdown) sufficiently for an agent to understand what to expect. It could mention that the output is plain text, but the current description is adequate.

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

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

Schema description coverage is 100% for both parameters (url and max_links), so the schema already provides full parameter semantics. The description does not add further detail about the parameters, only mentioning them in passing. Baseline score of 3 is appropriate.

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

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

The description clearly states it generates a production-ready llms.txt file for any URL, specifying the exact action (fetches, extracts, emits) and the output format. It distinguishes itself from sibling tools by being specifically for llms.txt generation, not general visibility scanning or 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 includes a 'Useful for' section with three concrete scenarios (client indexing, personal project, competitor audit), giving clear context for when to use it. It does not explicitly mention when not to use or list alternative sibling tools, but the use cases are sufficient for typical selection.

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 and non-destructive nature. Description adds context on returned fields (id, type, params, etc.) and default behavior (active subscriptions), complementing 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?

Two short sentences; first states purpose and output, second gives usage advice. No extraneous text, front-loaded with essential information.

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

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

Given the tool's simplicity (one optional parameter, no output schema), the description adequately covers purpose, output fields, and usage context. No gaps detected.

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. Description does not add extra meaning beyond the schema, meeting baseline expectation.

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' with specific fields, distinguishing it from sibling tools like 'subscribe' and 'unsubscribe'.

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

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

Explicitly says 'Use this to review what you're monitoring before adding more or to find an id to cancel', providing clear guidance on when to use and excluding other contexts.

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

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

The description discloses significant behavioral traits beyond the annotations (which are all false): rate-limiting to 5/day, free usage, no quota impact, return of a claim_token for later status checks, and the team's daily digest review. The annotations themselves are not contradicted.

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

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

The description is long but front-loaded with purpose. Every sentence earns its place, covering exclusions, token flow, rate limits, and roadmap impact. Slightly verbose and could benefit from bullet structure, but remains organized and scannable.

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

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

For a tool with no output schema and multiple nuanced behaviors (claim_token, rate limits, cross-server exclusions), the description covers all essential usage context. It explains what the return token is for, how to use it, and the operational constraints, making the tool 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 coverage is 100%, so the baseline would be 3, but the description adds substantial meaning: clarifies enum values for 'type', explains that 'context' is optional structured context, describes 'message' length and specificity, and details the 'claim_token' dual-use (passing back to read status). This goes well 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 starts with a specific verb phrase ('Tell the Pipeworx team something is broken, missing, or needs to exist') and clearly identifies the resource (Pipeworx feedback). It distinguishes itself from sibling tools by focusing on feedback relative to research/discovery/subscription 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 when to use (bug, feature, data_gap, praise) and provides a clear exclusion: 'ONLY for tools served by this Pipeworx connection' with guidance to file with other servers. Also offers fallback criteria ('Not sure? Pipeworx tool names are the ones this connection lists').

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, signaling a safe read operation. The description adds valuable context: it is 'self-aggregating signal derived from CF analytics-engine, no PII', and specifies caching duration (5min-1h). This goes beyond annotations to inform the agent about data freshness and privacy.

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 focused sentences plus a bulleted list of use cases. Every sentence adds distinct value: what it returns, why it's useful, and how it works. It is front-loaded with the core purpose and well-structured without redundancy.

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

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

Given only one optional parameter with 100% schema coverage, the description is complete. It explains the return structure (top tools, packs, volume), provides usage guidance, and appears sufficient for correct invocation. The output is implied, so lack of output schema is not a gap.

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

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

The schema covers the single parameter 'window' with an enum and description. The description adds semantic context: 'Shorter windows surface what's hot right now; longer windows show steady-state demand.' This helps the agent choose the appropriate value based on intent, enhancing the schema's technical specification.

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

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

The description explicitly states the tool returns 'top tools, top packs, and total call volume' based on recent agent activity. It uses a specific verb ('returns') and clearly defines the resource. It uniquely describes the tool's purpose among siblings, distinguishing it as a trend/analytics tool rather than a query or action 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?

The description lists three concrete use cases (discovering hot data sources, confirming canonical choices, seeing alignment with agent needs) and explains window semantics. It does not explicitly state when not to use it, but the use cases provide strong guidance. Caching behavior is also mentioned, helping manage expectations.

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

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

Annotations declare readOnly, openWorld, idempotent, non-destructive. Description adds scanning scope, filtering logic (partition filter, semantic anchor), fill check details, and when not to trade. No contradiction with annotations.

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

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

Description is well-structured with sections (modes, semantic anchor, partition filter, response, fill check) but quite long. Every sentence adds value; could be slightly trimmed but no wasted text.

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

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

Despite no output schema, description details the return structure (opportunities[], partition_check, fill_check) and important conditions. Sufficient for an agent to understand outcomes.

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

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

Schema already describes both parameters with 100% coverage. Description adds useful context like mention of event slug format and topic as seed question, enhancing usability but not essential.

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

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

Description starts with 'Find arbitrage opportunities on Polymarket via monotonicity violations + partition-sum checks' – a specific verb+resource+method. Differentiates from siblings like polymarket_edges and polymarket_fill_risk.

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

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

Explicitly states when to use each mode: no args for trending_scan, event for specific market, topic for cross-event. Also provides recommendation ('event (recommended for a specific market)') and explains what each does.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, but the description adds valuable behavioral context: caching ('Cached 1h at the KV level keyed on all knobs'), response structure with diagnostics, and detailed edge calculation logic. No contradictions with annotations.

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

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

The description is well-structured with clear sections (model families, response segments, knobs, caching) and front-loads the core purpose. However, it is verbose with detailed coefficients and technical specifics that could be streamlined. It earns its length but could be 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?

Given the complexity (9 parameters, no output schema), the description is exceptionally complete. It explains the response structure, edge computation, filtering, caching, and why segments might be empty. It leaves very little ambiguity for an agent to understand and invoke 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%, so baseline is 3, but the description adds substantial meaning beyond the schema. For example, for 'slippage_pp' it explains Polymarket's zero fees and typical bid/ask costs, and for 'min_partition_leg_kelly' it clarifies why min_kelly does not apply to partition arbs. Every parameter has enriched guidance that helps the agent use them correctly.

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

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

The description clearly states the tool's purpose: 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price.' It is built for 'what should I bet on today' and distinguishes from siblings like polymarket_arbitrage by focusing on Pipeworx data disagreement. The specific verb 'scan' and resource 'Polymarket markets' with a defined scope make purpose very 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?

The description provides a clear usage scenario ('what should I bet on today') and explains that agents discover opportunities without paging hundreds of markets. It also details tradeable-edge knobs and filtering. However, it does not explicitly state when not to use this tool versus siblings like polymarket_edge_tracker or polymarket_fill_risk, leaving some ambiguity.

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

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

Annotations are readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds significant context: the exact output structure (tracked[], expired[], snapshot_dates[]), the meaning of sign in edge_pp_net, and that decay is from daily closes, not intraday. No contradictions.

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

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

The description is front-loaded with purpose, then details output in a structured format. It is fairly concise given the complexity, though some sentences could be tightened. It earns its length.

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

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

With no output schema, the description fully explains the return fields and edge cases (gaps, sign meaning, limits). It covers all necessary aspects for an agent to use the tool correctly. Very complete.

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

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

Schema coverage is 100% with both parameters described. The description clarifies the clamping behavior for 'days' (2-30) and the default for 'window', but this adds little beyond the schema. Baseline is 3, and no additional parameter semantics 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 tool's purpose: providing edge persistence and decay telemetry from daily snapshots. It explicitly answers the question 'how long has this edge existed and is it shrinking?'. Among siblings like 'polymarket_edges' and 'polymarket_arbitrage', this tool is distinguished by its focus on time-series 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?

The description explains when to use the tool (to distinguish fresh edges from aged ones) and includes context that an old wide edge is different. It also mentions limits like the 60-day snapshot TTL. However, it does not explicitly compare to siblings or state when not to use it.

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

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

Annotations indicate readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, which align perfectly with the description's characterization as a risk check. The description adds behavioral details such as walking the ladder, returning a verdict (clean|degraded|cannot_fill), and explaining forced directional risk, exceeding what annotations provide.

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

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

The description is comprehensive but somewhat lengthy; it uses line breaks effectively to separate modes and returns. Every sentence adds value, but it could be slightly more concise by breaking into bullet points. Nonetheless, it is well-structured and front-loaded with the core 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?

With no output schema, the description compensates by enumerating all return fields (top_of_book, vwap_fill_price, slippage_pp, shares_filled, max_fillable_usd, verdict, per-leg detail, thin_legs, max_clean_notional_usd, forced_directional_risk). It covers both modes and the critical risk of unbounded directional exposure. The definition is fully complete for an AI agent to use correctly.

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

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

Schema description coverage is 100%, yet the description adds significant meaning: it clarifies that market and event are mutually required modes, explains side default for basket (auto from partition sum), and specifies how size_usd is interpreted for basket (settlement notional S, shares per leg paying $1). 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 explicitly states it performs a 'Realizable-vs-theoretical edge check against live CLOB order-book depth,' and distinguishes between single-market and basket modes. It clearly differentiates from sibling tools like polymarket_arbitrage and polymarket_edges by positioning itself as a pre-trade risk check.

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

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

The description gives explicit usage guidance: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500.' It also warns about partial basket fills converting an arb into an unhedged directional position, providing clear when-to-use and when-not-to-use 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?

Goes far beyond annotations by detailing safety fields (compatibility_warning, temporal_alignment, skipped_cross counters), explaining when spreads are meaningful vs not, and describing the matching algorithm. Annotations already mark read-only, idempotent, and non-destructive; description adds critical operational context.

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

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

Well-structured with clear sections (MODES, RESPONSE, SAFETY FIELDS). Front-loaded with key purpose. Slightly verbose in safety field explanation, but necessary for clarity. Could be tightened without losing meaning.

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?

Comprehensive coverage for a complex tool with no output schema. Describes response structure (leg-by-leg prices, top_spreads_pp), safety fields, and edge cases. All necessary information for an agent to understand behavior and interpret results is included.

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?

Parameters are well-described in the schema (100% coverage). The description adds interaction semantics (topic overrides, explicit parameters override topic mapping) and provides examples. Adds value beyond schema without redundancy.

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 identifies the tool as computing cross-venue spread between Kalshi and Polymarket for the same question. Mentions specific resources (venues, events, modes) and distinguishes from sibling tools like polymarket_arbitrage by emphasizing multi-venue comparison.

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

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

Explicitly states two usage modes (topic shortcuts and explicit tickers) with examples. Includes when to use each mode and warns about compatibility issues (compatibility_warning). Could be improved by explicitly mentioning when not to use, but provides strong contextual cues.

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

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

Annotations already declare read-only, idempotent, non-destructive. The description adds behavioral details: scoping (anonymous IP, BYO key hash, account ID) and listing behavior when key omitted. 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, front-loaded with action, then usage, then scope. No wasted words; every sentence earns its place.

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

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

Given one optional parameter, thorough annotations, and no output schema, the description covers purpose, usage, behavior, parameter, and scope completely. Nothing is missing.

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% (key parameter fully described). Description adds functional context (omit to list all keys, pairing with remember/forget) and scoping details, which adds value 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 uses a specific verb 'retrieve' and resource 'value previously saved via remember', and clearly distinguishes from siblings 'remember' and 'forget'.

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

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

The description explicitly states when to use (look up previously stored context) and names alternatives: 'Pair with remember to save, forget to delete.' It also explains scoping and the option to list all keys.

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 states that setting mark_read:true flags events as read, modifying server state. This contradicts the annotation readOnlyHint=true, which indicates no side effects. Per scoring guidelines, contradiction results in score 1.

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

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

The description is three sentences with no wasted words. It front-loads the primary action and efficiently covers return fields, filtering, side effect, and alternative endpoint.

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

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

Given the tool is a simple read operation with no output schema, the description covers all necessary aspects: what it returns, parameters, usage patterns, and an alternative access method. It is complete for an agent to use correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by providing an example for type ('sec_8k'), clarifying the ISO timestamp for since, and explaining that mark_read:true flags events read for subsequent calls.

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 pulls fired events from subscription feed and returns recent alerts with specific fields (source, citation_uri, raw payload). It distinguishes itself from sibling tools by being specific to alerts and providing an alternative HTTP endpoint.

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 filters (type, since) and the mark_read flag to control read state. It also mentions polling is fine and gives an alternative endpoint for scripts/dashboards. However, it does not explicitly state when not to use this tool versus alternatives.

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

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

Annotations already declare readOnlyHint, idempotentHint, etc. The description adds valuable context: fan-out to multiple sources, fallback logic, soft-fail for patents API, and return format (changes[] grouped by source, total_changes, pipeworx:// URIs).

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, front-loading purpose with example queries, then detailing sources, parameters, return format, and alternative. Every sentence adds value, though it could be slightly more concise by separating examples from technical explanation.

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 (multi-source, fallback, soft-fail, no output schema), the description is very complete. It covers all sources, accepted date formats, fallback behavior, return structure, limitations, and a sibling alternative.

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 extra meaning: examples for `since` (ISO date or relative, recommended '30d'), explanation of `value` (ticker or CIK), and that `type` only supports 'company'.

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

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

The description clearly states the tool's purpose: providing a change feed for a company over a time window, with example queries like 'What's new with X'. It distinguishes from the sibling tool 'entity_profile' by explicitly saying when to use that instead.

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

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

The description gives explicit when-to-use guidance with natural language examples and specifies when to use the alternative 'entity_profile'. It also explains fallback behavior (GDELT preferred, GNews when rate-limited) and soft-failure for patents.

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

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

Adds significant behavioral context beyond annotations: key-value paired by identifier, authenticated persistence vs 24-hour retention for anonymous, and pairing with recall/forget. 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?

Four sentences, front-loaded with purpose, each sentence adds value. Could be slightly more concise but well-organized.

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

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

Completes the picture: explains storage mechanism, scope, persistence, and usage with sibling tools. No output schema, but description covers necessary 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 covers both parameters fully (100% coverage). Description does not add extra parameter-specific details beyond the schema, staying at baseline.

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

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

The description uses a specific verb 'Save' and resource 'data the agent will need to reuse later', and distinguishes itself from siblings by naming recall and forget as companion 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?

Clearly states when to use: 'when you discover something worth carrying forward', with concrete examples. Mentions alternatives recall and forget, but lacks explicit when-not to use.

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

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

Beyond the readOnly/idempotent annotations, the description reveals that unresolved identifiers are explicitly listed under `unresolved`, that enrichment degrades gracefully without GLEIF/OpenFIGI (EDGAR identifiers still return), and that each identifier is labeled with its source. It also explains the ISIN-to-LEI mapping for non-US issuers.

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 each sentence adds value: query examples, supported types, behavioral details, and edge cases. It is appropriately detailed for a tool with two entity types and multiple identifier sources, though the single-paragraph format could be more scannable.

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 input formats for both types, output identifiers, unresolved behavior, graceful degradation, and usage context within the tool ecosystem. Since there is no output schema, the description adequately explains what is returned and how identifiers are labeled.

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

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

The schema already documents both parameters, and the description adds extra semantics such as accepting ISIN for company and clarifying that an ISIN resolves to the legal entity issuer. It also generalizes the `value` parameter beyond the schema's examples, covering tickers, CIKs, name, and drug names.

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

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

The description uses the specific verb 'resolve' and clearly states the tool maps user-spoken names to canonical/official identifiers (CIK, LEI, FIGI, RxCUI). It differentiates from siblings with 'Use FIRST whenever you have a name but need an ID' and provides illustrative example queries.

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

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

Explicitly instructs 'Use FIRST whenever you have a name but need an ID' and notes it replaces 2-3 manual lookups. However, it does not name alternative tools or provide exclusion criteria (e.g., when NOT to use), so it's clear but not fully exhaustive.

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

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

Annotations already convey readOnly, idempotent, and non-destructive nature. The description adds valuable detail about internal calls to ai_visibility_check and the output structure (score, confidence, signal density), which is 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 two well-structured sentences with no wasted words; it is front-loaded with the primary purpose and immediately useful.

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 moderate complexity (4 params, no output schema), the description covers the return format and usage context adequately. It lacks details on error handling or ranking algorithm but is sufficient for agent decision-making.

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

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

Schema coverage is 100% with clear descriptions for each parameter. The description adds extra semantics by specifying that the first entity is treated as the 'subject' and the rest as competitors, which is not in 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 compares AI visibility across multiple entities, explicitly distinguishes from the single-entity sibling 'ai_visibility_check', and uses specific verbs like 'scan' and 'compare'.

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 provides clear usage context for competitive AI-marketing audits and implies the alternative 'ai_visibility_check' for single entities, but does not explicitly state when not to use it.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, etc. Description adds valuable context: partial failures, bundlephobia first measurement delay (5-30s), and that sources_failed will list failures while other data still returns. No contradiction.

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

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

The description is moderately long but each sentence adds value. It front-loads the core purpose and then provides details on behavior, limitations, and output. Could be slightly more concise, but structure is logical.

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

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

Given no output schema, the description thoroughly explains the return format: summary block with 10 fields, per-advisory detail, links, alternative versions, and sources_failed. Covers all aspects of the tool's complex behavior.

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

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

Schema coverage is 100% with clear descriptions for both parameters. The description adds little beyond schema (mentions scoped packages and default version), but it provides overall context that helps an agent understand the meaning of parameters in the tool's behavior.

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

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

The description clearly states it performs a composite check for adding npm packages, covering license, advisories, version history, and bundle size. It distinguishes itself from sibling tools by focusing on npm package evaluation, and uses specific verb 'scan' and resource 'dependency'.

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: 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me"'. Also notes NPM ecosystem only in v1, and mentions fallback for other ecosystems via deps.dev:version.

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

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

Annotations already provide readOnlyHint, openWorldHint, etc. The description adds valuable behavioral details: BGE-base-en embeddings, cosine similarity over 500-char overlapping windows, 200K char cap with truncation flagging. These go beyond annotations, but could mention rate limits or idempotency explicitly.

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

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

Four sentences, each with a clear purpose. Front-loaded with the core action, then usage, then pairing, then technical details. No unnecessary words. Perfectly concise.

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

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

Given no output schema, description explains return format: 'top-N passages with character offsets and similarity scores'. Also mentions offset for verification. Covers all necessary aspects for a search tool.

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

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

Schema coverage is 100%, so baseline is 3. Description adds meaning: 'text' is a 'fetched record', 'query' is 'natural-language query' with examples, 'limit' default is 5. It also explains the character limit in text. This exceeds baseline.

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

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

The description clearly states 'Semantic search INSIDE a fetched record' and provides concrete examples (SEC 10-K, article, long tool result). It distinguishes itself from siblings like ask_pipeworx_grounded by explaining the pairing pattern. The verb 'search within' matches the name and title.

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 says 'Use when the record is too big to cram into the prompt' and explicitly pairs with 'ask_pipeworx_grounded'. While it doesn't list explicit when-not-to-use scenarios, the context is clear. It could improve by mentioning alternatives for smaller records, but the guidance is strong.

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 non-readOnly, idempotent, non-destructive. The description adds substantial behavioral context: subscription creation returns an id, webhook signing secret is returned once, delivery channels have specific behaviors (always-on feed, optional email/SMS/webhook with constraints). No contradictions.

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

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

The description is well-structured: first sentence states purpose, then prerequisites, then types with examples, then delivery channels. It is somewhat lengthy but all information is relevant and earnestly placed.

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 covers return value (subscription id), prerequisites, type-specific parameter examples, delivery channel details, and constraints (SMS cap, webhook auto-disable). It is sufficiently complete for an AI agent to correctly invoke 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%, but the description enriches parameter understanding with concrete examples for each type (e.g., items:["5.02"] for sec_8k) and additional constraints for delivery fields (phone verification, SMS cap). This adds significant value 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 that the tool creates a proactive monitoring subscription, lists supported event types (sec_8k, polymarket_edge, fred_series, etc.) and delivery channels. It distinguishes itself from sibling tools like list_subscriptions and unsubscribe 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 specifies a prerequisite (Pipeworx OAuth account) and details delivery channel constraints (SMS must be verified, 10/day cap; webhook auto-disabled after 10 failures). While it does not explicitly state when not to use, the context and examples provide clear 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, non-destructive. The description adds that it returns structured example questions with tool+argument shapes drawn from a live catalog, and that calling with no arguments gives a full spread. This adds behavioral context beyond annotations.

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

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

The description is detailed yet efficient, front-loading alternative phrasings and clearly conveying purpose, scope, and usage. Every sentence adds value, though it is slightly dense and could be broken into shorter sentences for readability.

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

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

Given one optional parameter and no output schema, the description fully explains what the tool returns (category-bucketed example questions with tool+argument shapes) and when to use it. No gaps remain for an agent to understand invocation and outcome.

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

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

Schema coverage is 100% for the only parameter 'topic', with description listing valid values. The tool description supplements this by explaining the effect of omitting the parameter (full spread) and giving example topic values, adding meaningful usage context.

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

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

The description clearly states the tool returns example questions categorized by topic, serving as an onboarding entry point. It distinguishes from siblings like ask_pipeworx or domain-specific tools by explicitly stating its role: 'Use this FIRST when you do not yet know what Pipeworx can do for you'.

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

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

Provides clear when-to-use guidance (first tool for onboarding) and when to pass topic vs. omit. While it doesn't explicitly list alternatives, the context and phrasing make usage unambiguous. Missing explicit 'when not to use' but sufficient.

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

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

Annotations indicate non-read-only, non-destructive, and idempotent. The description adds that the row is 'deactivated (not deleted)' and 'historical events stay available', which clarifies the behavior beyond annotations. No contradiction.

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

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

The description consists of two concise sentences that front-load the main action and provide necessary details without extraneous information.

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

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

Given the tool's simplicity (one required parameter, no output schema), the description adequately covers purpose, ownership constraints, and the deactivation behavior. It is complete enough for an agent to use correctly.

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

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

Schema coverage is 100% with a clear description for the single parameter 'id'. The tool description does not add additional semantic detail beyond referencing 'by id', so 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 'Cancel a subscription by id' using a specific verb and resource, and it distinguishes itself 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?

The description includes ownership enforcement ('you can only cancel your own subscriptions'), providing a clear condition for use. It does not explicitly exclude scenarios, but offers sufficient 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?

Beyond the annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint), the description discloses critical behavioral nuances: what 'could_not_verify' means (the check did not happen, not evidence), what 'unsupported' means (looked but no source), the routing logic between SEC EDGAR and the grounded pipeline, and the exact nature of the returned verdict, value, citation, and reasoning. This is rich, non-redundant behavioral context.

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

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

The description is fairly long but every sentence carries value: trigger examples, use case, dual-path routing, output format, and important failure-mode caveats. It is front-loaded with the natural-language triggers, making the purpose immediately clear. Slightly dense but appropriate for the tool's complexity.

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

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

Given the tool's complexity, the description is remarkably complete. It fully explains what the tool returns (verdict enum, value with citation, reasoning), how it routes different claim types, and how to interpret ambiguous results ('could_not_verify', 'unsupported'). It also notes the efficiency benefit. This is more than sufficient for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100%—both parameters ('claim' and 'tolerance_pct') have descriptive text in the input schema. The description adds no direct parameter semantics beyond the schema, nor does it reference tolerance details. Baseline score of 3 is appropriate because the schema fully documents the parameters.

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

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

The description explicitly states the tool's purpose: natural-language claim verification against authoritative sources, with specific trigger phrases like 'fact check' and 'verify the claim that…'. It clearly identifies the resource (claims) and distinguishes it from siblings by detailing the two processing pipelines (SEC EDGAR for financials, grounded pipeline for everything else) and the structured verdict output.

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

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

The description gives clear usage context: 'Use whenever the agent needs to check whether something a user said is factually correct.' It also differentiates between financial and non-financial claims and notes that the tool 'Replaces 4–6 sequential calls,' implying it should be preferred over multi-step alternatives. However, it does not explicitly name alternative tools or provide when-not-to-use scenarios, so it falls short of a 5.

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