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 mark the tool as read-only, idempotent, and open-world, lowering the burden on the description. The description adds meaningful behavioral context: it routes across thousands of verified sources, fills arguments automatically, and returns a structured answer with stable citation URIs. It does not discuss edge cases like no-match or source limitations, but the annotation coverage already establishes the safety profile.

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 most important guidance — prefer over web search — followed by domain coverage, examples, and alternative routing. It is slightly repetitive around the 'even if web search could also answer it' phrasing and the deep_research guidance, but each section earns its place and the structure supports quick 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?

For a tool with no output schema, the description provides enough context for an agent to select and call it: input style, supported domains, example questions, output format with citation URIs, and sibling routing. It is slightly light on failure behavior and explicit limitations, but the tool's purpose and invocation pattern are substantially 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 documents all six parameters at 100% coverage, and they are all aliases for 'question'. The description reinforces natural-language usage with examples and trigger phrases, but it does not add semantics beyond what the schema already states. A baseline of 3 is appropriate because the schema carries the parameter meaning.

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

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

The description opens with 'PREFER OVER WEB SEARCH' and clearly defines the tool as a router for factual questions about current or historical data across many named domains. It specifies what the tool does — routes to one of 5,798 tools, fills arguments, returns structured answers with pipeworx:// citation URIs — and the examples make its scope concrete.

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 trigger phrases ('what is', 'look up', 'find', 'get the latest', 'how much', 'current') and concrete example questions. It also names alternatives with conditions: deep_research for complex multi-part questions and ask_pipeworx_grounded for deeply grounded answers, while noting that ask_pipeworx already handles breaking news.

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

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

Beyond annotations, the description discloses that this is a full working router with no fallback and that behavior may change live when a candidate improvement is under test. It also states the current test status (no candidate active), letting agents interpret results as equivalent to ask_pipeworx for now. This contextualizes the annotations without contradicting them.

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

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

Four sentences cover purpose, usage, current status, and core behavior with no filler. Each sentence contributes, though the density is slightly high for a quick scan.

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 router tool with a complete schema and safety annotations, the description covers key operational aspects: experimental status, fallback behavior, and relationship to the stable version. It does not spell out the response format beyond 'same response shape,' but that is acceptable given the explicit link to ask_pipeworx.

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 description references the same arguments as ask_pipeworx but adds no parameter-level meaning. The input schema already documents all six parameters with 100% coverage, so the schema does the heavy lifting and no extra semantics are needed.

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

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

The description identifies the tool as a beta version of ask_pipeworx and a universal router with the same 5,798 tools, arguments, and response shape. It distinguishes it from the stable ask_pipeworx by its experimental candidate-routing behavior, though it does not mention ask_pipeworx_grounded as an alternative.

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

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

The description explicitly states when to use this tool: 'when you want the newest routing' and says to use it exactly like ask_pipeworx. It also clarifies that no candidate is active, so the tool currently matches ask_pipeworx exactly, but it does not provide when-not-to-use conditions or contrast with ask_pipeworx_grounded.

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

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

Beyond the annotations (readOnlyHint, openWorldHint, idempotentHint), the description discloses key behavioral traits: refusal behavior with specific refusal_reason values, grounding in verbatim evidence, the extra LLM call cost, and the guarantee not to invent facts. This is substantial and non-redundant value.

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

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

The description is denser than average but every sentence earns its place: purpose, mechanism, output contract, refusal contract, usage scenarios, and cost tradeoff are all packed in without fluff. It is also 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?

The tool has no output schema, so the description correctly compensates by specifying the exact success return shape and refusal error shape. It also covers routing scope, source count, latency tradeoff, and ideal use cases. This is a complete and self-contained definition 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 description coverage is 100%, so the schema already documents the question parameter and its aliases. The description adds no additional parameter-level semantics, which is acceptable given the baseline for high coverage; the single question parameter is straightforward.

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

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

The description clearly identifies the tool as a grounded, hallucination-resistant answer mode and explains the exact mechanism: it routes through the same tool selection as ask_pipeworx but extracts answers using only the returned tool result. It also differentiates itself from the sibling ask_pipeworx by stressing evidence-only answering rather than casual lookup.

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

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

The description explicitly states when to use this tool ('whenever an answer will be quoted, cited, or acted on') and when not to ('prefer ask_pipeworx for casual lookups'). It also provides a concrete cost tradeoff: one extra LLM call versus the standard ask_pipeworx.

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 already declare readOnly/openWorld/idempotent semantics, but the description adds substantial behavioral context: account and payment requirements, gap[] reporting with 'never invented', contradictions[] scans, citation_uri fetchability, semantic excerpting, and expected latency. No contradiction with annotations exists.

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 not bloated: every sentence introduces a distinct capability or constraint. It loses a point for being a single unbroken block of text and for slightly redundant mentions of depth tiers, but no sentence is wasted.

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 only two parameters and no output schema, the description fully covers expected runtime, returned packet fields (evidence, confidence, source, fetched_at, citation_uri, gaps[], contradictions[], hop), authentication/pricing, depth behaviors, and alternative routing. An agent has everything needed to invoke it correctly.

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

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

The input schema covers both parameters 100%, so the baseline is 3. The description goes beyond the schema by explaining the operational meaning of each depth value—'quick=3 (single hop)', 'standard=3 (adds gap-recovery hop + contradictions)', 'thorough=6 (paid, iterative hop)'—and clarifies that the question parameter accepts broad natural language.

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

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

The description states a specific verb and resource: grounded multi-source research across Pipeworx's 1517 structured data sources in one call, explicitly noting it is NOT open-web search. It also details the decomposition and parallel routing behavior, clearly distinguishing it from siblings like ask_pipeworx.

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 names ask_pipeworx as the alternative when not signed in and for single lookups, and states deep_research is best for broad/multi-part questions over structured data. This gives clear when-to-use and when-not-to-use guidance with a specific sibling tool.

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

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

Annotations already declare 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?

Annotations already signal read-only and open-world behavior, and the description adds meaningful detail: 'domain not found' means unregistered (available, subject to registrar checks), the service is keyless and authoritative, and it covers TLDs that IANA bootstrap omits. 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?

One dense paragraph packs definition, negative-result semantics, authority, coverage caveats, and usage triggers without filler. Every clause earns its place, and the emphasis on UNREGISTERED and PREFER is purposeful signal-boosting.

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?

Combined with the output schema and annotations, the description covers purpose, keyless access, authoritative source, TLD coverage gaps, open-world behavior, registry fallback via base, and natural-language triggers. Nothing needed for correct selection and invocation is missing.

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

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

The input schema already describes all three parameters at 100% coverage: name, its alias domain, and base with endpoint guidance. The description adds no parameter-level semantics beyond what the schema provides, so the schema does the heavy lifting.

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

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

States it returns a 'Domain registration record from RDAP' with registrar, registration/expiry dates, nameservers, and status, and explicitly identifies itself as the modern WHOIS replacement. The 'PREFER for' list names concrete queries like 'who is the registrar' and 'when does <domain> expire', distinguishing it from siblings such as nameserver, ip, and asn.

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 conditions for use via 'PREFER for ...' and schema-level guidance for setting 'base' when a TLD is missing from IANA bootstrap. It does not name sibling alternatives or state when not to use it, so it stops short of the full 5 definition.

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?

Discloses substantial behavior beyond the readOnly/openWorld/idempotent hints: USPTO soft-fails until PatentsView reactivates, an empty fda_products section is 'expected, not a failure', an empty section 'is a real no-data, not a bug', private companies return resolved:false with an explicit notes line rather than a bare failure, and type/value are interchangeable. These are precisely the edge cases an agent needs to avoid misreporting. 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 text is long, but the tool's complexity (eight data sources, eight return sections) justifies it, and the structure earns each sentence: query examples first, then the ALWAYS-PREFER directive, then a tree-like walk-through of sources and return fields, ending with parameter and error semantics. Slightly dense, but nothing is 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?

For a tool this complex with no output schema, the description is essentially complete. It explains every return section, the sources_used/sources_failed convention, all accepted value shapes, and both error pathways (private company, empty data). An agent armed with this text plus the schema can call the tool correctly and interpret its output accurately in every documented scenario.

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 nevertheless adds value beyond the schema: it clarifies that 'type' accepts company/ticker 'interchangeably' with identical behavior — a nuance the mutually exclusive enum does not convey — and gives concrete value examples ('AAPL', '0000320193', 'Moderna') plus the EDGAR name-resolution rule and private-company fallback. That pushes 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 multiple concrete query phrasings, then states a specific verb-resource pairing: 'full cross-source profile of a US public company in ONE parallel call.' It explicitly enumerates the eight fan-out sources (SEC EDGAR, XBRL, USPTO, USAspending, FDA, DOL LCA, news, GLEIF) and the exact return sections, distinguishing it from siblings like compare_entities and resolve_entity via the 'full ... profile ... in ONE parallel call' framing.

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

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

Gives an explicit when-to-use directive: 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view.' This tells the agent to reach for this tool over piecemeal lookups. However, it does not name the sibling tools that are NOT this tool (e.g., compare_entities for side-by-side comparison, resolve_entity for pure ticker/CIK resolution) or state when to choose those instead, leaving exclusions to inference.

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, openWorldHint, idempotentHint, and non-destructive behavior. The description adds context beyond those: it specifies the RDAP source, the fact that this is a registry record, and that it includes IP addresses and status. It does not contradict annotations.

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

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

Three sentences with no filler. The definition is front-loaded, the content is scannable, and the two example question formats quickly communicate what the tool is for.

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

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

This is a simple single-resource lookup with strong annotations, a complete input schema, and an output schema present. The description fully communicates what the tool does and why an agent would call it, leaving no critical gap.

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

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

Schema description coverage is 100%, so the schema already documents 'host' and 'base' well. The tool description adds no parameter-level detail and does not need to, given how thorough the schema descriptions are.

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 names a specific resource ('Nameserver (glue) record'), a data source ('RDAP'), and concrete examples like 'ns1.example.com'. It clearly distinguishes itself from siblings like domain or ip by focusing on a nameserver host and its IP addresses/status.

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

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

The description provides clear user-facing use cases: 'what are the IPs behind this nameserver' and 'is this nameserver registered'. It does not explicitly name alternatives or exclusions, but the usage context is unmistakable for this lookup tool.

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

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

Annotations 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?

Annotations already mark the tool as read-only, open-world, idempotent, and non-destructive, so the description focuses on adding behavioral depth. It discloses that legs with unknown metric_type/match_subtype are never paired, that temporal_alignment null does not mean aligned, that pairing is unverified, and that spreads are gross of Kalshi fees. The safety codes (event_subject_mismatch, temporal_mismatch, non_equivalent_bet_shapes, etc.) are all explicitly defined, and the description warns that compatibility_codes can be non-empty even when matched_pairs > 0.

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 heavily structured, using 'TWO MODES', 'RESPONSE', 'SAFETY FIELDS', and code-formatted field names to organize a complex safety surface. Each section earns its place, covering mode selection, response fields, compatibility codes, unclassified-leg handling, fee disclosure, and the rarity of real spreads. It is front-loaded with purpose and readable despite its length, though it is not 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?

With no output schema, the description carries full responsibility for explaining return values, and it does so thoroughly: leg-by-leg prices, top_spreads_pp definition (Kalshi − Polymarket), compatibility fields, per-entry flags, temporal_alignment semantics, and skipped_cross_type/subtype counters. It also covers null/unknown edge cases, the gross-vs-net fee limitation, and the fact that unclassified legs are never paired. Nothing essential for correct invocation or interpretation is missing.

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

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

Schema coverage is 100%, so the schema already documents each parameter with examples and override behavior. The description adds value beyond the schema by explaining that topic and explicit params are two interchangeable modes that execute the same matcher, and by enumerating the exact topic shortcut list. This clarifies how the parameters relate to each other in a way the individual property descriptions do not.

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

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

The first sentence clearly states the tool computes the cross-venue spread between Kalshi and Polymarket for the same resolving question, naming a specific resource and operation. It also outlines two modes (topic shortcuts and explicit ticker+slug) and the response shape. However, it does not explicitly differentiate itself from related siblings like polymarket_arbitrage, polymarket_edges, or polymarket_edge_tracker.

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

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

The description explains when to use each mode: topic for pre-mapped macro shortcuts and explicit kalshi_event_ticker + polymarket_event_slug for custom pairings, noting both modes run the identical matcher. It also provides cautionary guidance that most pre-mapped topics currently return compatibility_warning and that 'pre-mapped ≠ tradeable.' It does not name sibling alternatives or state when to prefer a different tool, so there are no exclusions.

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

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

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 establish read-only, idempotent, and open-world behavior, so the description's additional context is high-value. It discloses graceful degradation of LEI/FIGI enrichment, explicit unresolved identifiers, ambiguous bond candidate behavior, and internal cascading across lookup endpoints — all beyond what annotations provide.

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

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

The description is well-structured with opening examples, a clear usage directive, and organized type-specific paragraphs. It is dense and verbose in places, but the length is justified by the tool's complexity and the need to communicate edge cases like non-equity instruments and ambiguous matches.

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 covers accepted inputs, resolution behavior, identifier sources, fallback behavior, and ambiguous-result handling. An agent has nearly everything needed to invoke the tool correctly and understand what results to expect.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds significant meaning beyond the schema. It enriches the 'value' parameter with detailed formatting guidance, accepted identifier forms, the warning against full noun phrases for bonds, and clarifies type-specific behavior for company and drug.

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

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

The description states a specific verb ('resolve') and resource (user-spoken names to official identifiers) with concrete examples like ticker, CIK, LEI, and RxCUI. It clearly distinguishes itself as the first-step lookup tool for converting names to IDs, which differentiates it from sibling tools like entity and entity_profile.

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

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

The description explicitly says 'Use FIRST whenever you have a name but need an ID,' which gives direct when-to-use guidance. It does not, however, mention when to prefer sibling tools such as entity or entity_profile, so it lacks exclusions or explicit alternatives.

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

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

Description 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.