Arcgis Lancaster

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

Annotations already declare read-only, idempotent, open-world behavior. The description adds important context: default model is free, passing _apiKey probes Anthropic and the user pays directly, and it specifies the per-model return shape. 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?

Three sentences, front-loaded with the core purpose, followed by key operational detail and use cases. No redundant phrases; every sentence contributes.

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, default behavior, cost implication, return format, and use cases. Given the schema and annotations, it's highly complete. Minor omission: no mention of error handling or behavior when the API key is invalid, but that's not essential for selecting/invoking the tool.

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

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

Schema coverage is 100%, so baseline is 3. The description enhances this by noting the default model behavior and the financial implication of using _apiKey (BYO key, direct payment to Anthropic), which the schema doesn't cover.

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 probes one or more LLMs for knowledge about a business/brand/product/topic and scores visibility (0-100) per model. The verb 'Probe' plus the specific scoring output and return format distinguish it from sibling tools like ask_pipeworx or scan_competitor_ai_presence.

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 use cases: 'AI-marketing audits, pre-launch brand checks, competitive monitoring.' It does not mention when not to use or alternatives, but the context is clear given the distinct functionality and the default model/free tier.

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 safety (readOnly, openWorld, idempotent, non-destructive). The description adds valuable behavioral context: routes to 5,529 tools across 1,455 sources, returns pipeworx:// citation URIs, works on every tier, and is a single fast call. It also hints at limitations by suggesting ask_pipeworx_grounded for hallucination-resistant single answers.

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

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

The description is longer than typical but every sentence serves a purpose: it specifies domains, alternatives, example triggers, and when to step up. It is well-structured with clear progression from recommendation to fallback options, though it could be slightly trimmed without losing value.

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

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

Given the tool's broad scope and absence of an output schema, the description is remarkably complete. It explains what the tool does internally, what it returns (structured answers with citations), and how it compares to alternatives. It also covers usage context across tiers and question types, making it self-sufficient for an AI 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%, so the schema fully documents all six parameters (question and five aliases). The description adds no extra parameter-level detail beyond examples, but given the high coverage, the baseline of 3 is appropriate. It does reinforce the use of natural language questions without new semantics.

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

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

The description clearly states the tool's purpose: answering factual questions about real-world data from many domains, routing to thousands of sources, and returning structured answers with citations. It explicitly distinguishes itself from siblings like ask_pipeworx_grounded and deep_research by positioning as the default entry point.

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?

Very explicit guidance is provided: 'PREFER OVER WEB SEARCH' for a wide range of question types, 'START HERE' as the default, and 'Step up only when needed' for ask_pipeworx_grounded and deep_research. It lists trigger phrases and concrete examples, making it clear when to use this tool versus alternatives.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds valuable context beyond this: it is a beta with live candidate routing improvements, currently no active candidate, and is a full working router with no fallback. This explains the experimental nature and potential for behavior changes, which annotations do not capture.

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 tool's identity and then providing current status and usage. Every sentence carries important information, though it is slightly verbose (e.g., the parenthetical date). It is well-structured and avoids redundancy, but could be trimmed slightly.

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

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

The description covers the tool's purpose, beta status, usage, and safety profile (via annotations). It notes the same response shape as ask_pipeworx but does not detail the exact response format, which is a minor gap given there is no output schema. Overall, it is sufficiently complete for a one-parameter router tool.

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

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

Schema coverage is 100% with all six parameters documented as aliases for 'question'. The description adds no further parameter-specific details beyond saying 'same arguments' as ask_pipeworx, which is redundant given the schema. The baseline of 3 is appropriate since the schema fully handles parameter documentation.

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

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

The description clearly identifies the tool as a beta version of ask_pipeworx, a universal router with the same 5,529 tools and arguments. It distinguishes itself from the stable ask_pipeworx by noting it runs candidate routing improvements, making its purpose and scope explicit.

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

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

It explicitly states when to use this tool: "Use it exactly like ask_pipeworx when you want the newest routing." It also references the stable router as a comparison point, implying the alternative for stable use. This provides clear contextual guidance and an implicit when-not-to-use signal.

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

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

The description adds substantial behavioral context beyond the annotations: it details the grounded extraction process, the exact return shape on success and refusal, the list of refusal reasons, and the extra LLM call cost. This fully discloses behavior that annotations (readOnly, idempotent) do not cover.

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

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

The description is dense but every sentence adds value: purpose, routing, extraction guarantee, return formats, use cases, and cost trade-off. It is front-loaded with the core purpose and avoids redundancy. Despite being a single paragraph, it is well-structured and appropriately concise for the tool's complexity.

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

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

The description comprehensively covers the tool's behavior, return values, failure modes, and relationship to the sibling tool. Even without an output schema, the return structure is documented in full, including the refusal reasons. The context is complete for an agent to decide when to use it and what 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?

The input schema already provides 100% coverage of parameters via aliases for 'question'. The description does not add additional parameter-level detail beyond what the schema states, so the baseline of 3 applies. However, the description implies the natural-language question use case, which is consistent with the schema.

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

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

The description clearly states the tool's function: a hallucination-resistant answer mode that extracts answers using only tool result content, with explicit refusals. It distinguishes itself from the sibling ask_pipeworx by noting the extra LLM call and the focus on high-stakes reads, making the purpose unmistakable.

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

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

Explicit when-to-use guidance is provided: 'Use whenever an answer will be quoted, cited, or acted on...' and it names the alternative 'prefer ask_pipeworx for casual lookups.' This directly addresses usage vs. 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 establish readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds extensive behavioral detail: parallel fan-out to category-specific data packs, resolver contract with market_match_confidence and suggestions[], safety short-circuit on low-confidence matches, closed-market blocking status, illiquid wide-spread flag, news fallback mechanics (_fallback_attempted, _fallback_failed_reason, retry_after_sec), and resolution-rule risk with ev_impact. This goes far beyond the annotation safety profile and discloses failure modes and edge-case handling. 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 with uppercase section headers (CLASSIFIERS, FAN-OUT EXAMPLES, RESPONSE SHAPES, RESOLVER CONTRACT, SAFETY, RESOLUTION-RULE RISK) that make it scannable. The first sentence front-loads the core purpose. Every section carries unique operational information without filler, earning its length given the tool's complexity, though it is not concise in absolute terms.

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

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

With no output schema, the description carries the full burden of explaining return values and does so thoroughly: result.market, result.analysis, result.evidence, resolver contract fields, parent_event structure, news fallback fields, and status routes (low_confidence_match, market_closed_or_inactive). It even documents a known arbitrage loss pattern (flat-50¢ void settlements) with ev_impact guidance. This is exceptionally complete for such a complex tool.

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

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

The input schema already provides thorough descriptions for all three parameters: market input formats (slug/URL/question text), depth enum (quick/thorough with explanation), and include_raw with byte-size tradeoffs. Schema description coverage is 100%. Although the description's fan-out examples (e.g., 'BTC bet → coingecko + fred + gdelt+gnews') add color, they don't materially change parameter understanding. Baseline 3 is appropriate given high schema coverage.

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

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

The opening sentence clearly states the tool's function: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies a concrete verb (Research), a resource (a Polymarket bet), and a distinct scope. The description further differentiates the tool by listing targeted use cases ('should I bet on X', 'what does the data say about Y', 'is there edge in Z'), which distinguishes it from sibling tools like polymarket_edges or polymarket_arbitrage.

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

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

The description provides explicit usage guidance: 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z".' It also explains blocking conditions (low-confidence match, closed/inactive markets) that signal when the tool will not return useful analysis. However, it does not name alternative tools or specify when NOT to use this tool in favor of a sibling, so it falls short of a 5.

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

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

Annotations already indicate readOnly, idempotent, and openWorld traits. The description adds substantial context: data sources (SEC EDGAR/XBRL, FAERS, FDA approvals), off-calendar fiscal year handling, metric sorting behavior, and pipeworx:// citation URIs. It fully discloses data provenance and result organization.

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

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

The description is longer than average but front-loaded with trigger phrases and every sentence carries useful information, from usage guidance to data source details and result format. A slight trim could make it more concise, but it remains efficient for the tool's complexity.

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

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

With no output schema, the description thoroughly covers return format (paired data + citation URIs), data sources, edge cases (off-calendar fiscal years), and sorting behavior. It leaves little ambiguity about what the tool does and what it returns, especially combined with rich annotations.

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

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

The schema already covers parameter descriptions 100%, but the description significantly enriches meaning by explaining type-specific data pulls, providing concrete examples (AAPL/MSFT; ozempic/mounjaro), and noting the parallel execution and 2–5 range. It adds practical semantics beyond the enum values.

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

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

The description clearly states the tool performs side-by-side comparison of 2–5 companies or drugs in one parallel call, with explicit trigger phrases like 'Compare X and Y' and 'X vs Y'. It distinguishes itself from sibling tools like entity_profile by focusing on multi-entity comparisons rather than single-entity profiles.

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

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

Explicitly instructs to ALWAYS PREFER this tool over sequential single-pack lookups when comparing entities, and provides concrete query examples that should trigger its use. While no sibling tool names are mentioned, the when-to-use and when-not-to-use guidance is unambiguous.

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

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

Annotations already mark it as read-only, idempotent, and non-destructive. The description adds substantial behavioral context beyond that: it returns a findings packet with verbatim evidence and confidence, explicitly states gaps[] are never invented, guarantees citation_uri is always fetchable, explains contradictions[] in standard/thorough, describes semantic excerpting behavior, and gives latency expectations (15-60s). No contradiction with annotations (annotation_contradiction=false).

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?

Though long, the description is front-loaded with the critical account requirement and is organized in a logical flow: prerequisites, overview, when to use, when not to use, depth semantics, return format, citation behavior, and latency. Every sentence provides distinct value—no filler or redundancy. The length is justified by the tool's complexity.

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

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

With no output schema, the description carries the full burden of explaining return values, and it does so thoroughly: findings packet fields, gaps[], contradictions[], citation_uri resolvability, and semantic excerpting. It also covers prerequisites, alternatives, depth variants, and performance expectations. Combined with 100% parameter schema coverage and read-only/idempotent annotations, there is no significant missing context for an agent to misuse the tool.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds meaningful extra semantics beyond the schema: it ties depth levels to paid plan requirements, explains that standard/thorough perform gap recovery/lead-chasing, notes contradictions[] appear only in those modes, and gives latency information for 'thorough'. The question parameter is enriched with practical examples of ideal use cases. This goes beyond merely restating parameter names.

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

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

The description names a specific workflow ('Grounded multi-source research', 'Decomposes your question into focused facets') and clearly scopes the resource ('1455 STRUCTURED data sources'). It explicitly distinguishes this from ask_pipeworx and other siblings, and states what it is NOT ('NOT open-web search'). This leaves no ambiguity about what the tool does.

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

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

The description provides explicit when-to-use ('Best for broad/multi-part questions over structured data') and when-not-to-use ('For a single lookup use ask_pipeworx', 'For BREAKING... prefer ask_pipeworx'). It also spells out account and tier requirements ('If you are not signed in, use ask_pipeworx instead') and explains which depth level to choose based on gap-recovery needs.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is known. The description adds valuable behavioral context by specifying the return format: top-N most relevant tools with names, descriptions, and full input schemas (with curated examples), and notes that results are ready to call directly, eliminating a second schema lookup.

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

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

The description is three sentences with no fluff. The first sentence front-loads the core purpose, the second gives usage scenarios with a domain list, and the third explains the return value and when to call first. Every sentence earns its place.

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

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

Given the tool is a meta-discovery tool with no output schema, the description adequately covers what the tool returns (top-N tools with schemas and examples), how to use it, and when to invoke it. The safety profile is covered by annotations, and parameters are fully documented in the schema, so nothing critical 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 description coverage is 100% and all parameters, including aliases, are well-documented in the input schema. The description reinforces the natural-language nature of the query and provides examples, but it does not add meaning beyond the schema's existing parameter descriptions. 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 starts with 'Find tools by describing the data or task', which clearly states the tool's verb (find) and resource (tools). It distinguishes itself from siblings by being the meta-discovery tool, and provides a comprehensive list of supported domains (SEC filings, financials, FDA drugs, etc.), making its purpose unmistakable.

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

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

The description gives explicit when-to-use guidance: 'Use when you need to browse, search, look up, or discover what tools exist' and 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' It provides clear context but does not explicitly mention alternatives or exclusions, though the 'FIRST' directive implies it should be used before other tools.

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

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

Annotations already declare read-only/idempotent/non-destructive, and the description adds rich behavioral context: it fans out across multiple sources, returns a specific shape, soft-fails for patents after a sunset date, and uses a GDELT→GNews fallback. It also notes 'ONE parallel call,' signaling performance characteristics. No contradiction with annotations.

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

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

The description is longer than average but densely packs essential information: example queries, source list, return fields, fallbacks, and limitations. Every sentence contributes value, though it could be trimmed slightly without losing clarity.

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 fully enumerates the return payload (cik, company_name, recent_filings, fundamentals, patents, news, LEI) and clarifies edge cases (patent sunset, fallback, name support). It also points to resolve_entity for alternatives, making the tool's context complete for selection and invocation.

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

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

Schema description coverage is 100%, so the description does not need to add much. It reinforces the value format with examples ('AAPL', '0000320193') and the name-not-supported rule, but these are already in the schema. No additional semantic meaning is provided beyond the schema.

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

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

The description clearly states the tool creates a 'full cross-source profile of a US public company in ONE parallel call,' with a specific verb and resource. It distinguishes itself from siblings by explicitly saying to prefer it over chaining single-pack SEC/XBRL/news lookups for holistic queries.

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

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

Provides explicit when-to-use guidance: 'ALWAYS PREFER over chaining single-pack... when the user asks for a holistic view.' It also gives an exclusion and fallback: names are not supported, so 'use resolve_entity first if you only have a name.' This clearly directs the agent to the correct 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 destructiveHint=true and idempotentHint=true, so the description doesn't need to restate that. It adds minor context about clearing 'sensitive data the agent saved earlier', which reinforces the safety implication, but otherwise relies on annotations. No contradiction; score 3 is appropriate as the description adds some value beyond annotations.

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

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

Two sentences, zero fluff. The first sentence is a direct action statement; the second provides usage context and sibling references. Every phrase earns its place, and the description is immediately understandable.

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

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

For a simple delete-by-key tool with one required parameter and no output schema, the description is complete. Annotations cover safety (destructive, idempotent), and the description provides usage context. It could mention idempotency behavior explicitly, but annotations already cover that, so this is sufficient.

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

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

The input schema fully documents the single parameter 'key' with description 'Memory key to delete' (100% coverage). The description does not add additional parameter semantics beyond what the schema provides, so baseline 3 is warranted. The example in the schema further clarifies 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 verb 'Delete' and resource 'previously stored memory by key', making the action specific and unambiguous. It also distinguishes itself from sibling tools by explicitly naming 'remember' and 'recall', showing it is the complementary deletion 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?

Provides explicit when-to-use guidance: 'when context is stale, the task is done, or you want to clear sensitive data'. It also mentions pairing with 'remember and recall', giving context on how it fits into the memory workflow, which helps the agent select it over alternatives.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive behavior. The description adds valuable context beyond this by explaining the internal process (fetches the page, extracts title/description/key links) and the output format (standard llms.txt markdown blob). This provides insight into how the tool behaves without repeating annotation data.

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

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

The description is compact and front-loaded with the main action. Two sentences plus a 'Useful for' list convey all essential information with no filler. Every sentence contributes meaning, and the structure is easy to 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 tool with only two parameters, no output schema, and informative annotations, the description fully covers what the tool does, how it works, and the output format ('single text blob ready to drop at site-root/llms.txt'). It also gives practical use cases, making it complete for an agent to decide when and how to invoke it.

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

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

The input schema already provides 100% coverage for both parameters (url and max_links) with clear descriptions. The tool description does not add additional semantic meaning about the parameters, relying on the schema to carry the detail. Baseline 3 is appropriate for high schema coverage.

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

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

The description uses a specific verb ('Generate') plus resource ('a production-ready llms.txt file for any URL') and clearly states the purpose ('so AI crawlers can index the site cleanly'). It distinguishes itself from siblings like ai_visibility_check or scan_competitor_ai_presence by focusing on producing a standardized file for any URL.

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 ('getting a client's site indexed by AI, drafting llms.txt for your own project, or auditing how an AI crawler would see a competitor'), giving clear context for when to use it. However, it does not mention alternatives or when NOT to use it, so it falls short of the highest bar.

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 this is a safe, read-only, idempotent operation. The description adds what the tool returns but does not disclose potential runtime behavior, error conditions, or network dependencies. This adds some context beyond annotations but not rich behavioral detail, so a 3 fits.

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

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

The description is a single, front-loaded sentence that conveys all essential information without waste. Every part contributes to the meaning, making it highly concise and well-structured.

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

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

For a tool with one parameter, no output schema, and simple metadata retrieval, the description is nearly complete. It lists the key return components, but it could mention the output format or potential limitations. Since the description is the only source for return semantics, a slight deduction is warranted.

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 mentions 'by url' but adds no additional parameter semantics beyond what the schema already provides. No extra value given, so the baseline score stands.

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

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

The description clearly states the tool's function: retrieving a layer's schema from an ArcGIS Feature/Map Service URL, with specific return items (fields, geometry type, record count, capabilities). It is specific and unambiguous, but it does not explicitly distinguish from sibling tools like query_layer, so it falls short of a 5.

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

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

The description implies usage when one needs schema information for an ArcGIS layer, but it provides no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. This is implied rather than stated, so a 3 is appropriate.

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

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

The annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds that the scope is limited to the caller's subscriptions and specifies the return fields (id, type, params, etc.), which is useful but not extremely rich. No side effects are described, but none are needed for a read-only list.

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 only two sentences, front-loads the primary action, and packs the return fields and usage guidance into the second sentence without redundancy. Every word serves a purpose.

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

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

Given the tool's simplicity, rich annotations, and complete schema, the description sufficiently covers the tool's behavior and use context. It would benefit from mentioning the include_inactive parameter, but the schema covers that, so it is a minor gap. Overall it is complete for the intended use.

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

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

The input schema has 1 parameter with 100% coverage, including a description for include_inactive. The tool description does not itself mention this parameter, but the schema fully covers it, so the description adds no additional semantic value beyond the schema.

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

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

The description uses a specific verb 'List' and clarifies the scope as 'the caller's active subscriptions' with a defined resource. It distinguishes itself from sibling write tools like subscribe and unsubscribe by focusing on read-only listing, and lists the exact fields returned.

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

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

It explicitly tells the user when to use it: 'review what you're monitoring before adding more' (which implies before using subscribe) and 'to find an id to cancel' (which leads to unsubscribe). This gives clear context of appropriate use cases.

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

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

The description goes well beyond the basic annotations (readOnlyHint: false, etc.) by disclosing rate limiting (5 per identifier per day), the claim_token workflow for anonymous follow-up, the fact that it's free and doesn't count against quota, and that the team reads digests daily. No annotation contradiction 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 long but each section earns its place: purpose, routing exclusions, claim_token behavior, rate limit, and cost. It is front-loaded with the core purpose and then layers caveats, though it could be tightened slightly without losing essential context.

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

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

Given there is no output schema, the description fully carries the burden of explaining return behavior (claim_token for anonymous reports, later lookup semantics) and operational expectations (daily digest, rate limit, free). It covers parameter semantics, exclusions, and workflow sufficiently for an agent to invoke the tool correctly in varied situations.

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 valuable extra semantics: it explains the claim_token round-trip workflow, asks users not to paste end-user prompts, and describes what type and message should contain. This goes beyond the schema's field-level descriptions without making them redundant.

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

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

The description states a specific verb ('Tell the Pipeworx team') and resource (feedback about broken/missing/needed tools), immediately clarifying what the tool does. It also distinguishes itself from sibling tools like ask_pipeworx or discover_tools by focusing solely on reporting issues, gaps, or praise about Pipeworx tools.

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

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

The description gives explicit when-to-use guidance for bug, feature/data_gap, and praise scenarios, plus a clear when-not-to-use: if the tool came from a different MCP server, file it there instead. It also provides a decision heuristic ('Not sure? Pipeworx tool names are the ones this connection lists').

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, so the safety profile is clear. The description adds meaningful behavioral context beyond annotations: it notes the data is self-aggregating from 'CF analytics-engine', contains no PII, returns only (pack, tool, count), and is cached 5min–1h depending on window. This enriches the agent's understanding of freshness, privacy, and output format.

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 long and efficiently front-loaded: it opens with the core value proposition, then provides usage scenarios, then ends with implementation details. Each sentence earns its place. It is slightly longer than strictly necessary, but the added context on use cases and caching justifies the length.

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

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

For a simple read-only tool with one optional parameter and no output schema, the description covers all essential aspects: what it returns (top tools, packs, call volume), the data source (CF analytics-engine), privacy (no PII), output shape (pack, tool, count), caching behavior, and practical use cases. There are no significant informational gaps.

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 single parameter 'window' has 100% schema description coverage with an enum and a clear explanation of shorter vs longer windows. The tool description only restates the window options without adding new semantics. Since the schema already does the heavy lifting, a baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'What other AI agents are calling on Pipeworx right now' and specifies it returns top tools, top packs, and total call volume over a recent window. This specific verb+resource+outcome distinguishes it from sibling discovery tools like discover_tools or search_datasets, which focus on finding data sources rather than observing agent usage trends.

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 three explicit use cases: discovering hot data sources, confirming a popular tool as canonical, and checking alignment with agent needs. It also explains how window choice affects results. It does not name sibling alternatives or state when not to use the tool, but for a read-only trending lookup, the intended usage is well conveyed.

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

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

Annotations indicate read-only, open-world, idempotent, non-destructive, so the description adds value by describing internal thresholds (3pp, 20% placeholder fraction), the fill check against live CLOB depth, and the semantic anchor (0.30 Jaccard similarity). It also discloses edge-case behavior like returning null arb signal when placeholder fraction is too high, which is not implied by 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 front-loaded with the core purpose and mode selection. All sections (SEMANTIC ANCHOR, PARTITION FILTER, FILL CHECK) are operational instructions that would otherwise be missing, so the length earns its place. The header-based structure aids scanning and the content is dense with 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 having no output schema, the description enumerates the response fields (opportunities[] with gap_pp, suggested_trade, etc., and partition_check object) and explains edge-case returns (null arb signal on placeholder fraction >20%, realizable_edge_pp when fill check fails). This makes the tool safe to invoke without external references.

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?

While the JSON schema provides basic descriptions for event and topic, the tool description adds concrete examples ('fed-decision-may-2026', 'Strait of Hormuz traffic returns to normal'), explains the outcome of each mode, and clarifies that event walks child markets while topic flattens the union. This enriches the parameter semantics far beyond the schema.

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

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

The description clearly states the tool finds arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks, distinguishing it from siblings like polymarket_edges and polymarket_fill_risk. It also names the specific invocation modes (default/event/topic), leaving no ambiguity about what the tool does.

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

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

Explicitly instructs when to call with no args (trending_scan), when to use event (specific market) vs topic (cross-event scan), and refers to polymarket_fill_risk for custom sizing. Also provides a negative condition: do not trade when realizable_edge_pp <= 0, giving clear do's and don'ts.

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

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

Beyond the readOnly/openWorld/idempotent annotations, the description discloses rich behavior: the three response segments and model families, diagnostics for empty segments, 1h KV-level caching keyed on knobs, and the warning that 'your edge may already be in the price'. It also discloses the Fed signal limitation, providing substantial transparency.

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

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

The description is long but well-structured with capitalized section headers (MODEL_DRIVEN, TRADEABLE-EDGE KNOBS, RESPONSE TOP-LEVEL) and front-loaded with the core purpose. It is somewhat more verbose than necessary for a selector, but each section contributes useful details for a complex tool.

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

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

With no output schema, the description fully specifies the response shape (by_segment, fed_candidates/fed_note, _diagnostics) and the meaning of knobs and filters. It also covers limitations and caching, making the tool's behavior predictable and complete for invocation.

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

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

Schema coverage is 100%, so baseline is 3. The description adds significant extra meaning for knobs: explains slippage_pp context (zero fees but bid/ask eats 20-50bp), min_partition_leg_kelly behavior (parent kelly always 0, so min_kelly doesn't apply), and min_liquidity/max_spread_pp as tradeable-edge filters.

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+scope: 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price.' This clearly distinguishes it from siblings like polymarket_arbitrage or polymarket_edge_tracker by focusing on data-disagreement opportunities.

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

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

The description states it is 'Built for "what should I bet on today"' and mentions 'agents discover opportunities without paging hundreds of markets', which provides clear usage context. It doesn't explicitly name alternatives or when-not-to-use, but the sibling list makes alternatives apparent.

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

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

Annotations already declare readOnly/idempotent/non-destructive behavior, so the description meaningfully adds behavioral details beyond that: history is limited by a 60-day snapshot TTL, snapshots only exist on cache-miss days, edge_pp_net is signed by trade direction, and decay uses daily closes rather than intraday data. This is rich, non-obvious behavior disclosed clearly. 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 longer than ideal but is well-structured with ARGS, RESPONSE, and LIMITS sections, and the opening line quickly states the core purpose. Each sentence adds substantive value—response format, edge cases, TTL constraints—so despite its length, it is efficient for a tool with this complexity.

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

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

Given the absence of an output schema, the description fully documents the response structure (tracked[], expired[], snapshot_dates[]), explains field semantics and edge cases (TTL, cache gaps, signed values), and clarifies computation. The tool is complex and the description covers all essential operational aspects, making it effectively self-contained for agent invocation.

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

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

Schema description coverage is 100% and already documents both parameters (days with default/clamp, window with allowed values). The description mostly repeats these details and adds only modest context like 'snapshot family' and the lookback purpose. Since the schema carries the parameter meaning, the description adds marginal value, matching the baseline of 3 for high schema coverage.

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

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

The description clearly defines the tool's purpose as 'edge persistence and decay telemetry' and frames it around a specific question: 'how long has this edge existed and is it shrinking?' It distinguishes itself from the sibling polymarket_edges tool by emphasizing temporal edge decay vs. current edge data, including the concrete contrast between a fresh wide edge and a 3-week-old one.

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

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

The description provides clear context for when to use this tool: when the user needs to understand edge persistence and decay over time, not just current edges. It implies the alternative is polymarket_edges (current snapshot) but does not explicitly state 'use X instead' or describe exclusion scenarios. The guidance is implied through the telemetry framing rather than explicit when-not-to-use instructions.

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

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

Annotations already declare readOnlyHint:true and destructiveHint:false, and the description adds rich behavioral context: it walks the CLOB ladder, returns top-of-book and VWAP fills, computes slippage, and highlights the danger of partial basket fills converting an arb into an unhedged directional position. 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 a long but well-organized block, front-loaded with the purpose and then clearly separated into REQUIRES, SINGLE-MARKET, BASKET, and USE-THIS sections. Some redundancy exists in repeating the 'theoretical overround on thin books is not capturable' point, but the density is justified by the tool's complexity.

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

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

With no output schema, the description compensates by enumerating return fields (top_of_book, vwap_fill_price, slippage_pp, shares_filled, max_fillable_usd, verdict, and comprehensive basket-mode outputs), covering mode-specific behavior, defaults, and the key failure mode. This is a complete picture for a complex, high-risk 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?

Even though schema description coverage is 100%, the description adds essential semantic distinctions across modes: size_usd is 'max spend on buys, target proceeds on sells' in single-market mode but 'settlement notional S (shares per leg)' in basket mode, plus defaults and clamp behavior. This goes far beyond the schema's field descriptions.

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

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

The opening line 'Realizable-vs-theoretical edge check against live CLOB order-book depth' uses a specific verb and resource, clearly distinguishing this fill-risk verification tool from sibling tools like polymarket_arbitrage and polymarket_edges. It also enumerates the specific modes (single-market and basket) and the distinct risk it addresses.

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 it: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500'. It also explains the trade-off between theoretical and realizable edge, making the usage context 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?

The description extensively discloses behavior beyond the readOnly/openWorld/idempotent annotations: it details compatibility_warning conditions, temporal_alignment semantics, and skipped_cross_type/subtype counters. This gives the agent a clear picture of edge cases and failure modes, far exceeding the annotation baseline.

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

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

The description is lengthy but well-structured with bolded labels (TWO MODES, RESPONSE, SAFETY FIELDS). Every sentence conveys essential information for a complex tool; however, it could be tightened slightly without losing 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?

With no output schema, the description compensates by explaining the response structure (leg-by-leg prices, spread in pp, compatibility warnings) and temporal alignment. It fully covers the tool's behavior, making it self-sufficient for an agent to understand inputs, outputs, and failure conditions.

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

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

Schema coverage is 100% with descriptions for all three parameters. The description adds value by explaining the relationship between parameters (e.g., explicit tickers override topic-mapped sides) and listing the exact allowed topic values, which the schema also contains but the description reinforces with mode framing.

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 'Cross-venue spread between Kalshi and Polymarket for the same resolving question,' clearly identifying the tool's function and scope. It distinguishes from sibling tools like polymarket_arbitrage by emphasizing the cross-venue comparison and outcome-equivalence checks.

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

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

The description explains the two operational modes (topic shortcuts vs explicit tickers) and provides guidance on when the tool's spread is meaningful versus when compatibility warnings invalidate it. It lacks explicit references to alternative sibling tools, but the 'pre-mapped ≠ tradeable' warning and mode selection offer solid usage direction.

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

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

Annotations already declare read-only and idempotent behavior. The description adds useful behavioral context by mentioning it returns attribute rows and geometry, and clarifies the SQL-like nature of the where clause.

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

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

The description is concise (three sentences) and front-loaded with the purpose, followed by parameter list and a usage tip. Every sentence contributes meaningfully with no redundancy.

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

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

The description covers purpose, URL source, parameters, return type, and sampling tip. With a rich schema and annotations, it is nearly complete, though it could optionally mention pagination behavior or alternatives like layer_info, but the schema already covers limit/offset.

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 all parameters. The description adds minimal extra value with the sampling tip and the 'SQL-like' qualifier, which is already partially implied by the schema.

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

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

The description clearly states the tool queries an ArcGIS Feature Service / Map Service layer by URL, explicitly referencing the source from search_datasets. It lists parameters and return type, effectively distinguishing it from sibling tools like search_datasets and layer_info.

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

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

Provides clear context that the tool operates on layer URLs from search_datasets and includes a sampling tip (where="1=1" + out_fields="*"). However, it does not explicitly state when not to use this tool or name 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 establish read-only, idempotent, non-destructive behavior. The description adds value by explaining the scope (anonymous IP, BYO key hash, or account ID) and the behavior of omitting the key to list all saved keys. It doesn't contradict any annotations and provides context beyond the structured data.

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

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

Three sentences, front-loaded with the primary action, then use case, then scope and pairing. No wasted words; each sentence adds distinct value.

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

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

For a simple retrieval tool with one optional parameter, the description covers functionality, use case, scope, and relationships to sibling tools. Since there is no output schema, it doesn't need to enumerate return types, but it could have briefly mentioned the return format for a missing key. Overall, it's nearly 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 schema already documents the single 'key' parameter with 100% coverage ('Memory key to retrieve (omit to list all keys)'). The description repeats this and adds a few domain examples (target ticker, address, research notes) but does not add significant meaning beyond the schema, so the baseline of 3 applies.

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

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

The description clearly states a specific verb ('Retrieve') and resource ('a value previously saved via remember'), and explains the alternative behavior of listing keys when the argument is omitted. It distinguishes itself from sibling tools by naming 'remember' and 'forget' as complementary operations, making it obvious this is the memory-read 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?

It provides explicit context on when to use the tool: to look up previously stored context without re-deriving it. It also pairs with remember (save) and forget (delete), which are sibling tools. However, it does not explicitly state a 'when not to use' scenario, so it falls slightly short of a full 5.

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

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

Annotations already declare readOnlyHint and idempotentHint, but the description adds key behavioral context: setting mark_read:true flags events read and affects future calls. It also notes the persistent feed and the raw event payload, providing transparency 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?

The description is three sentences, front-loaded with the core purpose, and every sentence earns its place—purpose, payload details, filtering, mark_read behavior, and the alternate endpoint. No fluff or redundancy.

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

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

Given 5 parameters and no output schema, the description covers all essentials: purpose, output fields, filtering options, mark_read effect, polling suitability, and an alternative REST access point. The schema fills in parameter specifics, making this a complete and actionable description.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaningful detail beyond the schema: a concrete type example ('sec_8k'), clarifies the ISO timestamp format for since, and explains the mark_read side-effect, enhancing 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 opens with 'Pull fired events from your subscription feed,' a specific verb+resource statement that clearly defines the tool's function. It also details the returned payload (source, citation_uri, raw event payload), distinguishing it from sibling tools like list_subscriptions.

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

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

The description gives clear context that this is a read-oriented tool suitable for polling ('Polls work fine') and offers an alternative HTTP endpoint for scripts/dashboards. However, it does not explicitly mention sibling tools or when not to use this tool, missing the full 'when-not/alternatives' 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 declare readOnly, openWorld, idempotent, and non-destructive behavior, and the description adds valuable context beyond that: multi-source fan-out, source-specific fallbacks, rate-limit handling, sunset API soft-fail behavior, and the exact return structure. No contradiction with annotations.

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

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

The description is dense but every sentence carries necessary information—query patterns, source fan-out, date formats, return shape, and alternative tool. It is front-loaded with the most common use cases and avoids filler or repetition.

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

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

Given the tool's complexity (multiple data sources, fallbacks, various date formats, citations), the description covers all essential aspects: what it returns, how sources behave, how to invoke it, and when to use a different tool. No output schema exists, but the description compensates by describing the return structure.

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

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

Even though schema coverage is 100%, the description significantly enriches parameter understanding: it explains that 'since' accepts both ISO dates and relative shorthands with examples, and that 'value' can be a ticker or zero-padded CIK. It also notes the 'type' enum currently only supports 'company', adding clarity beyond the schema.

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

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

The description explicitly states the tool's function: a change feed for a company over a time window, with clear examples of user intents. It also distinguishes itself from the sibling entity_profile by contrasting dynamic changes vs static 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?

Provides explicit 'when to use' guidance via natural language examples, and explicitly says to use entity_profile instead for static profiles. It also documents fallback behavior (GDELT vs GNews) and soft-fail for USPTO, so the agent knows what to expect.

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 mark this as idempotent and non-destructive. The description adds meaningful context beyond annotations: scoping by identifier, persistent memory for authenticated users, 24-hour retention for anonymous sessions, and pairing with recall/forget. 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?

Description is four sentences, front-loaded with the primary action, followed by usage context, technical details, and sibling pairing. No wasted 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?

Covers purpose, usage, persistence/expiry, scoping, and relationship to sibling tools. Though there is no output schema, this is a simple save operation; the absence of return-value details is not a gap given the completeness of the rest.

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

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

Schema description coverage is 100%: both 'key' and 'value' have detailed descriptions with examples. The description does not add parameter-specific semantics beyond what the schema already provides, so a 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 explicitly states the action ('Save data the agent will need to reuse later') with a specific resource ('key-value pair scoped by your identifier'). It also differentiates from sibling tools by mentioning 'Pair with recall to retrieve later, forget to delete.'

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

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

Provides explicit when-to-use guidance: 'Use when you discover something worth carrying forward' with concrete examples (resolved ticker, target address, user preference, research subject). It also mentions alternatives (recall/forget) and clarifies persistence differences between authenticated and anonymous sessions.

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

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

Beyond the annotations (readOnly, idempotent), the description discloses that each call cascades through several internal lookup endpoints, that LEI/FIGI enrichment degrades gracefully when GLEIF or OpenFIGI is unavailable, and that unresolved identifiers are explicitly listed under `unresolved` rather than silently omitted. It also notes that identifiers are labeled with their source, giving the agent insight into data provenance and reliability.

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

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

The description is front-loaded with example queries and a clear purpose statement, followed by well-separated supported-type details and a degradation caveat. While somewhat long, every sentence earns its place given the tool's complexity. A slightly tighter rewrite could condense the opening examples, but the structure is logical 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?

With no output schema, the description fully carries the burden of explaining return values: for company it lists CIK, ticker, company_name, LEI, FIGI, ownership, and source labeling; for drug it lists RxCUI, ingredient, brand, and a citation link. It also covers failure modes (unresolved list, graceful degradation) and explicitly says what is omitted, making the tool's behavior highly predictable.

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 parameter basics well (100% coverage), so baseline is 3. The description adds meaningful conditionality: for company, it explains that FIGI resolves only 'when a ticker is implied' and LEI includes ownership 'when the LEI resolves,' linking input value to output richness. It also clarifies that 'value' accepts ticker, CIK, or name, reinforcing the schema examples while adding context about cross-source behavior.

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

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

The description opens with concrete user utterances and states the core function: resolve a user-spoken NAME to canonical/official identifiers. It enumerates supported entity types (company, drug) and specific output fields (CIK, ticker, LEI, FIGI, RxCUI), clearly distinguishing itself from sibling tools that consume these identifiers. The verb 'resolve' plus the explicit resource ('name to identifiers') leaves no ambiguity.

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

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

The description gives an explicit directive: 'Use FIRST whenever you have a name but need an ID.' It further positions the tool as a replacement for 2-3 manual lookups, and its mention of 'other tools require as input' clarifies when to use this tool versus downstream consumers. It also sets expectations about graceful degradation if upstream sources fail, which helps agents decide when to trust results.

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 read-only/idempotent annotations, the description discloses that it internally calls ai_visibility_check, ranks results, and returns score/confidence/signal density. No contradictions with annotations. This adds meaningful behavioral context.

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

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

Three sentences, front-loaded with the core action, each sentence earns its place: action, internal mechanism, use case, and output. No redundancy or fluff.

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

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

Given the moderate complexity, 4 parameters, and no output schema, the description sufficiently covers purpose, behavior, use case, and return fields. It also references the underlying probe tool, making it complete for an agent to invoke correctly.

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

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

Schema description coverage is 100% and all parameters are well-documented in the schema. The description adds little to parameter understanding (mostly reiterating the entities concept), so the baseline of 3 is appropriate.

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

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

The description states the tool compares AI visibility across multiple entities side-by-side, using specific verbs and resources. It distinctively positions itself against sibling tools like ai_visibility_check by explicitly saying it probes each entity with ai_visibility_check and ranks by score.

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

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

It clearly states the use case ('competitive AI-marketing audits') and implies when to use (when comparing multiple entities) but does not explicitly exclude alternatives or name when-not-to-use. This is clear context without explicit exclusions.

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

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

Annotations already mark read-only, idempotent, open-world. Description adds valuable behavioral context: partial failures degrade gracefully, bundlephobia's first measurement can take 5-30s, sources_failed will list timeouts, and the tool fans out to multiple APIs. This goes beyond the structured annotations and informs the agent about non-obvious timing and failure 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?

Description is dense but well-organized: core purpose first, then usage triggers, then output summary, then limitations. Every sentence adds information; no filler. Length is justified by the tool's composite nature.

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

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

No output schema exists, so description must explain return fields and does so comprehensively, listing the summary block fields, per-advisory detail, links, and alternative versions. It also covers edge cases (timeout, partial failure). Given the tool's complexity, the description is complete and actionable.

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 doesn't need to explain parameters. The description adds context about the overall purpose but not new parameter-level detail. The 'version' field's default behavior is already in the schema. 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 identifies the tool as a composite check for npm package evaluation, specifying the exact question it answers ('should I add this npm package') and naming the two data sources (deps.dev and bundlephobia). It distinguishes this tool from siblings by focusing on a niche, multi-source scan rather than a generic search or entity 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?

Explicitly states when to use: whenever an agent asks about safety, popularity, size, or cost of an npm package. Also provides an exclusion and alternative: 'NPM ecosystem only in v1; PyPI / Maven / Cargo / Go fall under deps.dev:version directly.' This tells the agent exactly when not to use this tool.

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

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

Annotations already convey read-only, open-world, idempotent, and non-destructive behavior, so the description does not need to restate safety. It adds transparency by specifying the return payload (name, summary, record_count, owner/org, Feature Service URL) and the intended downstream usage, which goes beyond what annotations capture.

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

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

The description is two sentences that are front-loaded with the main purpose, followed by return value details and a workflow hint. Every sentence carries useful information, and there is no redundancy or fluff.

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

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

With no output schema, the description adequately explains what the tool returns and how to use the result, covering the essential context for the agent. It also provides examples and the scope of data (Lancaster County GIS), making the tool's behavior complete for practical use.

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

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

The input schema provides 100% parameter descriptions for query, limit, and org_id, so the baseline is appropriate. The description does not add extra detail about parameter syntax or formatting beyond the schema, but it reinforces the role of query in keyword search.

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 searches Lancaster County GIS open geospatial datasets by keyword, with specific examples (parcels, addresses, zoning). It distinguishes itself by mentioning the return of Feature Service URLs and the passing of those to query_layer/layer_info, which contrasts with sibling tools that operate on specific layers.

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

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

The description gives a clear context for when to use the tool: to discover datasets by keyword before querying their data. It implies alternatives by directing the user to pass the resulting URL to query_layer or layer_info, but it does not explicitly state when not to use this tool or name direct alternatives like search_within.

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 adds significant context beyond annotations: uses BGE-base-en embeddings, cosine similarity, 500-char overlapping windows, 200K character cap with truncation flag, and return payload details. This complements the readOnlyHint/idempotentHint 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?

Description is longer than ideal but every sentence carries useful information: core function, use case, pairing advice, technical details, and limits. Structured in a logical flow, but slightly dense.

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

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

With no output schema, the description properly explains return values (top-N passages with offsets and scores) and edge cases (truncation flag). Given the tool's complexity, this is fully sufficient for an agent to use correctly.

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

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

Schema coverage is 100% with good parameter descriptions, and the description enhances meaning by providing concrete query examples, default limit, and the truncation behavior tied to the text parameter. This adds value beyond the schema.

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

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

The description clearly states the tool performs semantic search inside a fetched record, with specific inputs (text, query) and outputs (passages with offsets and scores). It explicitly references sibling? not directly but contrasts with entire document retrieval and pairs with ask_pipeworx_grounded, distinguishing its role.

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

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

Provides explicit when-to-use guidance: when the record is too big to fit in the prompt, saving context. It names an alternative (ask_pipeworx_grounded) and explains the pairing pattern, offering clear contextual direction.

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 readOnly=false and idempotent=true, the description adds valuable behavioral details: the OAuth account requirement, phone verification for SMS, the 10/day SMS cap, webhook auto-disable after 10 failures, and that the webhook signing secret is returned only once. These disclosures go beyond the structured annotations and provide necessary context for safe usage.

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

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

The description is dense but well-organized: purpose, return value, requirement, types, and delivery channels. It front-loads the core function and each sentence adds relevant detail. It is slightly lengthy but avoids redundancy with the schema for the most part, earning a high score.

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 (nested objects, five types, multiple delivery channels), the description covers the main aspects: the subscription id return, feed retrieval, and two of the three delivery channels. However, it omits mention of the patent_grant and clinical_trial subscription types, which are only in the schema. Since the schema fills this gap, the description is mostly complete but not fully self-contained.

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

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

Schema description coverage is 100%, so the baseline is 3. The description repeats some examples already present in the schema (e.g., sec_8k with items, polymarket_edge with topic) but does not add significant new meaning beyond the schema. It omits the patent_grant and clinical_trial types, which are documented in the schema, so it neither enhances nor detracts much from the schema's parameter documentation.

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 'Create a proactive monitoring subscription to a live-data event stream,' which is a specific verb and resource. It clearly distinguishes this tool from sibling tools like list_subscriptions and unsubscribe by focusing on creation. It also outlines supported types and delivery channels, making the tool's function unmistakable.

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

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

The description gives clear context on when to use this tool, including the prerequisite of a Pipeworx OAuth account and the fact that anonymous/BYO cannot persist subscriptions. It also explains delivery mechanisms and how to retrieve alerts (recent_alerts or GET alerts.json). However, it does not explicitly state alternatives or when not to use it, such as for one-time queries, so it falls short of fully explicit 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?

The description adds substantial behavioral detail beyond the annotations: it reveals the return format (category-bucketed example questions with exact tool + argument shape), the source ('drawn from the live catalog of thousands of tools'), and the no-argument vs. topic-filtered call modes. This goes well beyond the read-only/idempotent hints and provides transparency about what the agent will receive.

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

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

The description is longer than average but every sentence contributes useful information: question phrasings, return content, category list, call variants, and usage guidance. It is front-loaded with the tool's purpose and ends with actionable when-to-use advice, though a bit dense in a single paragraph.

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

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

Given the tool's simplicity (one optional parameter, no output schema), the description is complete: it explains what the tool returns, how to call it with and without the topic argument, what categories exist, and when to use it. The lack of an output schema is fully compensated by the clear description of return content.

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 the schema already describes the topic parameter, its allowed values, and the omit-for-cross-category behavior. The description adds a few example values ('finance', 'pharma', 'betting') and repeats the call behavior, but this is marginal beyond the schema. Baseline of 3 is appropriate.

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

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

The description clearly identifies the tool as an onboarding entry point that returns category-bucketed example questions with the exact tool and argument shape to answer them. It uses a specific verb ('suggest questions') and resource ('Pipeworx capabilities'), and distinguishes itself from siblings by positioning as the first thing to call when you don'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?

The description explicitly states when to use the tool: 'Use this FIRST when you do not yet know what Pipeworx can do for you, or to learn how to call the meta-tools.' It also explains the optional topic parameter for focusing. However, it does not explicitly contrast with alternatives like discover_tools or explain when NOT to use this tool, so it falls short of a 5.

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

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

The description discloses key behavioral traits beyond annotations: ownership enforcement ('you can only cancel your own subscriptions') and the deactivation (not deletion) behavior with historical events remaining available. This adds significant value beyond the readOnlyHint=false and destructiveHint=false 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 three short sentences, each providing essential information: the main action, ownership constraint, and behavioral nuance. No filler or redundant content.

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 single-parameter schema, annotations, and lack of output schema, the description is complete. It explains the side effect (non-deletion) and points to recent_alerts for historical visibility, covering all necessary context.

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

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

Schema coverage is 100% and the parameter 'id' is fully described in the schema as 'Subscription id (uuid) returned by subscribe.' The description adds no further parameter details, so the baseline score of 3 applies.

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

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

The description opens with a specific verb and resource: 'Cancel a subscription by id.' This clearly states the tool's function and distinguishes it 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?

The description provides clear context for when to use the tool—to cancel a subscription—and notes ownership constraints. However, it does not explicitly mention alternatives or when not to use it, such as referencing list_subscriptions to find the id.

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

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

The description discloses crucial behavioral details beyond annotations: the verdict types, the distinction between 'could_not_verify' (check did not happen) and 'unsupported' (no source), the presence of verification_error, and the evidence/citation format. This significantly enhances the agent's ability to handle edge cases, exceeding the low bar set by the read-only and idempotent 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 reasonably long but packed with information. It is front-loaded with usage examples and critical caveats (e.g., could_not_verify semantics). While it could be more structured with bullet points, every sentence serves a purpose for a complex tool, so it earns 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?

Despite lacking an output schema, the description fully explains return values (verdicts, actual value, reasoning, citation), error semantics, routing logic, and the tool's efficiency gain. It covers all necessary context for an agent to select and use the tool correctly.

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

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

Schema coverage is 100% with both parameters described, so baseline is 3. The description adds value by explaining that tolerance_pct overrides the implied tolerance and gives a specific use case (hallucination detection), which goes beyond the schema text. This pushes it to a 4.

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

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

The description clearly states the tool's purpose: natural-language claim verification against authoritative sources. It includes specific verb/resource ('verify the claim') and differentiates from siblings by emphasizing it handles claim verification with a grounded pipeline, replacing multiple sequential calls. The examples make it 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?

It explicitly states when to use ('Use whenever the agent needs to check whether something a user said is factually correct') and explains the internal routing for company-financial vs. other claims. However, it does not explicitly state when not to use or name alternative sibling tools, so it falls short of a 5.

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