launches

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

Annotations already declare the tool as read-only, idempotent, and non-destructive. The description adds meaningful context: the default free model, the BYO Anthropic key and direct billing to the user, and the return structure. This goes beyond the structured annotations, though it doesn't cover potential rate limits or error conditions.

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 compact, front-loaded with the primary action, and each sentence earns its place: purpose, key configuration, return format, and use cases. No fluff or repetition.

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

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

Given the absence of an output schema, the description adequately summarizes return values (per-model {score, confidence, signals, raw_response} + combined view) and covers default behavior. It lacks elaboration on what 'signals' or 'combined view' entail, but for a tool of this simplicity it is sufficiently complete.

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

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

Schema coverage is 100%, so the parameters are already well-documented. The description adds extra semantics by explaining that _apiKey is needed for Anthropic, that the default model is free, and that the response includes per-model fields. This enriches the schema without being redundant.

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

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

The description clearly states the tool's function with a specific verb ('Probe'), resource ('one or more LLMs'), and output ('score visibility (0-100) per model'). It distinguishes itself from sibling tools like ask_pipeworx by focusing on external LLM knowledge checks rather than pipe-related 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?

Provides clear use cases ('AI-marketing audits, pre-launch brand checks, competitive monitoring') indicating when to use the tool. However, it does not explicitly mention alternatives or when not to use this tool versus comparable siblings like scan_competitor_ai_presence.

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

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

Annotations already declare the tool read-only, non-destructive, open-world, and idempotent. The description adds that it is a single fast call, works on every tier, and returns citation URIs, which helps an agent anticipate behavior. It doesn't contradict annotations and adds context about its routing behavior and output.

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

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

The description is information-dense and front-loaded with 'PREFER OVER WEB SEARCH', but contains some redundancy (e.g., 'START HERE' and 'default entry point' repeated). The examples and alternative tool mentions are valuable, so length is justified but could be trimmed slightly.

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

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

The description covers use cases, alternatives, trigger phrases, and the nature of the output (structured answer with citations). It does not describe error handling or how to handle ambiguous questions, but given the annotations and schema, it is sufficiently complete for an agent to select 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%, with all six parameters described as aliases for 'question'. The description does not add semantics beyond the schema, though examples illustrate the expected natural language input. Baseline of 3 is appropriate because the schema is sufficient.

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

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

The description clearly states the tool's function: it routes questions to one of 5,529 tools and returns structured answers with citations. It also distinguishes from siblings by pointing to ask_pipeworx_grounded and deep_research for different needs. This is a specific verb+resource with clear scope.

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

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

The description explicitly says to prefer this tool over web search and provides trigger phrases ('what is', 'look up', etc.) with examples. It also gives exclusion guidance: use ask_pipeworx_grounded for verbatim evidence and deep_research for multi-part questions. This is model usage guidance.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive. The description adds valuable context beyond that: it explains the beta nature, that no candidate is currently active so it matches ask_pipeworx exactly, and that it is a full working router with no fallback. This discloses the experimental edge and potential for behavior changes when candidates are active, which is useful for the agent.

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 earns its place: it establishes identity, current state, usage, and reassurance. It is front-loaded with the core purpose, though it could be 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 lack of an output schema, the description compensates by stating the response shape is identical to ask_pipeworx. It covers the tool's status, behavior, and usage in a self-contained way, making it complete for an agent to invoke correctly. Minor gap: it doesn't explain how routing works or how to interpret responses, but the cross-reference to ask_pipeworx covers this.

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

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

The input schema already provides 100% coverage with descriptions for all six parameters (question and five aliases). The description adds that arguments are the same as ask_pipeworx, but this is a cross-reference rather than substantive semantic detail. Baseline 3 is appropriate given the schema's completeness.

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

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

The description clearly states this is a beta version of ask_pipeworx, a universal router with 5,529 tools, and explicitly contrasts it with the stable ask_pipeworx by noting it hosts candidate routing improvements. This distinguishes it from sibling tools and specifies its function.

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 explicit use guidance: 'Use it exactly like ask_pipeworx when you want the newest routing' and notes results are compared against the stable router. This gives a clear when-to-use, though it does not explicitly state when not to use it (e.g., for stable production needs), and doesn't mention other alternatives like ask_pipeworx_grounded.

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

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

Beyond the annotations (readOnly, openWorld, idempotent, non-destructive), the description discloses that the tool costs 'one extra LLM call,' returns evidence with a verbatim quote, and explicitly refuses when data doesn't directly answer—listing all refusal_reason values. This provides deep insight into expected behavior.

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

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

The description is a dense but efficiently structured paragraph. Every sentence earns its place: purpose, mechanism, output format, refusal modes, usage context, and cost comparison. It flows from what → how → when, with zero wasted words.

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

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

With no output schema, the description fully specifies the return structure on success and failure, including all refusal_reason values. It also covers cost, routing, and source count, leaving no critical gaps for an agent selecting and invoking the tool.

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

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

The schema already documents all six parameter aliases (question, q, text, input, query, prompt) with 100% coverage. The description does not add parameter-specific semantics; it focuses on usage and output. Baseline 3 is appropriate given the schema's high coverage.

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

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

The description clearly defines the tool as a 'Hallucination-resistant answer mode' and distinguishes it from ask_pipeworx by explaining it 'EXTRACTS the answer using ONLY what the tool result contains.' It names the verb (ask) and resource (Pipeworx) while adding the grounded mode, which sets it apart from siblings like ask_pipeworx_beta.

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 and when-not-to-use guidance: 'Use whenever an answer will be quoted, cited, or acted on' and 'prefer ask_pipeworx for casual lookups.' It also names the alternative and quantifies the cost trade-off, making the selection criteria unambiguous.

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 extensive behavioral detail beyond the read-only annotation: low-confidence short-circuit behavior, closed-market status, illiquid wide-spread warnings, cancellation-rule parsing, and the blocking nature of resolution paths. This is far beyond what annotations convey.

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 and well-structured with labeled sections, but it is extremely long and encyclopedic. While each section earns its place, the overall length reduces conciseness.

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

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

No output schema exists, so the description fully compensates by detailing response shapes, resolver contract, parent-event extractor, news fields, safety mechanisms, and resolution-rule risks. Every operational aspect is covered.

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 covers all parameters, but the description enhances meaning: it explains depth's 'quick/thorough' distinction via fan-out examples and include_raw's size/use tradeoffs. This adds value 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?

Opens with 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call' – a specific verb+resource. The 'Use for' phrases ('should I bet on X', 'what does the data say about Y') clearly distinguish it from sibling tools like arbitrage or edge trackers.

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 provides 'Use for' scenarios, giving clear context for when the tool is appropriate. However, it does not mention alternatives or exclusions (e.g., when to use polymarket_arbitrage instead), 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.

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

Beyond the annotations (readOnly, idempotent, non-destructive), the description discloses specific data sources (SEC EDGAR/XBRL, FAERS), handling of off-calendar fiscal years, sorting by primary metric, and the return format including citation URIs. This provides substantial behavioral context without contradicting the annotations.

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

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

The description is dense but each sentence serves a purpose: examples, explicit priority, data specifics, fiscal year handling, sorting behavior, and output format. It is front-loaded with the most critical usage guidance and wastes no words.

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

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

With no output schema, the description properly explains return values ('paired data + pipeworx:// citation URIs') and also covers scope constraints (2–5 entities), sorting, and the efficiency benefit. This is complete for a comparison tool with two parameters and rich 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?

The schema already describes both parameters fully (100% coverage). The description adds interpretive value by explaining what each enum value (company vs drug) actually retrieves (10-K financials vs FAERS/trial data), which goes beyond the schema's simple 'Entity type' labeling. However, the core parameter semantics are already covered by 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 performs side-by-side comparisons of 2–5 companies or drugs in one parallel call. It distinguishes from siblings like entity_profile by explicitly prioritizing this tool over sequential single-entity lookups, and uses trigger phrases ('X vs Y', 'which is bigger') to make the purpose undeniable.

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

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

The description provides explicit when-to-use guidance via example queries and directly says 'ALWAYS PREFER over sequential single-pack lookups when comparing entities.' It also contrasts with alternatives by stating it replaces 8–15 sequential lookups, giving clear direction on when this tool should be chosen over sibling 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 readOnly/openWorld/idempotent, but the description adds substantial behavioral context: account/paid plan requirements, 15-90s latency, gap[] behavior (never invents), contradictions[], hop fields, citation_uri resolvability, and excerpting of large records. No contradiction with annotations; the description extends transparency well beyond the structured hints.

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

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

The description is long but densely packed with actionable information; every sentence contributes to usage understanding (auth, latency, outputs, limitations, depth semantics). It is front-loaded with the account requirement. However, the wall-of-text format could be better structured with bullet points for readability, so it's not a perfect 5.

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

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

Given complexity (2 params, no output schema), the description fully compensates: it details the return packet structure (verbatim evidence, confidence, source, fetched_at, pipeworx:// citation), explains gaps[] and contradictions[], covers latency expectations, and notes excerpting behavior. It leaves no critical aspect of the tool's behavior ambiguous for an agent selecting it.

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

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

Although schema coverage is 100%, the description enriches both parameters. It explains 'depth' semantics far beyond the enum: quick=3 facets, standard=5 with gap recovery and contradictions scan, thorough=8 with iterative lead-chasing. For 'question', it clarifies 'Broad/multi-part is fine — decomposition is the point', adding meaning about expected input granularity.

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

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

The description clearly states it performs 'Grounded multi-source research across Pipeworx's 1455 STRUCTURED data sources' in one call, explicitly contrasting with open-web search and sibling ask_pipeworx. It specifies a concrete verb-resource pair and differentiates itself by decomposing questions and routing to 5,529 tools in parallel.

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: 'Best for broad/multi-part questions over structured data'. It names alternatives with exclusion criteria: 'For a single lookup use ask_pipeworx' and 'For BREAKING or colloquial CURRENT-NEWS ... prefer ask_pipeworx'. It also notes 'If you are not signed in, use ask_pipeworx instead', and describes depth-level tradeoffs.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds valuable context about the return structure (names, descriptions, full input schemas) and the promise that results are 'ready to call directly' with 'no second schema lookup needed', which goes beyond the annotations without contradicting them.

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

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

The description is somewhat lengthy due to the enumerated list of data domains, but every sentence contributes information: what it does, when to use it, what it returns, and a directive. It is well-organized 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?

Given the tool's moderate complexity and lack of an output schema, the description adequately covers its behavior, return value, and usage context. It explains that results include full schemas ready to call, which substitutes for an output schema, and the examples in the schema further illustrate usage. Minor gaps exist, like not describing the exact JSON shape of the result, but overall it is sufficient.

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

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

The input schema has 100% description coverage, documenting the 'query' parameter and all aliases (q, task, search, description) plus 'limit'. The description's mention of 'describing the data or task' aligns with the query parameter but adds no new semantic detail beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description opens with 'Find tools by describing the data or task', which clearly identifies the tool's verb and resource. It further differentiates itself from domain-specific sibling tools by positioning itself as a meta-tool for discovery, and the explicit list of supported data domains adds specificity.

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 explicit usage direction: 'Use when you need to browse, search, look up, or discover what tools exist' and 'Call this FIRST when you have many tools available and want to see the option set (not just one answer)'. This tells the agent exactly when to invoke it and hints at when not to (when seeking a single answer directly from a domain tool).

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

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

Beyond the annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint), the description discloses important behavioral details: it fans out across multiple sources in a single parallel call, returns specific data fields with sorting, includes fallback chains (GDELT→GNews), and notes the USPTO PatentsView API sunset with soft-fail behavior. This adds meaningful context about how the tool operates and its limitations, exceeding what annotations alone provide.

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

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

The description is long but densely packed with useful information. It is front-loaded with example queries and the core 'full cross-source profile' message. While it reads as a single verbose paragraph, each clause contributes to the tool's purpose, input requirements, output details, and fallback behavior. It is not wasteful, though restructuring into shorter sentences could improve scannability.

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

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

With no output schema, the description takes full responsibility for explaining return values, which it does thoroughly: lists cik, company_name, recent_filings (with URI format), fundamentals (specific fields and sorting), patents, news mentions, and LEI. It also covers input constraints, error conditions (names not supported), and fallbacks. For a complex multi-source tool, this description is remarkably complete and self-sufficient.

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

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

The input schema already provides 100% parameter coverage with descriptions for type and value. The description adds valuable usage context beyond the schema: concrete examples ('AAPL', '0000320193'), the requirement for zero-padded CIK, and explicit note that names are unsupported. This reinforces and clarifies the schema rather than repeating it, adding practical semantic guidance.

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

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

The description clearly states the tool's purpose: building a 'full cross-source profile of a US public company in ONE parallel call.' It uses specific verbs like 'profile', 'research', 'brief me' and lists concrete output categories (SEC, XBRL, USPTO, news, LEI). It also distinguishes itself from sibling tools like resolve_entity and compare_entities by emphasizing the holistic, cross-source nature and the preference over chaining multiple lookups.

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

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

The description explicitly says 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view.' It also provides clear exclusions: 'names not supported (use resolve_entity first if you only have a name)' and shows example queries to illustrate when to use the tool. This gives unambiguous guidance on when to select this tool over alternatives.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false. The description's 'Delete' aligns with this, but adds little behavioral context beyond what annotations provide, such as permanence or side effects. No contradiction.

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

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

The description is concise and focused, with three sentences each serving a purpose: core function, usage scenarios, and companion tools. No unnecessary words or repetition.

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

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

For a simple one-parameter tool with no output schema, the description adequately covers purpose and usage while leveraging annotations for safety context. It could mention irreversibility explicitly, but the destructiveHint annotation already conveys this.

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

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

Schema description coverage is 100% with the parameter 'key' described as 'Memory key to delete.' The description does not add additional meaning beyond the schema, matching the baseline for full schema coverage.

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

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

The description clearly states the tool's function: 'Delete a previously stored memory by key.' It uses a specific verb and resource, and distinguishes itself from siblings like remember and recall by emphasizing deletion.

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

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

Provides explicit usage context: 'Use when context is stale, the task is done, or you want to clear sensitive data the agent saved earlier.' It also suggests pairing with remember and recall, but does not explicitly state when not to use the tool, 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.

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds valuable behavioral context: it fetches the page, extracts title/description/key links, and outputs a single text blob. This goes beyond the annotation basics and explains the processing pipeline.

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

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

The description is three sentences, front-loaded with the core action, and each sentence earns its place. The 'Useful for' list adds practical context without being bloated. It's slightly list-heavy but overall efficient and well-structured.

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

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

Given the tool's simplicity (2 params, no output schema), the description is sufficiently complete: it explains what the tool does, the output format, and when to use it. The mention of 'single text blob ready to drop at site-root/llms.txt' partially compensates for the missing output schema. No major gaps remain.

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

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

Schema description coverage is 100% for both parameters, so the schema already documents url and max_links fully. The description does not add detail about parameter syntax or semantics beyond what the schema provides, but it does mention 'key links' which aligns with max_links. This is a solid baseline score.

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

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

The description clearly states a specific verb ('Generate') and resource ('a production-ready llms.txt file'), and explains the process (fetches, extracts, emits). It distinguishes itself from sibling tools focused on visibility checking by centering on file generation, making the purpose unmistakable.

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

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

The description offers explicit use cases ('getting a client's site indexed', 'drafting llms.txt for your own project', 'auditing how an AI crawler would see a competitor'), giving clear context on when to use it. It doesn't name alternative tools, but the use-case list effectively guides the agent.

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

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

The annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds value by enumerating the returned fields (name, time, status, pad, etc.), providing useful context beyond what annotations offer. 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 concise, front-loaded with the primary action and resource, and lists return fields in a compact single sentence. Every word earns its place 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?

For a simple single-parameter read-only lookup, the description covers purpose and return content, while annotations cover safety. The output schema handles detailed return values. It is adequately complete, though it could mention error handling or not-found cases, but this is minor given the tool's simplicity.

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

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

The input schema has 100% coverage for the id parameter, including a type, description, and example. The tool description merely references 'by ID' without adding extra semantic detail, so the schema already carries the meaning. 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 uses the specific verb 'Get' with the resource 'launch' and clearly states it retrieves details by ID. It distinguishes itself from sibling tools like get_past_launches and search_launches, which focus on lists or 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?

The description implies usage for looking up a specific launch by ID, but it does not explicitly state when to prefer this over alternatives like search_launches or get_past_launches. No exclusions or alternative tool references are provided.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, etc.), the description adds meaningful behavioral details: the data source (Launch Library 2), sorting order, confirmed-outcome filtering, separate `unconfirmed` reporting, and the fact that `until` defaults to now. This significantly aids the agent in understanding tool behavior.

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

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

The description is front-loaded with the core purpose and each sentence adds value: clarifies confirmed/unconfirmed semantics, windowing, return fields, and default limit. It is detailed but not verbose.

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

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

The description fully covers the tool's nuanced behavior (confirmed versus unconfirmed launches), which is essential for correct use. It also mentions return fields even though an output schema exists, providing a complete picture for the agent.

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

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

The input schema already provides 100% parameter coverage with detailed descriptions and examples. The description adds a brief reminder about using `since`/`until` for a window and the default limit, but this largely restates schema information without introducing new semantics.

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

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

The description clearly states the tool's function: 'Fetch rocket launches that have already flown, sorted newest-first, from Launch Library 2.' This is a specific verb+resource+scope that distinguishes it from sibling tools like get_upcoming_launches and search_launches.

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

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

The description provides clear context on when to use the tool: for counting or listing launches with confirmed outcomes, and explains the distinction between `launches` and `unconfirmed`. It also explains how to use `since`/`until` for windowed queries, though it doesn't explicitly mention alternatives like get_upcoming_launches or search_launches.

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 read-only, idempotent, open-world, and non-destructive hints. The description adds value by specifying the data source (Launch Library 2), default result count, and the exact fields returned, going beyond the annotations. No contradictions found.

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

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

Two concise, front-loaded sentences communicate purpose, source, output fields, and default behavior without redundancy or fluff. Every clause earns its place.

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

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

For a simple read-only tool with one optional parameter, rich annotations, and an output schema, the description fully covers purpose, result contents, and defaults. No significant gaps remain for an agent to invoke it correctly.

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

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

Schema description covers the sole parameter 'limit' with its default (10) and meaning. The description repeats 'Default 10 results' but adds no new semantics. Baseline of 3 is appropriate given 100% schema coverage.

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

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

Description uses a specific verb ('Fetch') and resource ('next scheduled rocket launches from Launch Library 2'), clearly distinguishing it from siblings like get_past_launches and search_launches. It also enumerates return fields, leaving no ambiguity about what the tool does.

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 establishes clear context: this tool is for retrieving upcoming launch schedules. However, it does not explicitly mention alternative tools or when not to use it, so it falls just short of the 'explicit alternatives' bar for a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safe read-only nature is known. The description adds value by stating the return fields (id, type, params, created_at, last_fired_at, fire_count) and scoping to 'the caller's active subscriptions,' which is not implied by the annotations. No contradictions.

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

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

The description is two sentences, front-loaded with the core action and resource, then lists return fields, then provides usage guidance. Every sentence earns its place with no redundant 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?

This is a simple read-only list tool with one fully documented optional parameter. The description completes the picture by specifying return fields, which compensates for the lack of an output schema. All necessary context is provided.

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

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

The input schema has 100% coverage for the single optional parameter include_inactive, with its own description. The tool description does not add extra meaning to this parameter, but since the schema fully explains it, the baseline of 3 is appropriate.

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

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

The description clearly states the tool's function: 'List the caller's active subscriptions.' It uses a specific verb (list) and resource (subscriptions), and distinguishes itself from sibling tools like subscribe and unsubscribe by focusing on reviewing existing 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 explicitly says when to use it: 'Use this to review what you're monitoring before adding more or to find an id to cancel.' This directly guides the agent to use it before subscribing or unsubscribing, referencing the alternatives in context.

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

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

The description adds substantial behavioral context beyond the minimal annotations: it discloses rate limiting, quota exemption, claim_token return/retrieval flow, team digest frequency, and roadmap impact. It also specifies what content to include and what to avoid, giving agents a clear mental model of side effects.

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

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

The description is long but every sentence carries operational value; it front-loads the core purpose and then expands with usage constraints, exclusions, and workflow details. While not brief, it is well-structured for an agent.

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

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

For a tool with no output schema, the description adequately covers expected return behavior ('returns a claim_token'), the retrieval workflow, limitations, and intended context. It fully equips an agent to decide when and how to 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 the baseline is 3, but the description enriches parameter meaning by explaining the claim_token usage pattern ('pass it back later as pipeworx_feedback({claim_token:"pwfb_…"})') and instructs message content ('Describe the issue in terms of Pipeworx tools/packs — don't paste the end-user's prompt'). This 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 ('Tell') and resource ('Pipeworx team') and clearly distinguishes from siblings by limiting scope to tools served by this Pipeworx connection. It explicitly covers bugs, features, gaps, and praise, making the tool's purpose unambiguous.

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

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

The description gives explicit when-to-use guidance: 'Use when a tool returns wrong/stale data (bug)...' and also provides exclusions: 'if the tool came from a different MCP server... file it with that server instead.' It also offers a disambiguation test ('Pipeworx tool names are the ones this connection lists').

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

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

Annotations declare readOnly, openWorld, idempotent, and non-destructive. The description adds meaningful context beyond that: it is 'derived from CF analytics-engine', contains 'no PII', and is 'cached 5min-1h depending on window'. These details inform freshness and privacy expectations without contradicting 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 longer than two sentences but each sentence earns its place: purpose, use cases, data provenance, and caching. It is well-structured and front-loaded, though slightly verbose. It could be trimmed, but the information density is high enough to justify the length.

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

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

For a simple read-only tool with one parameter and no output schema, the description covers output contents, time windows, use cases, data source, privacy, and caching. It gives the agent everything needed to decide whether and how to call this tool, making it complete for the tool's complexity.

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

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

The schema fully documents the single window parameter with enum values and a description. The tool description enriches this by explaining the tradeoff: 'Shorter windows surface what's hot right now; longer windows show steady-state demand' and notes the default. This adds valuable interpretive guidance 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 opens with a clear statement of what it returns: 'top tools, top packs, and total call volume' over a recent window. The verb 'Returns' and specific data make it unambiguous, and it is clearly distinct from sibling tools like discover_tools by focusing on aggregate usage trends from other AI agents.

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

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

The description provides three explicit 'Useful for' scenarios: discovering hot data sources, confirming canonical tool choices, and checking alignment with agent needs. This gives clear context for when to use it, but it does not name alternative tools or 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?

The description goes far beyond the annotations (which already indicate read-only, open-world, idempotent, non-destructive) by disclosing detailed behavioral traits: the 3pp deviation threshold, placeholder filtering logic, Jaccard similarity requirement, fill check against live CLOB depth, and the condition that realizable_edge_pp ≤ 0 signals a non-tradeable overround. This adds substantial context not inferable from annotations.

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

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

The description is long but every sentence carries meaningful detail—modes, thresholds, filters, fill-check logic, and output shapes. It is structured in a logical flow, though it could benefit from clearer paragraph breaks or headers. It is not tautological or redundant, so it earns a solid score just below perfect.

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 complexity and lack of an output schema, the description compensates thoroughly by specifying the response structure (opportunities[], partition_check fields, fill_check details), explaining edge cases (placeholder filter, low similarity, thin legs), and referencing related tools. It leaves little ambiguity for an agent deciding when and how to invoke it.

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

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

Although schema coverage is 100%, the description adds significant meaning: it explains the formats and accepted inputs for 'event' (slug or full URL) and 'topic' (seed question), provides concrete examples, and clarifies how each parameter changes the tool's behavior (single-event vs cross-event scanning). This is a strong augmentation over the schema's basic field 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 finds arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It distinguishes itself from siblings by outlining three distinct modes (trending_scan, event, topic) and references the output structure, making the purpose unambiguous and specific to this 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?

Explicit usage guidance is provided: 'Call with NO args for a trending_scan', 'pass event for the strongest per-event partition_check', and 'topic for a themed cross-event scan'. It also names an alternative tool ('For custom sizing use polymarket_fill_risk') and explains when to choose each mode, including recommendations and a semantic anchor for cross-event mode.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds substantial behavioral context: caching behavior ('Cached 1h at the KV level keyed on all knobs'), diagnostics for empty segments, a 24h-move warning, the exclusion of Fed bets, and how slippage and edge are computed. It also explains the rationale for structural arbitrage corrections. There is no contradiction with annotations; rather, the description enriches the agent's understanding of the tool's behavior.

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

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

The description is dense and lengthy, but it is well-organized into logical sections (model families, output fields, knobs, response structure). The first sentence front-loads the core purpose. While it could be more concise, the level of detail is justified given the tool's complexity and the absence of an output schema. The use of ALL-CAPS section headers helps 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 there is no output schema, the description compensates by detailing the response top-level structure, per-opportunity fields (edge_pp_net, kelly_fraction, liquidity, spread_pp, volume), and the diagnostics object. It also explains why the Fed bet signal is unreliable and how the caching works. This makes the tool's behavior and output expectations clear for an agent, covering both normal and edge cases.

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

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

The input schema already provides 100% coverage with detailed descriptions for all nine parameters. The tool description only briefly references parameter groups (e.g., 'TRADEABLE-EDGE KNOBS') without adding meaning beyond the schema. Since the schema descriptions are already thorough, the description adds minimal incremental value for parameters, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price.' It also specifies the target use case ('Built for "what should I bet on today"'), distinguishing it from generic market data tools. The mention of three model families and output segments adds specificity beyond the 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 provides clear usage context ('agents discover opportunities without paging hundreds of markets') and explains the ideal invocation scenario. However, it does not explicitly mention when not to use the tool or compare it to sibling tools like polymarket_arbitrage or polymarket_edge_tracker. Since it lacks explicit exclusions or alternative recommendations, it misses the top score.

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

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

Beyond the annotations (read-only, open-world, idempotent), the description discloses key behavioral details: snapshots are written on cache-miss causing gaps, history is bounded by a 60-day TTL, and decay is computed from daily closes net of slippage rather than intraday data. This adds substantial context that annotations alone could not provide.

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

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

The description is long but highly structured and dense with essential information. It leads with the core question, then clearly separates Args, RESPONSE format, and LIMITS. Every sentence serves a purpose, making the length 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?

With no output schema, the description fully explains the response structure (tracked, expired, snapshot_dates) including field meanings and the interpretation of gaps. It also covers limitations (TTL, snapshot start time) and data source details, making the tool's behavior complete for an agent to invoke correctly.

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

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

The input schema already fully describes both parameters (days and window) with defaults and valid values, giving 100% schema coverage. The description repeats these defaults and adds a little context about 'snapshot family' and cache-miss behavior, but does not significantly enhance the parameter semantics beyond what the schema already states.

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 provides edge persistence and decay telemetry built from daily polymarket_edges snapshots, answering 'how long has this edge existed and is it shrinking?'. This specific verb-resource pairing (tracks persistence/decay) distinguishes it from sibling tools like polymarket_edges, which presumably provides current edges.

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

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

The description gives strong context for when to use the tool: to evaluate whether a wide edge is fresh or stale, explicitly noting that a 3-week-old wide edge is a different trade than a fresh one. However, it does not explicitly name alternatives or state when NOT to use it, so it stops 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.

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

Annotations already indicate read-only and idempotent behavior, but the description adds substantial behavioral detail: it walks the CLOB ladder, returns a verdict, calculates capture ratio, and flags partial basket fill risk. It also clearly warns that 'partial basket fills convert an arb into an unhedged directional position,' which is critical risk context beyond the annotations.

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

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

The description is long but densely packed, using clear section markers (REQUIRES, SINGLE-MARKET, BASKET) and front-loading the purpose. Every sentence adds necessary operational or risk context; the length is justified by the tool's two modes and many return fields.

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 enumerates return values for both modes, including nuanced items like thin_legs[], max_clean_notional_usd, and forced_directional_risk. It also covers parameter behavior, required modes, and real-world loss scenarios, making it sufficiently complete for correct invocation.

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

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

Although schema description coverage is 100%, the description greatly enriches parameter understanding. It explains mode-specific semantics: size_usd means 'max spend on buys, target proceeds on sells' in single-market mode but 'settlement notional' in basket mode, and side defaults differ (buy_yes vs auto). This is meaningfully more than the schema provides.

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

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

The description opens with a specific action: 'Realizable-vs-theoretical edge check against live CLOB order-book depth,' clearly defining the tool's core function. It explicitly distinguishes itself from sibling tools like polymarket_arbitrage and polymarket_edges by positioning itself as a pre-trade risk validation step.

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?

Usage context is explicit: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500.' This provides a concrete trigger and threshold, making it clear when this tool is the appropriate choice versus acting directly on arb/edge signals.

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

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

The description goes far beyond the annotations (readOnlyHint, idempotentHint). It discloses internal behavior such as automatic event fetching for topic mode, response structure (leg-by-leg prices, matched spread), and detailed safety fields including compatibility_warning conditions, temporal_alignment consequences, and skipped_cross_type/subtype counters. This provides deep insight into how the tool behaves and what edge cases affect the output, with no contradiction to 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 long and dense, but it is well-structured: beginning with the purpose, then modes, response, and safety fields. Every sentence contributes meaningful information, though some details about safety fields could arguably be compressed. It is verbose but appropriately so for the complexity of the tool, earning a strong score rather than a perfect one.

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 carries the full burden of explaining return values and behavioral edge cases. It thoroughly covers the response structure, compatibility warnings, temporal alignment, and skip counters. The complexity of cross-venue spread matching is high, and this description addresses the key concerns a user would have: what the spread means, when it's valid, and how to interpret failure conditions.

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

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

Although the schema already has 100% coverage with descriptions for each parameter, the tool description adds substantial meaning beyond the schema: it explains the 'topic' mode's pre-mapped shortcuts, how explicit parameters override the topic-mapped side, and how the two modes interact. The schema only lists examples and basic descriptions; the description clarifies usage semantics and relationships between 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 opens with a clear, specific statement: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' It then elaborates on two distinct operational modes (topic shortcuts and explicit ticker/slug pairings), which immediately distinguishes this tool from siblings like polymarket_arbitrage (which presumably focuses on intra-venue arbitrage) and other Polymarket-only tools.

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

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

The description explicitly explains when to use each mode: 'TWO MODES: (1) `topic` — 10 pre-mapped macro shortcuts... (2) explicit `kalshi_event_ticker` + `polymarket_event_slug` for custom pairings.' It also provides clear guidance on limitations: 'Real cross-venue spreads are rarer than the macro-shortcut list suggests... pre-mapped ≠ tradeable.' While it doesn't name a specific alternative tool, it tells the user what to expect and when results may not be meaningful.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds valuable scoping context: 'Scoped to your identifier (anonymous IP, BYO key hash, or account ID).' It also clarifies the listing behavior when key is omitted. This goes beyond annotations, though it doesn't mention edge cases like missing keys or return formats.

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

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

The description is two sentences, front-loaded with the core function, and every sentence earns its place. It packs purpose, usage, scoping, and sibling relationships without redundancy. No wasted words.

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

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

For a simple tool with one optional parameter and no output schema, the description is complete. It explains what the tool does, when to use it, what data it accesses (saved memories), and how it is scoped. The return behavior is implied by 'Retrieve a value' and 'list all saved keys'. No critical information 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?

The schema description covers the key parameter at 100%, providing a baseline of 3. The tool description adds meaning by giving concrete examples of what keys represent ('the user's target ticker, an address, prior research notes'), enriching the schema's generic 'Memory key' description. This elevates it above 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 the tool's function: 'Retrieve a value previously saved via remember, or list all saved keys (omit the key argument).' It uses specific verbs (retrieve/list) and identifies the resource (saved values/keys). It also distinguishes from siblings by explicitly mentioning 'Pair with remember to save, forget to delete.'

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: 'Use to look up context the agent stored earlier... without re-deriving it from scratch.' It also provides clear alternatives by naming remember and forget. This is strong usage context that helps the agent select the right tool.

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

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

Annotations claim readOnlyHint=true, but the description explicitly states that mark_read:true flags returned events as read, which modifies state. This contradicts the read-only hint, making the transparency score 1 as per the rules.

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

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

The description is four sentences, front-loaded with the core action, and contains no unnecessary words. Every sentence contributes meaningful 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?

The description covers return contents (source, citation_uri, raw payload), filtering, side effects, and alternative access via HTTP. For a simple tool with optional parameters, this is complete.

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

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

Schema coverage is 100%, but the description adds valuable semantics: type examples (sec_8k), since as ISO timestamp, and the effect of mark_read on subsequent calls. This goes beyond the schema baseline.

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

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

The description clearly states it pulls fired events from the subscription feed, with a specific verb and resource, and distinguishes itself from sibling tools like list_subscriptions or subscribe by focusing on reading events.

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 usage context, including filtering by type/since, mark_read behavior, and an alternative HTTP endpoint for scripts. It doesn't explicitly state when not to use it, but the context is sufficient.

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

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

The description discloses several behavioral traits beyond annotations: data sources (SEC EDGAR, GDELT→GNews fallback, USPTO), fallback logic, rate-limit handling, soft-fail behavior for patents, and return format (changes[], total_changes, citation URIs). This is rich additional context.

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

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

The description is dense but every sentence adds value. It is front-loaded with the core purpose, then details sources, parameters, and output. Slightly long but justified given the complexity; not verbose or redundant.

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

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

For a tool with no output schema, the description explains what will be returned (structured changes[] grouped by source, total_changes count, attribution URIs). It also covers key edge cases like patent API sunset and fallback behavior. Complete for the tool's complexity.

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

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

Schema covers all 3 parameters with descriptions, so baseline is 3. The description adds extra semantics for 'since' by explaining accepted formats (ISO or relative shorthand like '7d', '30d', '3m') and even recommending '30d' or '1m' for typical monitoring. 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 a change feed for a company, with a specific verb ('change feed') and resource scope. It also explicitly distinguishes itself from sibling tool entity_profile by naming it as the alternative for static profiles.

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

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

Provides explicit usage context with natural language examples ('What's new with X', 'latest on Y') and gives a clear exclusion: 'Use entity_profile instead when you want the static profile...' This is exactly the type of when-to-use guidance needed.

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

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

The description adds meaningful behavioral context beyond annotations: data is scoped by identifier, and retention varies (persistent for authenticated users, 24h for anonymous). It also explains the memory lifecycle by referencing recall and forget. Annotations already indicate non-read-only and idempotent, so the bar is lower; the description covers key additional traits. It doesn't mention overwrite behavior, but this is minor given the idempotent hint.

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 composed of four concise sentences that front-load the core purpose, then provide usage cues and lifetime details. Every sentence adds value and there is no fluff or redundancy.

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

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

For a simple two-parameter tool with ample annotations and no output schema, the description is complete. It covers purpose, usage, scoping, persistence, and companion tools, giving the agent all necessary context to use the tool effectively.

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

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

Schema coverage is 100% and parameters are well-described. The description adds context about key-value storage and scoping, but doesn't add substantial syntax or format details beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Save data the agent will need to reuse later.' It explicitly identifies the resource (key-value storage) and distinguishes itself from sibling tools by noting 'Pair with recall to retrieve later, forget to delete.' This differentiates it from the memory retrieval and deletion 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?

Provides explicit when-to-use guidance: 'Use when you discover something worth carrying forward (a resolved ticker, a target address, a user preference, a research subject)'. It also clarifies persistence conditions (authenticated vs. anonymous) and mentions companion tools (recall, forget), giving the agent a clear decision framework.

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 non-mutating/idempotent annotations, the description adds meaningful behavioral specifics: unresolved identifiers are surfaced under `unresolved` rather than silently omitted, enrichment degrades gracefully (EDGAR identifiers still return even if GLEIF/OpenFIGI is down), and each call cascades through multiple endpoints. These are the kind of side effects and edge-case behaviors an agent must know.

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

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

The description is longer than average but each sentence serves a purpose (examples, supported types, degradation behavior, efficiency note). The structure front-loads examples and a directive ('Use FIRST') before diving into type-specific detail. Some of the supported-type detail could be streamlined, but it's justifiable given the two distinct entity modes.

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 lookup tool with no output schema, the description thoroughly covers return values and behavior for both supported entity types, including citation format and failure/degradation semantics. It also reveals the internal cascading nature, which helps the agent calibrate cost/latency. There is no obvious missing 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?

The schema already names both parameters and provides type/value descriptions. The description enriches this by giving concrete examples (AAPL, 0000320193, 'ozempic') and clarifying what formats are accepted for each entity type. It also explains what identifiers will be returned, which is very useful for a 2-param tool with high schema coverage.

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

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

The description opens with concrete user queries ('ticker for', 'CIK for') and then states a clear mission: resolve a natural-language name to canonical official identifiers needed by other tools. It explicitly differentiates from siblings by framing itself as the input-resolution step for downstream 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?

Gives an explicit trigger condition: 'Use FIRST whenever you have a name but need an ID.' It provides examples of when to reach for it, including ownership queries. However, it doesn't explicitly mention when not to use it or name alternatives, but the placement ('FIRST') plus sibling list is 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?

Annotations already declare read-only, idempotent, and non-destructive. The description adds valuable behavioral context: it probes each entity with ai_visibility_check, ranks by score, and returns metrics. 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?

Three sentences, front-loaded with the core purpose, followed by mechanism and use case. No fluff, 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?

Despite no output schema, the description specifies return values ('ranked list with score, confidence, signal density per entity'). It covers multi-entity semantics, optional models, and shared context, making it complete for the tool's complexity.

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

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

Schema coverage is 100%, so the schema fully documents all parameters. The description reinforces the 'entities' semantics ('your brand + N competitors') and the Anthropic API key requirement, but does not add significant beyond-schema detail.

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

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

The description clearly states the tool's function: 'Compare AI visibility across multiple entities side-by-side.' It specifies the operation (probes with ai_visibility_check), the output (ranked list), and distinguishes from siblings like ai_visibility_check (single entity) and compare_entities (generic comparison).

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

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

Provides clear usage context: 'Useful for competitive AI-marketing audits' with a concrete example query. It implies when to use (multi-entity comparison) versus ai_visibility_check for single entities, though it does not explicitly mention alternatives or exclusions.

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

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

Annotations already mark the tool as read-only, idempotent, and non-destructive. The description adds valuable context beyond these: partial failures degrade gracefully, bundlephobia's first measurement can take 5-30s, and sources_failed will list failures. It also discloses what return components to expect.

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 the purpose, then efficiently lists sources, use cases, return fields, and failure behavior. Every sentence adds information without filler, and the structure flows logically.

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

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

Despite no output schema, the description lists the summary fields (is_latest, license, published_at, advisory_count, bundle_kb_min, bundle_kb_gz, dependency_count, has_esm, tree_shakeable), per-advisory detail, links, alternative versions, and ecosystem scope. It also covers timing and degradation, making it complete for a complex composite tool.

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

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

Schema description coverage is 100%, so baseline is 3. The description does not add meaning beyond the schema for parameters; it repeats 'version' defaults and scoped package acceptance already present in the input 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 a composite 'should I add this npm package' check that fans out across deps.dev and bundlephobia. It uses a specific verb ('scan') and resource ('dependency'), and distinguishes itself from siblings like scan_competitor_ai_presence by including npm-specific details.

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 provides use cases: 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me"'. Also gives exclusions and alternatives: 'NPM ecosystem only in v1; PyPI / Maven / Cargo / Go fall under deps.dev:version directly.'

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

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

Annotations already document read-only, idempotent, and non-destructive behavior. The description adds the return field list, which is useful, but does not disclose additional behavioral traits such as whether the search covers past/upcoming launches, pagination, or rate limits. With annotations covering safety, this meets the baseline.

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

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

Two concise sentences that front-load the core action and resource, list return fields, and avoid redundant wording. Highly efficient and well-structured.

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

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

The description, combined with full schema coverage, output schema, and annotations, provides sufficient information for a simple search tool. However, it leaves ambiguity about whether the search includes past, upcoming, or both types of launches—a relevant detail given the presence of dedicated past/upcoming 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 descriptions cover both parameters completely (100% coverage) with examples and defaults. The tool description's mention of 'rocket name, mission, agency' partially overlaps with the schema's examples, adding marginal semantic 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 the action (search), the resource (launches), and the search criteria (keyword: rocket name, mission, agency). It also lists the return fields, distinguishing it from sibling tools like get_launch which appear to retrieve specific launches by ID.

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

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

Provides clear context for when to use the tool (when you have a keyword to search launches) and subtly differentiates from specific retrieval siblings, but does not explicitly name alternatives or state when not to use it. The context is clear enough for most use cases.

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 (read-only, idempotent), the description discloses truncation ('cap is 200K chars (longer inputs are truncated and flagged)'), technical details (BGE-base-en embeddings, cosine, 500-char windows), and output characteristics (offsets and similarity scores). This adds substantial behavioral context without contradicting annotations.

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

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

The description is front-loaded with the core purpose and then layered with use case, pairing, and technical details. It is slightly dense but every sentence contributes value; no filler. Slightly longer than necessary but still well-structured.

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

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

With no output schema, the description specifies that results are top-N passages with character offsets and similarity scores. It also covers edge cases (truncation flag) and gives a concrete workflow with a sibling tool, making it complete for an agent to understand inputs, outputs, and limits.

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

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

Schema coverage is 100% and each parameter has a thorough description (e.g., 'max ~200K chars', '1-20, default 5', and query examples). The tool description adds contextual examples ('SEC 10-K body') but doesn't materially improve parameter-level semantics beyond the schema, so baseline 3 applies.

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

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

The description uses a specific verb ('semantic search') with a clear resource ('inside a fetched record') and concrete examples. It also distinguishes itself from sibling tools by explicitly pairing with ask_pipeworx_grounded and positioning itself as the retrieval step after fetching.

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

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

It explicitly states when to use: 'Use when the record is too big to cram into the prompt' and explains the benefit ('saves context, returns only the passages that matter'). It also names a complementary tool (ask_pipeworx_grounded) for grounding over passages, clarifying the workflow.

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

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

Discloses crucial behavioral constraints beyond annotations: auth requirements, anonymous/BYO limitation, SMS verification and daily cap, webhook auto-disable after 10 failures, and one-time signing secret. 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?

Dense but well-structured; front-loaded with purpose and returns. Slightly long due to type-specific examples, but each sentence adds value for a complex tool.

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

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

Given nested parameters, multiple subscription types, and no output schema, the description covers return value, auth, delivery, and failure behavior, making it complete for agent invocation.

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

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

Schema coverage is 100%, but the description adds examples, conditional requirements (e.g., clinical_trial requires sponsor or condition), and delivery constraints like phone verification and webhook signing secret, significantly enriching parameter meaning.

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

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

Clearly states it creates a proactive monitoring subscription to a live-data event stream and returns the new subscription id. Distinguishes from siblings like list_subscriptions and unsubscribe by specifying the creation action and supported event types.

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 prerequisites (requires Pipeworx OAuth account) and context for each subscription type. Does not explicitly name alternatives or exclusions, but the description's focus on creation plus sibling names implies usage.

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

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

Annotations already declare readOnly, openWorld, idempotent, non-destructive. The description adds useful behavioral context: the result is 'drawn from the live catalog of thousands of tools', returns 'category-bucketed example questions', and each example includes 'exact tool + argument shape'. This goes beyond the annotations without contradicting them.

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

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

The description is dense but well-structured: front-loaded with trigger phrases, then purpose, output format, and usage variants. Every sentence adds information, though the opening list of example queries is a bit long; it is still compact and purposeful.

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 adequately explains what will be returned (category-bucketed example questions with tool and argument shape). It also covers the two invocation modes and how it fits into onboarding. Given the tool's moderate complexity, this is complete.

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

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

Schema description coverage is 100% and the one optional parameter is already well-documented with allowed values. The description adds a few examples ('finance', 'pharma', 'betting') and reinforces the omit-for-spread behavior, but this only slightly enriches the schema, so baseline 3 is appropriate.

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

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

The description states a specific verb ('suggest questions'), resource ('Pipeworx'), and scope ('onboarding entry point'), and clearly distinguishes itself from sibling Q&A tools like ask_pipeworx by returning example questions with exact tool+argument shapes rather than answering questions.

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

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

Explicitly provides when-to-use guidance: 'Use this FIRST when you do not yet know what Pipeworx can do for you, or to learn how to call the meta-tools.' It also explains the no-argument vs topic-filtered usage and lists what kind of focus topics are valid.

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

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

The description goes beyond annotations by disclosing ownership enforcement and that the row is deactivated rather than deleted, preserving historical events. This adds valuable behavioral context not present in the annotations.

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

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

The description is two sentences, front-loaded with the primary action, and contains no filler. Each sentence adds meaningful information about behavior and consequences.

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 one-parameter tool with good annotations and no output schema, the description fully covers the operation, ownership restriction, and data retention behavior. No critical information 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?

The schema already provides full coverage of the single parameter 'id' with a clear description. The tool description only references 'by id' without adding new meaning, so it meets the baseline for high schema coverage.

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

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

The description uses a specific verb ('Cancel') and resource ('subscription'), clearly stating the action and its scope. It distinguishes itself from siblings like 'subscribe' and 'list_subscriptions' by describing the cancellation behavior.

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

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

The description clearly indicates the tool cancels a subscription by id and adds ownership constraints, providing context on when it is appropriate. It does not explicitly mention alternatives or when not to use it, but the context is clear.

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

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

Annotations already declare readOnly/openWorld/idempotent, but the description adds critical behavioral nuance: could_not_verify means the check did not happen and must not be shown as evidence, unsupported means no source covers the claim, and the verdict set is enumerated. It also discloses the two execution pipelines and the presence of verbatim evidence, going far 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 moderately long but every sentence earns its place: trigger examples, routing, verdict semantics, and caution about could_not_verify. It is front-loaded with the purpose and ends with an efficiency note, though it could be slightly tighter by not listing so many synonymous trigger phrases.

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

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

Given the tool's complexity (two pipelines, five verdicts plus error states) and absence of an output schema, the description supplies all necessary information: the verdict enum, the structured/grounded routing, and explicit handling instructions for inconclusive results. This is a complete picture for an agent to use the tool correctly.

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

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

Schema coverage is 100% with both claim and tolerance_pct documented, so baseline is 3. The description goes further by giving a concrete example of claim formatting and explaining how tolerance_pct overrides wording-implied defaults (including a hallucination-detection use case), adding genuine semantic 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 opens with a list of natural-language triggers ("fact check", "verify the claim that…"), then defines the tool as claim verification against authoritative sources, with a structured SEC EDGAR + XBRL fast path for company-financial claims and a grounded pipeline for any other factual claim. This clearly distinguishes it from sibling tools like ask_pipeworx or search_launches, making its scope 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?

It explicitly states 'Use whenever the agent needs to check whether something a user said is factually correct' and describes automatic routing for company-financial versus other claims. It also notes it replaces 4–6 sequential calls, giving a strong efficiency rationale, and explains when could_not_verify vs unsupported should not be treated as evidence. This is sufficient guidance for an agent to know when to invoke it.

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