Rdap

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint true, and destructiveHint false. The description adds significant behavioral context: probing multiple models, scoring range (0-100), default free model, BYO key for Anthropic with direct payment, and the return structure (per-model fields + combined view). 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 concise, front-loaded with core function, and every sentence adds unique value (core function, optional key, return shape, use cases). 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?

Despite lacking an output schema, the description fully explains the return values (per-model score, confidence, signals, raw_response, plus combined view). All four parameters are covered with meaningful context. The tool's complexity is well addressed.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds extra meaning: default model is free, _apiKey is passed directly to Anthropic, and context helps disambiguate. This exceeds the schema's descriptions.

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

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

The description clearly states the tool probes LLMs for knowledge about an entity and scores visibility, with specific verb ('probe', 'score') and resource ('LLMs', 'visibility'). It lists concrete use cases (AI-marketing audits, pre-launch brand checks) that distinguish it from sibling tools like 'ask_pipeworx' or 'entity'.

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

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

Guidance is provided on default model (Workers AI) and optional Anthropic probing with API key. Use cases are explicit, but no explicit when-not or alternative tools are mentioned, though the unique functionality makes it self-evident.

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 include readOnlyHint, openWorldHint, idempotentHint, destructiveHint – so bar is high, but description adds value: it discloses that the tool routes to 5,564 tools, fills arguments, and returns structured answers with stable pipeworx:// citation URIs. No contradiction with annotations.

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

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

The description is comprehensive and well-structured: starts with priority instruction, lists example sources, explains routing behavior, provides specific examples, and compares with siblings. Slightly long but each sentence serves a purpose. Front-loaded with key guidance.

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

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

Given no output schema, the description compensates by stating the return type ('structured answer with stable citation URIs') and listing wide-ranging inputs. Context signals show 6 params (1 required), 100% schema coverage – the description is complete enough for an AI agent to decide when and how to invoke.

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

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

Schema coverage is 100% – description doesn't need to detail each param. It provides examples in the schema (e.g., 'What was Apple\'s revenue in 2024?') and mentions the question parameter accepts aliases (query, q, prompt, text, input). However, the description itself adds little beyond 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 clearly states it is a routing tool for questions about current/historical structured data, listing specific domains (SEC, FDA, FRED, etc.) and distinguishing itself from siblings like ask_pipeworx_grounded. The verb 'ask' and resource 'Pipeworx' are clearly defined.

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

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

Explicitly says 'PREFER OVER WEB SEARCH' and provides a comprehensive list of question types and examples. Names specific alternatives (ask_pipeworx_grounded for grounded answers, deep_research for multi-part questions) with when to step up.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, destructiveHint=false, so the safety profile is clear. The description adds valuable context that this is a full working router (not a fallback) and that results are compared against the stable router to decide what merges. It also notes the last candidate was retired on 2026-07-26, increasing transparency. Minor deduction for not explaining what 'candidate routing improvements' entail technically.

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 and front-loaded: first sentence establishes identity and scope, second sentence clarifies current state, third sentence gives usage guidance, fourth sentence explains behavior. Every sentence adds unique value with no redundancy.

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

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

Given the tool's complexity (a beta router with thousands of underlying tools), the description covers purpose, current state, usage vs sibling, and behavioral implications. However, it doesn't explain what happens when a candidate is active (e.g., how routing differs, if response format changes). With no output schema, the description could briefly mention the response shape for completeness.

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

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

Schema coverage is 100%, so the schema already documents all 6 parameters (5 aliases + question). The description adds that the tool accepts the exact same arguments as ask_pipeworx, which reinforces consistency but the schema already covers the aliases. Slight deduction since the description doesn't add new parameter guidance beyond what the schema provides, but the baseline is 3 and this is marginally better due to the cross-reference with ask_pipeworx.

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 with identical functionality (universal router, same 5,564 tools, same arguments, same response shape) but with candidate routing improvements enabled when under test. It distinguishes itself from the stable ask_pipeworx sibling by noting it is the experimental edge for testing new routing.

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

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

The description explicitly says to use it exactly like ask_pipeworx when you want the newest routing. It also clarifies that no candidate is active currently, so it matches ask_pipeworx exactly right now. This provides clear when-to-use guidance relative to the sibling.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds significant behavioral context: it extracts answers strictly from tool results, returns explicit refusal reasons, and mentions the extra LLM call cost. No contradictions.

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

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

The description is well-structured with clear sections: purpose, process, return format, use cases, cost trade-off. It is detailed but not overly verbose; every sentence adds value. Could be slightly trimmed but remains efficient.

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

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

Given the complexity of the tool (question-answering with refusal logic, multiple sources, cost considerations), the description covers all essential aspects: functionality, when to use, return format with refusal reasons, and trade-off with sibling. No output schema, but the description fully explains return values.

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 parameters documented as aliases for 'question'. The description explains that the parameter is a natural language question, which echoes the schema. Baseline of 3 is appropriate as the schema already does the heavy lifting.

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

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

The description clearly states it is a 'Hallucination-resistant answer mode for high-stakes reads' and explains the process of routing, fetching, and extracting answers. It distinguishes itself from the sibling 'ask_pipeworx' by noting the cost of an extra LLM call and the explicit refusal mechanism.

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

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

Explicitly states when to use: 'Use whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts' with specific examples (financial, legal, medical). Also advises preferring 'ask_pipeworx for casual lookups', providing clear guidance on tool selection.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, covering the behavioral profile. The description adds no value beyond these annotations, missing context such as data source or response nature.

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

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

The description is extremely short, but it lacks substantive content. Every sentence should earn its place; the single phrase does not convey enough information for effective tool use.

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

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

Despite having an output schema, the description fails to provide context about the tool's scope, return type, or how the parameter relates to the resource. It is insufficient for a one-parameter tool with sibling alternatives.

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

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

With 0% schema description coverage and no parameter explanation in the description, the single required parameter 'number' is left unexplained. The description does not clarify that it expects an ASN number or its format.

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 'ASN allocation record' is a noun phrase without a verb, leaving ambiguity about the tool's action (e.g., lookup, list, describe). It vaguely identifies the subject but does not clearly state 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?

No usage guidance is provided. The description does not mention when to use this tool versus siblings like 'domain' or 'ip', nor suggests any prerequisites or constraints.

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 extensive behavioral context: fan-out examples per category, response shapes, resolver contract with match confidence, parent event extraction, news fields with fallback info, safety mechanisms for low confidence and closed markets, wide spread handling, and cancellation rule parsing. This far exceeds annotation coverage.

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

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

The description is detailed and informative but verbose. Every sentence adds value, but the wall of text could be more structured with bullet points or sections. Still, it efficiently packs complex information.

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

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

Given complexity (3 params, no output schema, rich behavior), the description covers all necessary aspects: input formats, fan-out logic per category, response fields, match confidence handling, parent events, news error handling, safety, liquidity warnings, and cancellation rules. No gaps remain.

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

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

Schema has 100% coverage of 3 parameters. The description adds significant meaning: market accepts slug, URL, or question text; depth defaults to thorough and explains quick vs thorough; include_raw explains when to use true vs false. Examples clarify usage.

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

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

The description clearly states the tool researches a Polymarket bet by pulling Pipeworx data. It specifies input types (slug, URL, question text) and output (evidence packet + comparison). Distinguishes from siblings like polymarket_arbitrage and polymarket_edges by focusing on research for a specific bet.

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 examples ('should I bet on X', 'what does the data say about Y', 'is there edge in Z'). Mentions safety behaviors like low-confidence short-circuits. Lacks direct comparison to sibling tools for when to use alternatives, but usage 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 are already rich (readOnly, idempotent, openWorld), but description adds significant behavioral context: data sources (SEC EDGAR/XBRL for companies, FAERS for drugs), handling of off-calendar fiscal years, sorting by primary metric, and citation URIs. No contradictions.

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

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

Front-loaded with trigger examples, every sentence adds value. Slightly dense with many details packed into one paragraph, but still efficient and scannable. 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 tool with two parameters, no output schema, and moderate complexity, the description covers behavior, data sources, sorting logic, and even mentions citation URIs. Agent has all necessary information to invoke correctly.

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

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

Schema coverage is 100%, yet description adds meaningful detail: explains what 'type' values map to (company pulls 10-K data, drug pulls FAERS data) and clarifies 'values' format (tickers/CIKs for company, names for drug) plus constraints (2-5 items). Exceeds the schema's minimal 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 a specific verb-resource combination: 'side-by-side comparison of 2–5 companies or drugs'. It includes example query triggers (e.g., 'X vs Y', 'which is bigger') and explicitly differentiates from sibling tools by saying 'ALWAYS PREFER over sequential single-pack lookups'.

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

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

Explicitly provides usage context: when user asks for comparisons (quotes examples), states it replaces '8–15 sequential lookups', and directly advises preference over alternative approaches. No ambiguity on when to use.

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

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

Annotations declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds substantial behavioral context: account requirement, non-web-search nature, parallel decomposition into 5,564 tools, return format (verbatim evidence + confidence + source + fetched_at + stable citation), gaps[] for unanswered facets, contradictions[] for standard/thorough, semantic excerpting, hop field, and expected latency (15-90s). No contradictions with annotations.

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

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

The description is lengthy but every sentence adds necessary information given the tool's complexity (account requirements, data source nature, decomposition mechanics, alternatives, depth behaviors, output expectations, performance). It is front-loaded with critical prerequisites (account). Minor redundancy in explaining depth twice could be trimmed, but overall efficient 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?

The tool is complex (2 params, no output schema, rich annotations, many siblings) and the description covers all essential aspects: purpose, usage boundaries, behavioral details, parameter semantics, output format (including citations and gaps), and performance expectations. It leaves no obvious gap for an AI agent to understand when and how to invoke this tool correctly.

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

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

Schema description coverage is 100% (both parameters documented). The description adds value beyond the schema: it explains the depth enum values in detail (quick=3 facets single hop, standard=3 with gap-recovery+contradictions, thorough=6 iterative+contradictions) and clarifies that the question parameter is for natural language broad/multi-part queries. This goes beyond the schema's minimal 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 it performs grounded multi-source research across 1462 structured data sources, decomposes questions into facets, and returns evidence with citations. It explicitly distinguishes from sibling ask_pipeworx by contrasting scope (broad multi-part vs. single lookup) and data source type (structured catalog vs. live news APIs). The verb 'research' and resource 'Pipeworx structured data' are specific and unambiguous.

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

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

The description provides explicit when-to-use guidance (broad/multi-part questions over structured data) and when-not-to-use (single lookup → ask_pipeworx; breaking current news → ask_pipeworx). It also accounts for authentication tiers: free vs. paid plan for 'thorough' depth, and directs unsigned-in users to ask_pipeworx. This covers both context and exclusions thoroughly.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so no concern about side effects. The description adds valuable behavioral details: returns top-N most relevant tools with curated examples and schemas, with results ready to call directly (no second lookup). No contradictions with annotations.

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

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

The description is front-loaded with the core action and followed by use cases and return details. It is slightly lengthy but every sentence adds value (domains, return format, examples). Could be slightly more streamlined, but remains clear and informative.

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

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

Given the tool's role as a discovery tool with no output schema, the description effectively covers its purpose, usage, input (query aliases), and output structure (tools with names, descriptions, schemas, examples). It also includes example queries. All relevant 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?

Schema description coverage is 100%, with good descriptions for each parameter including aliases. The description does not add significant new meaning beyond the schema, except for mentioning 'top-N' and 'curated examples' which relate to outputs rather than input parameters. 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: finding tools by describing data or task. It lists many specific domains (SEC filings, FDA drugs, etc.) and explains that it returns top-N relevant tools with full schemas, ready to call. This distinguishes it from sibling tools, which are specific domain tools, by positioning itself as a meta-discovery 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?

Explicitly states when to use: 'Use when you need to browse, search, look up, or discover what tools exist for...' and 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' This clearly implies when not to use (when you already know the tool) and gives actionable 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?

Adds valuable behavior beyond annotations: keyless access, authoritative registry source, and interpretation of 'domain not found' as unregistered (subject to registrar checks). This enriches the readOnly/openWorld/idempotent annotations with concrete domain-specific semantics.

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?

Concise and front-loaded: definition first, then key behavioral semantics, then usage examples. No wasted words; every sentence adds distinct value.

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

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

Given the tool's simplicity, full schema coverage, output schema presence, and strong annotations, the description is complete. It covers purpose, authoritative source, not-found semantics, and common use 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?

Input schema already fully describes both parameters ('name' and domain alias) with 100% coverage. The description does not add parameter-level details, but the schema carries the load, 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?

Clearly states it returns a Domain registration record from RDAP, listing specific fields (registrar, dates, nameservers, status). It also defines the 'domain not found' response as meaning unregistered, and explicitly differentiates itself as the modern replacement for WHOIS and authoritative source.

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 an explicit 'PREFER for' list covering common queries (registrar, expiry, ownership, WHOIS, availability), which is strong guidance. It does not explicitly mention when not to use it or direct users to alternatives, but the PREFER phrasing implies selection over other 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 declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. Description adds behavioral context about skipping bootstrap when a base URL is provided, enhancing transparency beyond annotations.

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

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

Two short sentences, front-loaded with main action. No unnecessary words; every sentence adds value.

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

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

Given the simple tool (2 parameters, rich annotations, output schema exists), the description is sufficiently complete. Could add more detail about return values but output schema likely covers that.

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

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

Schema coverage is 0%, so description must compensate. It explains 'handle' and 'base' implicitly through examples and context, but does not fully define them or their constraints.

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

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

Description states it retrieves entity information by handle and can skip bootstrap with a base URL. Purpose is clear but does not differentiate from sibling tools like entity_profile or resolve_entity.

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

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

No explicit guidance on when to use this tool versus alternatives. The hint about skipping bootstrap is only partially helpful and does not provide usage context.

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

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

Annotations already provide readOnlyHint, openWorldHint, etc. Description adds valuable behavioral details: fans across multiple sources, returns specific fields, patents soft-fail until May 2025, and LEI via GLEIF. 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?

Single paragraph around 100 words, front-loaded with examples. Every sentence adds value, though slightly longer than minimal.

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 rich annotations and schema, the description is fully complete: covers purpose, usage, return structure (filings with URIs, fundamentals sorted, patent status, news fallback). No output schema needed.

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 description is detailed. Description adds context that value can be ticker or zero-padded CIK, and names are not supported.

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

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

Description starts with multiple example queries, clearly stating it returns a full cross-source profile of a US public company. It distinguishes from siblings like resolve_entity (name resolution) and compare_entities.

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

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

Explicitly states 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups' for holistic views. Also advises using resolve_entity if only a name is available, and notes patents soft-fail.

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?

While annotations already indicate destructiveHint=true, the description adds contextual detail about what kind of data is affected ('previously stored memory') and why you would delete it ('clear sensitive data'). This adds value beyond the structured annotations.

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

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

Two efficient sentences: first states the action, second provides usage guidance. No wasted words, and the purpose is front-loaded.

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

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

Given the simple tool (1 parameter, no output schema, clear annotations), the description covers purpose, usage context, and relationship to siblings. No additional information is needed.

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 provides 100% coverage with a clear description of the 'key' parameter. The tool description does not add additional parameter-level detail, so baseline score applies.

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

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

Description explicitly states the verb 'Delete' and the resource 'previously stored memory by key'. It clearly distinguishes from sibling tools like 'remember' and 'recall', which are for storing and retrieving memories.

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

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

Provides explicit guidance on when to use the tool: 'when context is stale, the task is done, or you want to clear sensitive data'. Also suggests pairing with 'remember' and 'recall', giving context about alternatives.

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

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

The description details the underlying process (fetches page, extracts data, emits markdown) and output format, adding value beyond the read-only and idempotent annotations. No contradiction.

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

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

Two sentences plus a bullet list, front-loaded with the main action. Every sentence is concise and informative.

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

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

The description covers purpose, usage, behavioral process, output format, and use cases. Sufficient for agent understanding given low complexity and good annotations.

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

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

Schema coverage is 100%, so description does not need to add parameter details. It provides general context but no additional semantics for 'url' or 'max_links'.

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 generates an llms.txt file for AI crawlers, specifying verb, resource, and purpose. It distinguishes from sibling tools which focus on different domains.

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

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

The description lists three explicit use cases (client sites, own projects, auditing competitors) but does not mention when not to use it or 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 mark the tool as read-only, idempotent, and non-destructive. The description adds no behavioral context beyond the noun phrase; it does not explain output format, scope, or any side effects. It merely restates the resource type without disclosing additional 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 extremely terse—a single noun phrase—but this is under-specification rather than effective conciseness. It lacks a complete sentence and any functional language that would help an agent act on it.

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

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

Despite having an output schema and annotations, the description fails to clarify the tool's core purpose. It does not explain how to invoke it or what kind of 'allocation record' is returned, leaving the agent with an incomplete picture of the tool's functionality.

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 full descriptions for both parameters, including the 'address' field and its alias 'ip'. The description itself adds no parameter-specific meaning, so it does not improve upon 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 'IP/netblock allocation record' names a resource type but lacks an action verb. It vaguely indicates the tool deals with IP addresses or netblocks, but does not clearly state what the tool does, leaving it ambiguous whether it is a lookup, search, or other operation.

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

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

No usage guidance is provided. The description gives no indication of when to use this tool versus sibling tools like domain, asn, or nameserver, and does not mention any prerequisites or alternative choices.

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

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

Annotations already provide readOnlyHint, idempotentHint, destructiveHint. The description adds value by specifying the return fields and the default behavior of listing only active subscriptions, which complements the annotations.

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

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

The description is extremely concise with two sentences. Every sentence provides valuable information, and the key details are front-loaded. No wasted words.

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

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

Given the simple tool (1 optional param, no output schema, clear annotations), the description is complete. It lists the return fields, explains when to use it, and the annotations cover safety and idempotency.

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

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

The input schema has 100% coverage with a single optional boolean parameter. The description does not mention the parameter, but the schema already describes it sufficiently. Baseline 3 is appropriate.

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

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

The description clearly states the verb 'List' and the resource 'the caller's active subscriptions', distinguishing it from sibling tools like 'subscribe' and 'unsubscribe'. It is specific and unambiguous.

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

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

The description explicitly advises when to use the tool: 'to review what you're monitoring before adding more or to find an id to cancel'. It does not explicitly state when not to use, but the guidance is sufficient.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. The description adds no behavioral context beyond that, such as what the tool returns or any side effects. Since annotations cover safety, the description's contribution is minimal.

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?

Extremely short but not concise in a helpful way; it is underspecified. The single phrase does not earn its place because it fails to clarify the tool's purpose or usage. Brevity without substance is not valuable.

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

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

Despite having only one parameter and strong annotations, the description is critically incomplete. It does not explain the tool's function, input semantics, or output structure (even though an output schema exists). The minimal description fails to support correct tool selection and 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 0% with no description for the 'host' parameter. The tool description 'Nameserver record' adds no meaning to the parameter—neither format, constraints, nor examples beyond the schema's examples. Requires significant improvement.

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 'Nameserver record' is essentially a tautology, restating the tool name. It fails to specify the action (e.g., query, resolve) or outcome, leaving the agent to guess. It does not distinguish from siblings like domain or ip.

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

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

No guidance on when to use this tool vs alternatives. With many sibling tools (domain, ip, asn, resolve_entity), the agent receives no context to decide which tool is appropriate.

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

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

Annotations are all false, leaving the description to carry the full burden. It discloses that filing without an account returns a claim_token, that passing it back later reads resolution status, that the team reads digests daily, and that it is rate-limited to 5 per identifier per day. This goes well beyond annotations, enriching the agent's understanding of side effects and expectations.

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 carries operational value: purpose, use cases, exclusion criteria, workflow, rate limits, and quota impact. It is front-loaded with the core action and then proceeds logically. Slightly long, but not wasteful.

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 4 parameters (including a nested object), no output schema, and no annotation hints, the description fully compensates: it explains what the tool returns (claim_token), how to use that return value, the expected message format, the scope of feedback (Pipeworx tools only), and operational constraints. An agent has everything needed to invoke and follow up correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explaining the claim_token round-trip workflow, advising against pasting the end-user's prompt, and describing how to frame feedback in terms of Pipeworx tools/packs. It also contextualizes the type enum and context object, raising 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 opens with a specific verb+resource: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It clearly identifies the tool as a feedback channel for Pipeworx tools, distinguishing it from siblings like ask_pipeworx or discover_tools by its unique reporting 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?

The description gives explicit when-to-use criteria for bug, feature, data_gap, and praise, and an explicit exclusion: if the tool came from a different MCP server, file it there instead. It also explains the claim_token workflow for follow-up, rate limits, and quota status, providing complete decision guidance.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false. Description adds useful behavioral details: data derived from CF analytics-engine, no PII, cached 5min-1h, which exceeds annotation requirements.

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

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

Description is compact (3 sentences + bullet points), front-loaded with the main purpose. Could be slightly more structured but every sentence adds value without verbosity.

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, description adequately explains return type (top tools, top packs, total call volume) and caching behavior. All necessary context for a simple read-only tool is present.

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

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

Schema coverage is 100% and description adds value by explaining the trade-off between windows: 'Shorter windows surface what's hot right now; longer windows show steady-state demand.' This enriches the enum definition.

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

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

Description clearly states it returns 'top tools, top packs, and total call volume' with specific verb 'Returns'. It distinguishes itself from sibling tools like 'ask_pipeworx' and 'discover_tools' by focusing on aggregate trending data.

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

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

Explicitly lists three use cases (e.g., 'discovering what data sources are hot', 'confirming a popular tool...'), providing clear context for when to use. Does not mention when not to use, but the use cases sufficiently guide selection.

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

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

Annotations indicate readOnlyHint=true, idempotentHint=true, and no destructiveness. The description adds substantial behavioral detail: it explains monotonicity checks, partition sum checks, semantic anchor, partition filter, fill check against CLOB depth, and conditions for ignoring signals. 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 relatively long but well-structured with clear sections and parenthetical explanations. Every sentence adds value given the tool's complexity. Could be slightly more concise, but overall appropriate.

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

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

Despite lacking an output schema, the description thoroughly explains the response components (opportunities[], partition_check, fill check details) and references sibling tool for custom sizing. It covers both modes, edge cases (placeholder filtering, similarity thresholds), and trade advice. Highly complete.

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

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

Schema coverage is 100% with descriptions. The description adds meaning beyond schema by explaining the format of event slugs and topic seed questions, and the resulting behavior (e.g., single-event vs cross-event scanning). It provides practical examples.

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 two operation modes (event and topic) and a no-arg trending scan. This is specific and differentiates from siblings like polymarket_edges and polymarket_fill_risk.

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

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

The description provides explicit guidance on when to use each mode: event for a specific market slug, topic for cross-event scanning, and no args for trending scan. It also recommends event mode for specific markets. It does not explicitly state when not to use, but the context is clear enough.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds rich behavioral details: explains the three model families (MODEL_DRIVEN, STRUCTURAL_ARBITRAGE, CONCENTRATED_LONGSHOT), caching policy (1h at KV level), diagnostics, and the exclusion of Fed bets from ranking. 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 long but well-structured: it starts with the main purpose, then details each segment, response structure, and knobs. Every sentence adds value, but the length might hinder quick scanning. It is front-loaded and uses clear headings, earning a high score without being perfectly concise.

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

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

Despite no output schema, the description explains the response structure in detail: top-level by_segment with three segments, fed_candidates, fed_note, and _diagnostics. It describes key fields like edge_pp_net, kelly_fraction, liquidity, spread, volume, and the 24h-move warning. It also covers caching, filtering, and diagnostics. For a complex tool with many parameters and no output schema, the description is remarkably complete.

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

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

The input schema covers all 9 parameters with descriptions (100% coverage), so the baseline is 3. The description adds value by grouping parameters into 'tradeable-edge knobs' and explaining their interplay (e.g., min_liquidity and max_spread_pp filter opportunities where edge isn't realizable). It also clarifies that min_kelly applies half-Kelly and min_edge_pp is net of slippage. This goes beyond the schema but schema already does a good job.

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 specifies the verb (scan, return), the resource (Polymarket markets), and the unique angle (disagreement with Pipeworx data). This distinguishes it from siblings like polymarket_arbitrage or polymarket_edge_tracker, which have different focuses.

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

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

The description provides a clear use case: '"what should I bet on today" — agents discover opportunities without paging hundreds of markets.' It explains tradeable-edge knobs and filtering options. However, it does not explicitly state when NOT to use this tool or compare it to alternatives, though the use case is specific enough.

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

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

Annotations already indicate read-only and non-destructive. The description adds significant details: response structure (tracked, expired, snapshot_dates), meaning of decay trend categories, limitations (60-day TTL, daily closes only). 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?

Well-organized but verbose. The information is packed into a single paragraph; could be split for readability. Every sentence adds value, but length may slow scanning.

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?

Extremely thorough given no output schema. Covers return format, trend computation, edge cases (expired opportunities, snapshot gaps), and limitations. Leaves little ambiguity for an agent.

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

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

Schema covers both parameters with descriptions. The description adds defaults and clamping behavior for 'days', and explains 'window' families. Provides extra context beyond the schema.

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

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

Clearly states it provides edge persistence and decay telemetry from daily snapshots, answering the question of how long an edge has existed. The purpose is specific and distinct from siblings, though no explicit differentiation is given.

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?

Describes the scenario where a fresh wide edge differs from an older one, guiding when to use the tool. Includes limits on lookback and snapshot history. Lacks explicit alternatives or when-not-to-use statements.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false. The description adds context beyond annotations: explains it walks the order-book ladder, returns verdicts (clean|degraded|cannot_fill), details per-leg fill info in basket mode, and warns about 'thin_legs' and 'forced_directional_risk'. No contradictions with annotations.

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

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

The description is lengthy but well-structured with clear sections for SINGLE-MARKET and BASKET, and front-loads the core purpose. Every sentence adds necessary information; no redundant phrases. While it could be slightly more concise, the structure compensates, earning a 4.

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

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

Given the tool's complexity (two modes, multiple return fields, and no output schema), the description is thorough: it lists all return fields (top_of_book, vwap_fill_price, slippage_pp, etc.) and explains each mode's behavior. It also covers edge cases (thin_legs, forced_directional_risk). An agent can fully understand when and how to use this tool without external documentation.

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 parameters are documented in the schema. However, the description adds value by providing context: e.g., for `size_usd`, it explains 'Settlement notional — shares per leg, each paying $1 at resolution' in basket mode, and 'max spend on buys, target proceeds on sells' in single-market mode. This extra nuance justifies a score above the baseline of 3.

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

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

The description clearly states the tool's purpose: 'Realizable-vs-theoretical edge check against live CLOB order-book depth.' It distinguishes between single-market and basket modes, and its verb+resource structure ('check') is specific. Sibling names like polymarket_arbitrage and polymarket_edges are mentioned in the usage guidelines, showing differentiation.

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

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

Explicit when-to-use guidance: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500.' It explains why alternative approaches fail ('theoretical overround on thin books is not capturable') and warns of risks ('partial basket fills convert an arb into an unhedged directional position'). The requirement of one of `market` or `event` is stated upfront.

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

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

The description extensively explains behavioral details beyond annotations: compatibility_warning conditions, temporal alignment, skipped cross types, and the fact that mismatched bet shapes mean no arbitrage. No contradiction with annotations (readOnlyHint, openWorldHint, etc.).

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

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

The description is long but every sentence adds value; it front-loads purpose and modes, then details response and safety fields. Slightly verbose due to thoroughness, but 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?

Given no output schema, the description adequately describes the response structure (leg-by-leg prices, spread, safety fields). It covers input modes, behavioral caveats, and interpretation of results, making it complete for effective agent use.

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

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

Schema coverage is 100%, but the description adds context: relationship between topic and explicit parameters, auto-fetching behavior, and that topic overrides are possible. This goes beyond the schema definitions.

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

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

The description clearly states it computes the cross-venue spread between Kalshi and Polymarket for the same resolving question. The verb 'spread' and resource 'cross-venue' are specific, and it distinguishes itself from sibling tools like polymarket_arbitrage by focusing on same-outcome comparisons across venues.

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 two modes (topic shortcuts vs. explicit tickers), provides the list of 10 shortcuts, and gives detailed guidance on when the output is meaningful via safety fields. It warns that most pre-mapped topics currently return compatibility_warning, setting realistic expectations.

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

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

Adds scoping by identifier, which is not in annotations. Annotations already cover read-only and idempotent. No contradiction.

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

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

Three highly informative sentences, front-loaded with primary action, 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?

Covers input, output (implied), scoping, and sibling relationships. Adequate for a simple tool with annotations.

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

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

Schema has 100% coverage with good param description. Description repeats schema info with slight context about storage, but does not significantly enhance.

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?

Clear verb (retrieve/list) and resource (saved values). Explicitly distinguishes from siblings remember and forget.

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

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

States to use for looking up previously saved context without re-deriving. Explicitly pairs with remember and forget for complementary operations.

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

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

The description states that setting 'mark_read:true' flags returned events as read, implying a state mutation. This contradicts the annotation 'readOnlyHint:true', which asserts no state changes. Per scoring rules, a contradiction warrants a score of 1.

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

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

The description is three sentences, front-loaded with the core purpose. It efficiently conveys key details and an alternative endpoint without extraneous words. Minor improvement could be to group return fields more concisely.

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

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

Given no output schema, the description adequately explains return fields (source, citation_uri, raw event payload) and covers the tool's behavior (filtering, polling, alternative access). It lacks details on ordering or pagination but is sufficient for a simple list tool.

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

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

With 100% schema description coverage, the baseline is 3. The description adds value by explaining the effect of 'mark_read' (flags events read so next call shows only newer ones) and mentions filtering by 'type' and 'since', going slightly beyond the schema's dry parameter descriptions.

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

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

The description uses the specific verb 'Pull' and identifies the resource 'fired events from your subscription feed', clearly stating what the tool does. It distinguishes itself from sibling tools like 'list_subscriptions' or 'subscribe' by focusing on events from the feed.

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

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

The description mentions that polling works fine and provides an alternative REST endpoint ('GET registry.pipeworx.io/alerts.json') for scripts and dashboards, giving context on when to use this tool versus the API. However, it does not explicitly state when not to use it or compare to other sibling tools for similar tasks.

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

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

Annotations already indicate readOnlyHint, idempotentHint, and no destructive behavior. Description adds significant context beyond annotations: fans out to multiple data sources, GDELT→GNews fallback, PatentsView soft-fail, and structured return format with citations.

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

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

Description is dense but efficient, front-loaded with concrete query examples. Every sentence adds unique value without redundancy. Format is clean and scannable.

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

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

For a complex tool with multiple data sources, fallback, and soft-fail, the description is highly complete. It covers what the tool does, what sources it uses, how parameters work, and the return structure. Minor gap: no mention of rate limits or error handling, but overall strong.

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

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

Schema coverage is 100%, so baseline is 3. Description adds: explains 'since' accepts ISO date or relative shorthand, suggests '30d' or '1m' for typical monitoring, clarifies 'value' accepts ticker or CIK, and notes 'type' only supports 'company'.

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

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

Description explicitly states it's a change feed for companies covering SEC EDGAR, GDELT/GNews, and USPTO patents. It includes natural language examples that map to the tool's purpose and distinguishes itself from the sibling 'entity_profile' 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?

Provides clear guidance on when to use this tool vs 'entity_profile' (static profile regardless of window). Explains fallback behavior (GDELT→GNews) and soft-fail for PatentsView API. Includes recommended 'since' values like '30d' or '1m'.

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 behavioral details beyond annotations: scoping by identifier, persistence durations (persistent vs 24h). Annotations already indicate idempotent and non-destructive. 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?

Concise paragraph with front-loaded purpose. Each sentence adds value, though could be slightly tighter.

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?

Sufficient for a simple write tool without output schema. Mentions persistence and lifetime, but does not detail return values or error handling.

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

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

Schema covers both parameters with descriptions. The description adds value by explaining key-value pair semantics and providing example key prefixes like 'subject_property'.

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 saves data for reuse, identifies the resource as memory, and distinguishes itself by naming sibling tools recall and forget.

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

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

Provides explicit guidance on when to use ('when you discover something worth carrying forward') with examples, and suggests pairing with recall/forget. Does not explicitly state when not to use.

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

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

Annotations already declare readOnly/idempotent, and the description adds substantial behavioral details: internal cascading lookups, explicit `unresolved` fields, graceful degradation of LEI/FIGI enrichment, and source labeling. This goes far beyond the annotation hints and helps predict behavior under partial failures.

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

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

The description is dense but front-loaded with the core purpose and typical use cases. While it includes multiple example queries and deep detail on company resolution, each sentence contributes useful context, though a few examples could be trimmed for brevity.

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 thoroughly explains expected return contents (CIK, ticker, LEI, FIGI, RxCUI) and edge behaviors like unresolved identifiers and graceful fallback. It covers the tool's complexity and external dependencies, making it complete for an agent to invoke and interpret results.

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

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

The schema covers both parameters with examples, but the description adds additional nuance, such as accepting ISIN for company resolution and explaining the GLEIF ISIN-to-LEI mapping. This supplements the schema without redundancy.

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

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

The description clearly defines the tool as resolving user-spoken names to canonical identifiers, with a specific list of supported types and outputs. It distinguishes itself from siblings by noting it provides inputs other tools require, making the purpose specific and unambiguous.

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

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

Explicitly instructs 'Use FIRST whenever you have a name but need an ID,' providing a clear when-to-use directive. It also gives example queries and explains how different input formats (ticker, CIK, ISIN, name) map to appropriate uses, though it doesn't name specific alternative tools.

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

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

Description reveals it internally probes each entity using ai_visibility_check and ranks results. Annotations already declare read-only, idempotent, open-world; no contradictions. Adds value by explaining the internal process.

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

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

Three sentences, front-loaded with purpose and key functionality. Each sentence earns its place; no filler.

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

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

Given no output schema, description adequately explains return format (ranked list with score, confidence, signal density). Covers all aspects needed 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 has 100% description coverage, so baseline is 3. Description adds minor context like first entity being 'subject' and 'context' disambiguating names, but doesn't significantly expand beyond schema.

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

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

Clearly states the tool compares AI visibility across multiple entities side-by-side, using the verb 'compare' and specifying the resource ('AI visibility'). Distinguishes from sibling ai_visibility_check (single entity) and compare_entities (non-AI).

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

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

Explicitly says it's useful for competitive AI-marketing audits and gives an example question. Implicitly contrasts with ai_visibility_check for single entity, but doesn't explicitly state when not to use.

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

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

The description adds significant behavioral context beyond annotations: it is a composite call that fans out to deps.dev and bundlephobia, describes partial failure behavior (bundlephobia timeout, sources_failed list), and notes the 5-30 second delay for first measurements. Annotations already indicate readOnlyHint, openWorldHint, etc., so description complements them without contradiction.

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

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

The description is somewhat lengthy but each sentence adds value. It is well-structured: starts with overall purpose, then usage, return format, ecosystem scope, and finally failure behavior. A minor cut could be made, but it is 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?

Given the tool's complexity (composite, multiple data sources, partial failures, version defaults, ecosystem constraint), the description covers all essential aspects. It explains the return structure, failure modes, and scope, making it fully self-contained despite lacking an output schema.

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

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

Schema coverage is 100%, but the description adds useful context beyond schema: it mentions that scoped packages (e.g., '@types/node') are accepted for 'package', and that 'version' defaults to latest. This enriches the parameter understanding.

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

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

The description explicitly states it is a composite check for adding npm packages, covering license, advisories, bundle size, and tree-shaking. It clearly distinguishes from sibling tools, none of which are package-analysis tools, making the purpose unambiguous.

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

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

The description provides explicit use cases ('is X safe / popular / small', 'what does adding lodash cost me') and specifies that it is for npm only, directing other ecosystems to alternative tools. This effectively tells the agent when and when not to use it.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false. The description adds rich behavioral details: embedding model (BGE-base-en), chunking strategy (cosine over 500-char overlapping windows), character cap (200K chars with truncation and flagging), and return format (passages with offsets and similarity scores). No contradictions.

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

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

The description is front-loaded with the core purpose and then provides essential details. It's not overly verbose, though the technical details (embedding model, windows) could be slightly condensed. Overall, every sentence adds value.

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

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

Despite no output schema, the description adequately explains return values (top-N passages with character offsets and similarity scores). It also covers the input cap and truncation behavior. Given the tool's complexity and rich annotations, the description is complete.

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

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

Schema coverage is 100% with descriptions for all three parameters. The description echoes these but adds context like the default for limit (5) and examples for query. However, it does not significantly augment the schema's meaning, so baseline 3 is appropriate.

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

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

The description clearly states it performs semantic search inside a fetched record, provides concrete examples (SEC 10-K, article), and explains the benefit of saving context. It distinguishes itself from sibling tools like ask_pipeworx_grounded by emphasizing inline retrieval with offsets.

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

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

Explicitly states when to use: 'Use when the record is too big to cram into the prompt.' It also mentions pairing with ask_pipeworx_grounded. While it doesn't explicitly say when not to use, the guidance is clear and actionable.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the creation nature is expected. Description adds important behavioral context: requires OAuth, phone verification for SMS, 10/day cap, webhook auto-disable after 10 failures. IdempotentHint=true is hinted but not contradicted; description implies each call creates a new subscription. Overall, adds significant value beyond annotations.

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

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

Description is several sentences but well-organized: purpose, prerequisite, supported types with examples, delivery channels. Could be slightly more concise, but every sentence provides necessary information. 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?

Despite no output schema, description states return value (new subscription id). Covers prerequisites, type-specific parameters, delivery options with constraints. Missing details on idempotency behavior or pricing, but for a subscription creation tool, it is reasonably complete.

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

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

Schema coverage is 100% with property descriptions, but the description provides richer examples for each type's params (e.g., sec_8k items, polymarket_edge topic, fred_series series_id). Delivery channels explained with practical constraints (phone verification, signing secret, auto-disable). Adds meaning beyond schema structure.

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

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

Description starts with a specific verb-resource pair: 'Create a proactive monitoring subscription to a live-data event stream.' It clearly returns the subscription id and distinguishes from sibling tools like list_subscriptions and unsubscribe by focusing on creation. The supported types and delivery channels provide additional clarity.

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

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

Explicitly states prerequisite: 'Requires a Pipeworx OAuth account (anonymous + BYO cannot persist subscriptions).' Detailed per-type parameter examples guide proper use. Mentions delivery constraints (phone verification, daily SMS cap). Does not explicitly compare to alternatives like recent_alerts, but the context is clear for a subscription creation 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 (read-only, idempotent, open-world), the description adds that results are drawn from a live catalog of thousands of tools, returning example questions with exact tool+argument shapes. No contradictions with annotations.

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

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

The description is front-loaded with common user queries, structured with typical inputs, return behavior, calling conventions, and usage guidance. Every sentence adds value without redundancy.

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

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

Given the simple input schema and rich annotations, the description fully covers purpose, usage, parameters, and expected output (category-bucketed example questions). No output schema is needed as the return format is qualitatively described.

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 sole parameter 'topic' is fully described in the schema (100% coverage), and the description adds context: listing valid values ('finance', 'pharma', etc.) and explaining the behavior when omitted.

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: it is the onboarding entry point that returns category-bucketed example questions with tool+argument shapes. It distinguishes itself from siblings by being the first tool to use when the agent doesn't know what Pipeworx can do.

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

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

Explicitly states when to use this tool ('FIRST when you do not yet know what Pipeworx can do for you, or to learn how to call the meta-tools') and provides clear guidance on parameter usage (omit for full spread, pass topic to focus).

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 idempotentHint=true and destructiveHint=false. The description adds value by clarifying 'deactivated (not deleted)' and ownership enforcement, which align with and extend the annotations.

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

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

Two sentences, front-loaded with the action, no unnecessary words. Every sentence adds essential information.

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

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

For a simple tool with one parameter and no output schema, the description covers the effect (deactivate), ownership, and parameter origin. It is complete and sufficient for an agent.

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

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

Schema coverage is 100% with a clear description for the 'id' parameter. The tool description mentions it's returned by subscribe, which adds minor context but doesn't significantly enhance the schema's meaning.

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

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

The description clearly states 'Cancel a subscription by id' with a specific verb and resource, and distinguishes from siblings like 'subscribe' and 'list_subscriptions'.

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

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

Explicitly states ownership enforcement ('you can only cancel your own subscriptions') and explains the soft-delete behavior. While it doesn't explicitly exclude scenarios, the context is sufficient for correct use.

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

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

Annotations only declare readOnly/openWorld/idempotent and non-destructive, but the description goes much further: it explains the verdict set, distinguishes could_not_verify (check failed, not evidence) from unsupported (no source), and mentions verification_error{stage,detail}. This is critical behavioral context beyond annotations.

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

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

The description is front-loaded with natural-language triggers and is well-organized, but it is fairly long. Every sentence provides useful information, so it earns its place, though a slightly tighter version could be imagined.

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?

There is no output schema, so the description carries full responsibility for explaining return values. It covers the two execution paths, the verdict list, the citation format, the error semantics, and the benefit of replacing multiple sequential calls. This is complete for a tool of this 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 input schema already covers both parameters, but the description adds real value by explaining tolerance_pct's override behavior, the default cap, and a concrete use case (1–2 for hallucination detection). This goes well beyond the schema descriptions.

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

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

The description uses specific verbs like 'fact check' and 'verify the claim that...' and clearly defines the tool as natural-language claim verification against authoritative sources. It distinguishes itself from sibling research tools by focusing on claim validation and even describes the two routing paths for company-financial vs. other claims.

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

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

The description explicitly states 'Use whenever the agent needs to check whether something a user said is factually correct' and explains when the SEC EDGAR fast path vs. the grounded pipeline applies. However, it does not name alternative tools or explicitly state when not to use it, so it falls short of full guidance.

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