Guild Wars 2

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

Annotations already declare the tool as read-only, idempotent, and non-destructive, which covers key behavioral traits. The description adds value by listing the specific fields returned (name, description, category, tiers, points, prerequisites), providing more detail than the annotations alone. No contradictions are present.

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 efficiently conveys the tool's purpose and return fields. It wastes no words, though a slight restructuring (e.g., separating modes) could improve readability but is not necessary.

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 (4 optional parameters, no enums, output schema exists), the description covers the main usage modes and return values. Minor gaps remain for 'lang' and 'page_size' semantics, but overall it is sufficiently complete for an agent to use the tool correctly.

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

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

The input schema has 0% description coverage, so the description must compensate. It explains that 'ids' takes comma-separated IDs and that 'page' is for pagination, but it does not clarify the purpose of 'lang' or 'page_size'. This leaves two parameters undocumented in both schema and description, resulting in a partial explanation only.

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 specifies the action ('Fetch') and resource ('Guild Wars 2 achievement details'), and outlines two modes of operation (by IDs or by page). However, it does not explicitly distinguish this tool from sibling tools that also retrieve game data (e.g., items, currencies), which prevents a score of 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 when to use the tool (to fetch achievements by either IDs or page), but it provides no explicit guidance on when to choose one mode over the other, nor does it mention alternatives or situations where this tool should not be used. This is adequate but lacks clear direction for selection among sibling tools.

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

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

The description adds significant behavioral detail beyond annotations: default model (Workers AI Llama-3.3-70b), cost implications of Anthropic probe (BYO key), and return structure (per-model score, confidence, signals, raw_response + combined view). All annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false) are consistent.

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, 120 words, front-loaded with core action. Every sentence is substantive: main function, default model with cost implications, return structure, and use cases. No unnecessary words.

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

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

Given 4 parameters and no output schema, the description adequately covers what the tool does, how to call it, what it returns, and when to use it. The annotations cover safety aspects, making the definition complete for tool 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?

With 100% schema description coverage, baseline is 3. The description adds value by explaining the free vs paid models and the purpose of context parameter, providing useful usage guidance beyond the schema.

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

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

The description clearly states the tool's purpose: probing LLMs for knowledge about an entity and scoring visibility per model. It uses a specific verb-resource combination and distinguishes from sibling tools like 'scan_competitor_ai_presence' by focusing on brand visibility 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 provides clear usage context: AI-marketing audits, pre-launch brand checks, competitive monitoring. It mentions default model and optional Anthropic probe. While it doesn't explicitly list alternatives or when not to use, the context is sufficient for most agents.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, and the description adds valuable context: it routes to tools, fills arguments, returns stable citation URIs, and works on every tier. However, it does not disclose potential limitations like latency or error behavior, but for a read-only tool with strong annotations, the added detail is sufficient.

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

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

The description is front-loaded with the most important instruction ('PREFER OVER WEB SEARCH') and then efficiently covers use cases, alternatives, examples, and caveats. Every sentence contributes meaning without redundancy. Though long, the density of actionable guidance 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 complex routing tool, the description is remarkably complete: it specifies the types of questions (factual, real-world entities, events, numbers), provides examples, gives explicit alternative tools, and notes that it returns structured answers with citations. There is no output schema, but the description covers what to expect adequately.

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 adds example questions and notes it accepts natural language, but does not go beyond the schema's parameter descriptions, which already define the 'question' parameter and its aliases. No additional parameter semantics are provided.

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

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

The description clearly states that ask_pipeworx routes questions to one of 5,529 tools across 1,455 verified sources and returns structured answers with citations. It distinguishes itself from siblings by name (ask_pipeworx_grounded, deep_research) and explicitly says it is the default entry point, making the purpose unmistakable.

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

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

The description starts with 'PREFER OVER WEB SEARCH' and enumerates specific use cases (SEC filings, FDA, FRED/BLS, etc.). It provides explicit when-to-use and when-not-to-use guidance by naming alternatives: 'for a hallucination-resistant single answer use ask_pipeworx_grounded; for a broad/multi-part question use deep_research'. It also includes example queries.

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 adds critical behavioral context: it may have candidate routing improvements enabled live, is currently identical to ask_pipeworx due to no active candidate, and 'falls back to nothing' meaning it is fully functional. This goes beyond the annotations' 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 four sentences of dense, useful information. It is slightly verbose with details like the retirement date of the last candidate, but every sentence contributes to understanding the tool's state and usage. It could be tightened without losing core 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 annotations cover safety and idempotency, and the schema fully documents parameters, the description completes the picture by explaining the beta relationship to ask_pipeworx, current behavioral state, and evaluation purpose. No output schema exists, but the reference to 'same response shape' as ask_pipeworx is sufficient in 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% with all six parameters documented as aliases for 'question.' The description adds no parameter-specific meaning beyond saying 'same arguments' as ask_pipeworx, which is already covered by the schema. This meets the baseline of 3 but does not exceed it.

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

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

The description clearly states this is the beta version of ask_pipeworx, an identical universal router with the same set of tools and arguments. It distinguishes itself from the stable router by its experimental nature and current equivalence, making its purpose unambiguous.

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

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

Explicitly instructs to 'Use it exactly like ask_pipeworx when you want the newest routing,' providing a clear condition for use. It also clarifies that results are compared against the stable router, implying a testing/evaluation context, and notes that it is a full working router, not a fallback.

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

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

Annotations already declare readOnly, idempotent, and openWorld hints, but the description adds crucial behavioral context beyond that: it explains the hallucination-resistance mechanism (uses only tool result), details the exact return structure including evidence as verbatim quote, and lists all refusal_reason enums. It also discloses the cost tradeoff of one extra LLM call. 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 compact yet information-dense. Every sentence serves a purpose: starting with the mode, then routing mechanism, return format, usage context, and cost/alternative tradeoff. It is logically structured and front-loaded with the most critical identifier ('Hallucination-resistant answer mode'), making it 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?

Despite having no output schema, the description fully documents the return value structure (both success and refusal cases), explains when to use it, its relationship to sibling tools, and its performance cost. For a read-only query tool with a single question parameter, this is complete context for correct invocation.

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

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

Schema coverage is 100% for the single question parameter and its five aliases, so the baseline is 3. The description does not add parameter-specific semantics beyond what the schema already states, but that is acceptable because the question parameter is self-explanatory; no additional meaning is needed.

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

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

The description clearly identifies the tool as a hallucination-resistant answer mode for high-stakes reads, explicitly distinguishing it from ask_pipeworx by its grounded extraction and refusal behavior. The verb 'extracts' and resource description are specific, and the mode is contextualized within the same routing as ask_pipeworx but with a critical safety difference.

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

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

The description provides explicit when-to-use guidance: for answers that will be quoted, cited, or acted on, where invented facts are unacceptable. It names alternatives (prefer ask_pipeworx for casual lookups) and gives concrete examples (financial, legal, medical, public statements). This is exemplary clarity for selection.

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

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

Annotations declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description goes far beyond this, detailing market resolution, classification, fan-out, response shapes, resolver contract, various market states (low-confidence, closed, wide spread), resolution-rule risk, and news fallback behavior. This is exemplary transparency for a complex tool.

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 verbose but well-structured with labeled sections (CLASSIFIERS, FAN-OUT EXAMPLES, RESPONSE SHAPES, etc.). It is front-loaded with the main purpose and then provides necessary details. While lengthy, every sentence adds value given the tool's complexity.

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

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

Given the tool's complexity (multiple classifiers, fan-out scenarios, response shapes, edge cases), the description is remarkably complete. Since there is no output schema, the description thoroughly explains return values, including market match confidence, parent event extraction, news fields, and safety mechanisms. This fully compensates for the lack of output schema.

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

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

Schema coverage is 100% with descriptions for all three parameters (market, depth, include_raw). The description adds significant meaning beyond the schema, such as input format variations for market, default value and behavior for depth, and when to use include_raw. This adds context that helps an agent use the parameters correctly.

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

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

The description clearly states the tool's purpose: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies the resource (Polymarket bet) and the action (research/data retrieval). However, it does not explicitly differentiate from sibling tools like polymarket_edges or polymarket_arbitrage, though the detailed behavior implies uniqueness.

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: 'Use for should I bet on X, what does the data say about Y, or is there edge in Z.' This gives clear context for when to use the tool. It does not explicitly state when not to use it or list alternatives, but the use cases are specific enough.

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

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

Annotations already indicate readOnlyHint, idempotentHint, openWorldHint, and non-destructive nature. The description adds no behavioral details such as data sources, staleness, or restrictions, failing to leverage the opportunity to elaborate.

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

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

The description is extremely terse—only three words. While not verbose, it sacrifices necessary detail for brevity, making it under-informative rather than efficiently concise.

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

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

With a straightforward tool (no params, output schema present), the description could still be more complete by stating what 'build' refers to (e.g., application, Docker image). It currently lacks context for comprehensive understanding.

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?

There are no parameters, and schema coverage is 100% (empty). The description is adequate given that no parameter documentation is needed, though it could hint at what kind of build ID (e.g., numeric, string) is returned.

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 'Current build id.' is a noun phrase lacking a verb, making it unclear whether the tool retrieves, generates, or displays a build ID. It adds minimal clarity beyond the tool name itself.

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

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

No guidance is provided on when to use this tool versus alternatives like 'compare_entities' or 'items'. The description offers no context for appropriate scenarios.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so safety is covered. The description adds behavioral context by explaining that the tool returns all depth levels and what data each tier contains, going beyond the structured annotation fields.

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 sentence that packs essential information about purpose and output. It is somewhat dense, but every phrase contributes value and it is easy to parse. It is not overlong, earning a solid 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?

With one parameter, full schema coverage, and an output schema present, the description is largely complete. It explains the return semantics and use case. Minor gaps exist (e.g., whether the ids parameter is required), but these are addressed by the schema and annotations.

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

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

Schema description coverage is 100%, with the 'ids' parameter fully described in the schema. The description only reiterates that the IDs are numeric, adding no significant meaning beyond the schema, 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 uses a specific verb ('returns') and a specific resource ('Guild Wars 2 Trading Post order-book depth'), clearly distinguishing it from sibling tools like commerce_prices. It details what is returned (every standing buy and sell listing tier with price, count, and quantity), making the purpose unmistakable.

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

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

The description clearly implies when to use the tool: when you need order-book depth for item IDs rather than just a current price. It does not explicitly compare to alternatives or state when not to use, but the context is unambiguous enough for an agent to select it appropriately.

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, but the description adds valuable context by specifying the raw output format (copper unit_price, open quantity per side) and the numeric-ID requirement. This goes beyond the annotations, though it doesn't discuss error handling or rate limits.

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

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

The description is two sentences: the first establishes purpose and output, the second provides an alternative. It is front-loaded, economical, and contains no redundant or filler text.

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

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

Given the output schema exists and annotations cover safety, the description fully covers purpose, usage, and output format for a simple one-parameter tool. No significant gaps remain.

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

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

Schema coverage is 100%: the ids parameter is described as 'Comma-separated numeric item IDs.' The description only reinforces 'many numeric item IDs,' adding no new semantic detail beyond what the schema already provides, so baseline 3 is appropriate.

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

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

The description opens with a specific action: 'Bulk Guild Wars 2 Trading Post buy/sell quotes for many numeric item IDs at once.' It clearly names the resource (Trading Post quotes) and distinguishes itself from guild_wars_2_item_price, which handles single items by name with formatted prices.

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 guidance is given: 'Use guild_wars_2_item_price for a single item looked up by its name with gold/silver/copper formatting.' This tells the agent when to use this bulk tool vs the named alternative, making the choice straightforward.

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 valuable context: data sources (SEC EDGAR/XBRL for companies, FAERS for drugs), handling of off-calendar fiscal years, sorting by primary metric, and output format (paired data + citation URIs). No contradiction.

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

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

The description is dense but front-loaded with example queries that aid quick understanding. Every sentence serves a purpose, though it could be slightly more streamlined.

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 (comparison, two entity types, multiple data points), the description covers all necessary aspects: when to use, parameter details, data sources, sorting, and output format. No output schema is needed because the description explains returns adequately.

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 basic descriptions. The description adds meaning: for 'type' it clarifies the two options; for 'values' it specifies tickers/CIKs for companies and names for drugs, plus min/max constraints. It also explains sorting behavior. Good addition, though schema already covers basics.

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 performs side-by-side comparisons of 2-5 companies or drugs in one parallel call, listing example user queries. It distinguishes from sequential single-pack lookups, making the purpose clear and specific.

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

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

The description provides explicit guidance: 'ALWAYS PREFER over sequential single-pack lookups when comparing entities.' It also explains what each entity type returns, helping agents decide when to use it.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, which provide a good safety profile. The description adds no behavioral context, but does not contradict annotations. Minimal value added beyond 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?

The description is extremely concise (one word) but at the expense of necessary information. Conciseness should not sacrifice clarity; this is under-specification rather than efficient writing.

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 has two undocumented parameters and an output schema, the description is wholly inadequate. It does not explain return values, filtering, or any usage context, leaving the agent blind.

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 0%, and the description does not explain the two parameters ('ids' and 'lang'). With no enum constraints and no parameter descriptions, the agent receives no guidance on valid values or their meaning.

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

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

The description is a tautology: 'Currencies.' It merely repeats the tool name without any verb or explanation of what the tool does, failing to convey the action or resource.

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

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

No usage guidance provided. The description does not indicate when to use this tool over siblings like 'commerce_prices' or 'commerce_listings', nor does it mention prerequisites or context.

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

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

Beyond the annotations (readOnly, openWorld, idempotent), the description discloses account requirements, paid plan for 'thorough', expected latency (15-90s), the 'never invented' gap handling, contradictions[], semantic excerpting, and the guarantee that citations are always fetchable. These behavioral traits are not in the annotations and add significant operational context.

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

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

The description is long but dense, with a logical structure: critical account warning first, then core capability, then usage guidance, then technical details, then latency. Every sentence adds unique information, and the use of explicit markers (examples, alternatives, depth behavior) makes it 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?

Given the tool's complexity and lack of output schema, the description is remarkably complete: it explains the findings packet (verbatim evidence, confidence, source, fetched_at, citation), gap filling, contradictions, hop field, citation_uri resolvability, excerpting, and latency. It leaves no major operational question unanswered.

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

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

With 100% schema coverage, the baseline is 3, but the description adds meaningful nuance: depth:'thorough' requires a paid plan, and the second-hop iteration behavior is explained in accessible terms (re-angles gaps, chases leads). It reinforces that question can be broad and multi-part. This elevates it above the baseline.

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

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

The description clearly identifies a specific verb+resource+scope: 'Grounded multi-source research across Pipeworx's 1455 STRUCTURED data sources' in one call. It distinguishes itself from open-web search and from the sibling tool ask_pipeworx, which is explicitly called out as the alternative for single lookups and current news.

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: 'Best for broad/multi-part questions over structured data', and when-not-to: 'For a single lookup use ask_pipeworx', 'For BREAKING or colloquial CURRENT-NEWS topics, prefer ask_pipeworx', and 'If you are not signed in, use ask_pipeworx instead'. It also clarifies depth tiers and their iterative/recovery behaviors.

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 behavioral context beyond annotations (readOnlyHint, idempotentHint, destructiveHint). It states the tool returns top-N relevant tools with schemas ready to call without a second lookup. No contradiction with annotations.

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

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

Description is moderately sized but front-loaded with purpose. The list of domains could be slightly trimmed, but each sentence adds value. Efficient overall.

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 (6 params, 1 required, no output schema), the description is complete. It explains purpose, usage, return format, and when to call it. No 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?

Schema description coverage is 100%, so baseline 3. Description lists aliases for query and mentions limit, but schema already provides detailed descriptions. Minimal additional value beyond schema.

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

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

Description clearly states the tool finds tools by describing data or task, with specific verb+resource 'discover tools'. It lists many example use cases and distinguishes from siblings by advising to call this first when exploring many tools.

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

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

Explicitly states when to use: for browsing, searching, discovering tools. Provides examples like SEC filings, FDA drugs, etc. Suggests calling it first. Missing 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?

The description discloses important behavioral traits beyond annotations: it notes that patents soft-fail after May 2025, mentions data sources (SEC, XBRL, USPTO, GDELT, GLEIF), and specifies that only ticker or CIK are accepted. Annotations already indicate read-only, open-world, idempotent, non-destructive; description adds context on potential failures and return structure.

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

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

The description is relatively long but highly informative. It front-loads examples and the core preference rule. Every sentence adds value, explaining data sources, return fields, and constraints. While it could be slightly trimmed, it remains focused and 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?

Given the tool's complexity (multiple data sources) and lack of output schema, the description provides a thorough list of returned fields (cik, filings, fundamentals, patents, news, LEI). It explains data source details and failure modes. This is nearly complete, though exact output structure could be more precise.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds examples ('AAPL', '0000320193') and clarifies that names are not supported. It also explains the 'type' parameter's current limitation. This provides additional meaning beyond the schema, though the schema is already fairly clear.

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

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

The description clearly states the tool's purpose: 'full cross-source profile of a US public company'. It provides specific examples of user queries and lists the data returned (SEC, XBRL, patents, news, LEI). It also distinguishes from sibling tools like resolve_entity by specifying that names are not supported.

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 prefer this tool: 'ALWAYS PREFER over chaining single-pack...lookups when the user asks for a holistic view'. It also specifies when not to use it: 'names not supported (use resolve_entity first if you only have a name)'. This provides clear usage guidance and alternatives.

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

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

Description discloses destructive action (delete) and adds context about clearing sensitive data, complementing annotations (destructiveHint=true, readOnlyHint=false). No contradictions.

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

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

Two concise sentences: first states action, second provides usage context. No unnecessary words.

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

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

For a simple tool with one parameter and annotations present, description fully covers purpose, usage, and behavior. No 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?

Single parameter 'key' with schema description 'Memory key to delete'. Schema coverage is 100%, so description adds no extra meaning beyond 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?

Description clearly states verb 'delete', resource 'memory', and method 'by key'. It distinguishes from siblings by explicitly mentioning paired tools 'remember and recall'.

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 three specific scenarios: 'context is stale, the task is done, or you want to clear sensitive data'. Also references paired tools for context.

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

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

Annotations declare readOnlyHint, idempotentHint, and non-destructive. Description adds fetch/extract behavior and output format, fully consistent with annotations. No contradictions.

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

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

Two sentences, front-loaded with main action, no redundant information. 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?

For a simple two-parameter tool with no output schema, the description explains input (URL), behavior (fetch/extract), and output format (text blob). No 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?

Schema covers both parameters with descriptions. Description repeats the default/max for max_links but adds no new meaning beyond schema. Schema coverage is 100%, so baseline 3 is appropriate.

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

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

Description clearly states it generates an llms.txt file for any URL, enumerates specific use cases (client sites, own projects, competitor auditing), and is distinct from all sibling tools which cover different domains.

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

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

Provides explicit use cases in 'Useful for' section, but does not mention when not to use it or any prerequisites. However, given its unique purpose among siblings, this is sufficient.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds valuable context beyond this: it states prices are live from the official API, describes the return payload (buy order, sell offer, quantity, spread, copper and readable strings, item metadata). This exceeds the minimal annotation info, though it omits details like rate limits or how 'include_listings' alters the output, which prevents a 5.

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

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

The description is a single, well-organized paragraph with front-loaded purpose and concrete examples. Every sentence adds information: lookup methods, example queries, return fields, and data source. It is slightly long but not wasteful, so a 4 is appropriate.

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

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

For a read-only lookup tool with no output schema, the description thoroughly explains the return values (buy/sell orders, quantities, spread, copper and gold/silver/copper strings, item name/rarity/type/icon) and the live nature of data. It also covers all three parameters via schema and adds precedence notes. Given the tool's simplicity, this description is effectively complete.

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

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

Schema coverage is 100% with each parameter described. The description adds explicit precedence (item_id takes precedence over name) and includes real-world examples (e.g., 'Mystic Coin', 19721). It also clarifies the default behavior of include_listings by example. This extra clarification merits a 4 above the schema-only baseline.

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

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

The description has a specific verb ('price') and resource ('Guild Wars 2 Trading Post item'), with clear lookup methods (by name or item_id) and concrete query examples. It unambiguously distinguishes itself from generic commerce tools by focusing on a single item's prices and listing the exact output fields.

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 ('what is X selling for', 'how much is X worth right now') and includes example inputs. It does not explicitly mention alternatives (e.g., commerce_prices) or when not to use it, but the use cases are unmistakable, so it earns a strong 4 rather than a 5.

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

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

Annotations already declare readOnlyHint and destructiveHint=false, so the agent knows it's a safe read operation. The description adds context by listing returned fields (name, type, rarity, etc.), which is useful but does not disclose additional behaviors like rate limits or pagination defaults.

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

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

The description is a single, well-structured sentence with a clear verb and resource. It is front-loaded and avoids unnecessary words, though it could be slightly improved by separating the two modes for readability.

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

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

The description lists returned fields, which is helpful given the output schema exists. However, it omits details like default page size, language usage, or error handling. For a tool with 4 optional parameters and no parameter descriptions, more context is needed.

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

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

With 0% schema description coverage, the description must compensate. It mentions comma-separated IDs and page modes, but does not explicitly map to the 'ids', 'page', 'page_size', or 'lang' parameters. It does not clarify the format or constraints for these parameters, leaving significant gaps.

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 'Fetch', the resource 'Guild Wars 2 item details', and specifies two distinct modes (by comma-separated IDs or by page). It also lists the returned fields, making it easy to differentiate from sibling tools like 'achievements' or 'currencies'.

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 two usage patterns (by IDs or by page) but does not provide explicit guidance on when to choose one over the other, nor does it mention when not to use this tool. No alternatives are cited.

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, indicating safe read behavior. The description adds value by specifying the return fields and the purpose (monitoring/cancellation). It does not contradict annotations. The description provides useful behavioral context beyond what annotations offer.

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

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

The description consists of two sentences with no extraneous words. The first sentence states the function and returns, the second gives usage context. It is front-loaded and efficient.

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

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

Despite no output schema, the description lists the return fields (id, type, params, created_at, last_fired_at, fire_count). Combined with one simple optional parameter and strong annotations, the description provides sufficient information for effective tool 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% with the single parameter 'include_inactive' fully described in the input schema. The tool description does not add additional parameter semantics beyond the schema. Baselines correctly at 3 since schema does the heavy lifting and description adds no extra parameter meaning.

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

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

The description clearly states 'List the caller's active subscriptions' and enumerates the return fields (id, type, params, etc.). The verb 'List' and resource 'subscriptions' are specific. It distinguishes from sibling tools like 'subscribe' and 'unsubscribe' which have different actions.

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

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

The description provides explicit guidance: 'Use this to review what you're monitoring before adding more or to find an id to cancel.' This tells when to use the tool (before adding subscriptions, to get cancellation ids). It does not explicitly state when not to use it or mention alternatives, but the context is clear.

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

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

Annotations only state safety hints (non-readonly, non-idempotent, etc.). The description goes far beyond by disclosing rate limits (5 per identifier per day), being free and not counting against quota, the claim_token flow for anonymous filing, and the daily digest processing. It fully explains what happens when feedback is submitted.

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

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

The description is long but densely packed with useful information. It is front-loaded with the purpose sentence, then logically flows into usage rules, formatting, token flow, and policies. While every sentence earns its place, the size is at the upper edge of concise; a slightly tighter edit could earn a 5.

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

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

With no output schema, the description compensates by explaining what the caller gets (a claim_token) and how to use it for later status checks. It covers scope, exclusions, content requirements, rate limits, and cost. For a simple feedback tool with four parameters, this is fully 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?

Although schema coverage is 100%, the description adds crucial cross-parameter semantics: it explains how claim_token is used to retrieve a previous report (pass it alone), how the 'type' categories map to real-world scenarios, and how message content should be framed (describe in terms of Pipeworx tools/packs, don't paste user prompts). This enriches the schema descriptions meaningfully.

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 begins with a specific verb and resource: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It clearly covers the feedback categories (bug, feature, data_gap, praise) and distinguishes this tool from all sibling tools by explicitly scoping it to Pipeworx-owned tools, which is unique in the catalog.

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 given with concrete examples: wrong/stale data (bug), missing catalog item (feature/data_gap), and positive experience (praise). It also provides a clear exclusion rule: if the tool came from a different MCP server, file it elsewhere. This is a model of usage clarity.

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 safe read-only behavior. Description adds caching details, self-aggregation signal, and no PII, going well 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?

Four concise sentences with clear bullet points. No redundant information; each sentence adds value.

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

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

Given a single optional parameter and no output schema, the description adequately specifies return values and caching behavior, making the tool fully understandable.

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

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

Schema covers the single parameter with enum and description. The description adds contextual guidance on short vs long windows, enriching the enum 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?

Clearly states it returns top tools, top packs, and total call volume over a recent window. Distinct from siblings like 'discover_tools' or 'ask_pipeworx'.

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

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

Explicitly lists three use cases (discovery, confirmation, alignment) but does not mention when not to use the tool.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds rich behavioral context: semantic anchor Jaccard threshold, partition filter for placeholder slugs, fill check against live CLOB depth, and conditions for null signals. 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 thorough but slightly verbose; however, every sentence adds value. It is front-loaded with the main purpose and structured logically by mode. A more compact version could convey the same information, but it is not excessively long.

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 clearly outlines the response structure: opportunities array with fields, partition_check object in event mode, and fill_check details. It covers edge cases like placeholder filters and similarity thresholds. The tool is complex, and the description provides sufficient completeness for an agent to understand inputs, behavior, and outputs.

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 both parameters have descriptions. The description adds significant context: event takes a slug or full URL, topic takes a seed question, and each parameter triggers a different scanning mode. It explains how the parameters affect the analysis, going well beyond the schema.

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

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

The description explicitly states the tool's purpose: 'Find arbitrage opportunities on Polymarket via monotonicity violations + partition-sum checks.' It clearly distinguishes three modes of invocation (no args, event, topic) and differentiates from sibling tools like polymarket_fill_risk.

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

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

The description provides explicit guidance on when to use each mode: 'Call with NO args for a `trending_scan`', 'pass `event` for the strongest per-event partition_check', 'pass `topic` for a themed cross-event scan.' It also warns against acting on signals with low realizable edge and refers to polymarket_fill_risk for custom sizing.

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 other safety cues. The description adds extensive behavioral context: cache duration (1h), response structure (by_segment with three model families), edge computation details, and diagnostics for empty segments. 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 lengthy but well-organized, with numbered segments and clear sections for knobs and diagnostics. Every sentence adds value given the tool's complexity. Could be slightly tighter, but front-loads purpose effectively.

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 9 parameters, no output schema, and complex nested response structure, the description compensates fully. It explains the three response segments, fed_candidates, diagnostics, and how parameters like min_partition_leg_kelly affect filtering. Complete enough 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 provides 100% parameter descriptions with decent detail. The description adds semantic connections, e.g., why min_partition_leg_kelly exists (partition arbs always return kelly_fraction_half=0 at parent level). This adds meaning beyond the schema's per-parameter docs.

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 scans Polymarket markets for opportunities where Pipeworx disagrees with market price, with a specific use case ('what should I bet on today'). It distinguishes from sibling tools like polymarket_arbitrage and polymarket_edge_tracker by focusing on edge discovery without paging.

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 the tool is for discovering opportunities and avoiding manual paging. It implies context (daily betting scouting) but does not explicitly list alternatives or when not to use. Sibling names suggest related tools, but no direct comparisons are made.

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, idempotent, non-destructive behavior. The description adds transparency by explaining it reads snapshots, decay is based on daily closes, gaps indicate no scan, and history is bounded by 60-day TTL. 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 detailed but well-structured with clear sections for the main query, response fields (tracked, expired, snapshot_dates), and limits. It is front-loaded with the purpose, though could be more concise.

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

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

Given no output schema, the description thoroughly explains the response format, including edge_pp_net time-series, first_seen, trend, decay_pp_per_day, expired opportunities with lifespan, and snapshot dates. It also addresses edge cases like gaps and TTL limits.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds context on default values (days=14, window='1wk') and clarifies the response structure, providing meaning beyond the schema.

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

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

The description clearly states the tool provides 'edge persistence and decay telemetry' and answers a specific question about how long an edge has existed and if it's shrinking. It uses specific verbs and resources, distinguishing it from siblings like polymarket_edges.

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

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

The description explains when to use this tool (to assess edge duration and decay) and contrasts with fresh vs old edges. It gives limits on history depth and TTL. However, it does not explicitly mention when not to use or list alternative tools.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, establishing a safe read-only query. The description adds valuable behavioral context: it walks the order book ladder, returns fill prices/slippage, renders a verdict (clean/degraded/cannot_fill), and flags forced directional risk. 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 well-structured with single-market and basket sections, a usage directive, and clear return field enumeration. While a bit long, every sentence earns its place given the tool's complexity. Minor reduction could improve, but current form is acceptable.

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 thoroughly documents return fields for both modes (top_of_book, vwap_fill_price, slippage_pp, shares_filled, theoretical_sum vs realizable_sum, capture_ratio, profit_usd, thin_legs[], max_clean_notional_usd, forced_directional_risk). It also covers edge cases like partial fills and unhedged positions. Complete for 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?

Schema description coverage is 100%, but the description adds meaning beyond parameter names: it explains size_usd as max spend on buys and target proceeds on sells (single-market) vs. settlement notional in basket mode, and clarifies side auto-detection in basket mode based on partition sum. This compensates for any lack of enums.

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

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

Description explicitly states the tool performs a realizable-vs-theoretical edge check against live CLOB order-book depth. It cleanly separates single-market and basket modes and directly connects to sibling tools polymarket_arbitrage and polymarket_edges, telling the agent when to use this tool before those.

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?

Description gives explicit when-to-use: before acting on polymarket_arbitrage signals or trades above ~$500. It warns against partial basket fills converting arb into unhedged directional positions, and states that theoretical overround on thin books is not capturable. This provides clear context and 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?

The description adds considerable behavioral context beyond the annotations (readOnlyHint, idempotentHint, destructiveHint false). It details compatibility_warning scenarios, temporal_alignment, skipped_cross counters, and explains when spreads are meaningful. This is exemplary 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 lengthy but well-structured with bullet points and clear sections. Each sentence adds information, but it could be more concise. Some redundancy exists (e.g., repeating 'compatibility_warning fires in two cases').

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 explains the response structure (leg-by-leg prices, top_spreads_pp) and safety fields, despite no output schema. It covers compatibility, temporal alignment, and skipped comparisons. It is fairly complete for a complex tool, though it could mention the exact output format more explicitly.

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

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

Schema coverage is 100% with all parameters described. The description adds value by explaining the two modes (topic auto-fetch vs explicit tickers) and providing examples. It clarifies the meaning of topic as pre-mapped shortcuts and that explicit tickers override the topic.

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

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

The description clearly states it computes the cross-venue spread between Kalshi and Polymarket for the same question. It specifies the resource (two venues) and action (compare/compute spread), and distinguishes from sibling tools like polymarket_arbitrage by focusing on cross-venue differences.

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 two modes (topic shortcuts vs explicit tickers) and warns that pre-mapped topics often return compatibility warnings, implying they are not always tradeable. While it doesn't explicitly state when not to use, the safety fields provide guidance. It could be clearer about alternatives, but it is sufficiently informative.

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 no behavioral context beyond what annotations already state (readOnlyHint, openWorldHint, etc.). Annotations indicate a safe, read-only operation, but the description fails to describe any additional constraints or behaviors.

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

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

The description is extremely short, but this is under-specification rather than conciseness. Every sentence should earn its place; here the single word fails to convey necessary information.

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

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

Given the output schema exists and annotations are present, the description should still explain the tool's purpose and parameter usage. It is completely inadequate for a tool with two un-documented parameters.

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

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

With 0% schema description coverage, the description must explain parameter meaning, but it does not. It does not mention 'ids' or 'lang' parameters at all.

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 is a single word 'Professions', which is a tautology that restates the tool name. It does not specify any action (e.g., 'list', 'get') or clarify what the tool does with professions.

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

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

No guidance is provided on when to use this tool versus sibling tools. There is no mention of context, exclusions, or alternatives.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint true, and destructiveHint false. The description 'Quaggan images.' adds no behavioral context beyond what annotations provide, such as specifying the output format or side effects.

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

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

The description is extremely concise at three words, front-loaded with the essential information. No unnecessary 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 tool's simplicity (no parameters, output schema exists), the description 'Quaggan images.' is largely adequate. It could benefit from stating that it returns image URLs, but the output schema covers return specifics.

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?

There are zero parameters, and schema description coverage is 100% (trivial). The description does not add parameter information, but it is not needed.

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

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

The description 'Quaggan images.' clearly indicates that the tool provides images of quaggans. While it lacks an explicit verb, the context of retrieving images is clear and it distinguishes from siblings like 'achievements' or 'items' that likely return data.

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

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

No usage guidelines are provided. The description does not mention when to use this tool versus alternatives, such as other data-retrieval 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?

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint), the description adds that omitting key lists all keys, explains scoping, and pairs with remember/forget. No contradictions.

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

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

The description is concise, front-loaded with purpose, and every sentence adds meaningful detail without redundancy.

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

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

Given no output schema, description adequately covers behavior (retrieve/list) and scoping. Could mention return format explicitly but not critical for a simple read 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% and the description reinforces the key parameter behavior (omit to list all). Adds value by giving context (scope, examples) beyond the schema's brief description.

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 retrieves a value by key or lists all keys, differentiating it from siblings 'remember' and 'forget'. It uses specific verbs and resource contexts.

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

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

Provides clear use case examples (ticker, address, research notes) and context (scoped to identifier). Implicitly contrasts with re-deriving from scratch, but lacks explicit when-not-to-use or alternatives.

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

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

Beyond annotations (readOnly, idempotent), the description explains mark_read behavior, return fields, and that polling is acceptable, adding valuable operational context without contradictions.

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

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

The description is front-loaded with purpose, followed by return details, filtering, side effects, and alternatives. Every sentence adds value with no redundancy.

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

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

Given robust annotations and schema, the description is fully adequate, covering return structure, parameter usage, and integration patterns for a read-only polling tool.

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

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

With 100% schema coverage, the description enhances understanding by providing examples (e.g., 'sec_8k' for type) and explaining the effect of mark_read, going beyond the schema definitions.

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

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

The description clearly states the tool pulls fired events from a subscription feed and specifies the returned data (source, citation_uri, raw payload). It is distinguishable from siblings like 'subscribe' or 'list_subscriptions' by focusing on recent alerts.

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 explains when to poll and mentions an alternative URL for scripts/dashboards, providing context for usage. However, it lacks explicit 'when not to use' guidance.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, destructiveHint. Description adds significant context: fans out to multiple sources, fallback logic, date format support (ISO/relative), return structure with citations. 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 detailed but front-loaded with examples, making it easy to grasp. Every sentence adds value, though slightly verbose. Could be trimmed slightly without losing information.

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

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

Given the complexity (multiple data sources, fallbacks, date parsing), the description covers all necessary context. No output schema, but description mentions return shape. References sibling tool for alternative use case.

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. Description adds value by explaining the 'since' parameter supports relative shorthand ('7d', '30d', '3m', '1y') and that 'value' accepts ticker or CIK. Enhances beyond schema.

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

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

The description clearly states it provides a 'change feed for a company in the last N days/weeks/months' and differentiates from sibling tool 'entity_profile' by stating when to use the latter instead.

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

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

The description includes example queries, explicitly states when to use ('what's new with X', 'latest on Y') and when not ('Use entity_profile instead when you want the static profile'). Also explains fallback behavior (GDELT→GNews) and soft-fails.

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 write operation (readOnlyHint=false) and idempotent. The description adds key behavioral context: 'Stored as a key-value pair scoped by your identifier. Authenticated users get persistent memory; anonymous sessions retain memory for 24 hours.' This goes beyond annotations without contradiction.

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

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

The description is efficient: three sentences covering purpose, usage guidance, and behavioral details. It is front-loaded with the core action and uses minimal words to convey necessary information.

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

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

For a store tool with simple parameters and no output schema, the description covers purpose, usage, persistence, and pairing. It omits what happens on key overwrite (implied by idempotent hint) but is otherwise complete.

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

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

Schema coverage is 100% with descriptions for both key and value. The description adds meaning by providing example keys ('subject_property', 'target_ticker') and stating value can be 'any text'. This enriches the schema information.

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

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

The description clearly states the tool's purpose: 'Save data the agent will need to reuse later.' It specifies the verb 'save' and resource 'data', and distinguishes from sibling tools 'recall' and 'forget' by explicitly mentioning pairing use.

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

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

The description provides explicit guidance on when to use the tool: 'Use when you discover something worth carrying forward (a resolved ticker, a target address, a user preference, a research subject).' It also mentions pairing with recall and forget, but does not explicitly state when not to use it.

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

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

The description goes well beyond the annotations by revealing internal cascading behavior, graceful degradation when GLEIF/OpenFIGI are unavailable, explicit labelling of source for each identifier, and the convention of stating unresolved identifiers under 'unresolved' rather than omitting them. No contradiction with annotations. This is highly informative.

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. The opening examples and imperative 'Use FIRST' immediately convey the primary use case. The SUPPORTED TYPES section is structured and each sentence provides actionable detail (source, fallback, unresolved handling). Despite length, every sentence earns its place.

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

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

Despite lacking an output schema, the description explains what the tool returns: identifiers labelled with source, an explicit 'unresolved' section, a citation for drug lookups, and graceful degradation. It also explains the internal cascade, giving the agent a full picture of the tool's behavior and limitations. No gaps for the agent to infer.

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% (2 params), so the baseline is 3. The description adds substantial value beyond the schema by giving concrete examples for each type (e.g., 'ticker (AAPL), CIK (0000320193), or name' and 'brand or generic name (e.g., "ozempic", "metformin")'). This clarifies the expected input format beyond the schema's generic descriptions.

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

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

The description starts with concrete user queries and then clearly states the action: 'resolve a user-spoken NAME to the canonical/official identifiers other tools require as input.' This is a specific verb+resource combination that distinguishes it from sibling tools like entity_profile or compare_entities, which serve different purposes.

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 guidance: 'Use FIRST whenever you have a name but need an ID.' This clearly states when to use the tool. However, it does not explicitly mention when not to use it or name alternative tools, so it falls short of the highest bar. The supported types and input formats provide additional contextual guidance.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds that it probes each entity via ai_visibility_check, ranks results, and returns a list with score, confidence, signal density. This adds useful behavioral context beyond the annotations without contradiction.

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

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

The description is three sentences, front-loaded with the main action, and every sentence adds value. No fluff or repetition.

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

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

The description explains the purpose, process, and output (ranked list with score, confidence, signal density). It does not detail output format or model behavior implications, but given the richness of annotations and concise schema, it is adequately complete for a tool that composes another.

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

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

Schema description coverage is 100% with adequate descriptions for all parameters. The description adds extra meaning for the 'entities' parameter by stating the first entry is treated as the subject. For other parameters, it adds minimal additional value, but the baseline of 3 is exceeded due to this clarification.

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

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

The description clearly states the tool compares AI visibility across multiple entities side-by-side, probes each entity, ranks by score, and surfaces the most/least recognized. It uses specific verbs and resources, and differentiates from sibling tools like ai_visibility_check (single entity) and compare_entities (likely different comparison).

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

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

The description explicitly states the use case: competitive AI-marketing audits, and hints at ordering with 'First entry treated as the subject'. It implies when to use (comparing multiple entities) but does not explicitly mention when not to use or name alternative tools. Still, it provides clear context.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint. The description adds behavioral details beyond these: composite fan-out across two services, summary return fields, per-advisory details, links, alternative versions, and that bundlephobia's first measurement can take 5-30s with sources_failed on timeout. 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 moderately long but packs substantial information. It is front-loaded with the main purpose and then lists details logically. Each sentence adds value, though slight tightening could improve conciseness.

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

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

Given no output schema, the description lists return fields (summary block, per-advisory, links, recent alternatives) and mentions partial failures. For a complex tool with external service dependencies and potential latency, this provides adequate completeness for an agent to understand behavior.

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

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

Schema description coverage is 100% (both parameters documented). The description adds value by noting that scoped packages (e.g. '@types/node') are accepted for the 'package' parameter, and that 'version' defaults to the latest if omitted. This provides helpful semantic context beyond the schema.

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

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

The description clearly states the tool's purpose: a composite 'should I add this npm package' check covering license, advisories, bundle size, and tree-shaking via deps.dev and bundlephobia. It uses specific verbs and resources, and distinguishes itself from siblings by being a one-call composite for npm packages.

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: when the agent asks 'is X safe/popular/small' or 'what does adding lodash cost me'. Also clarifies scope (NPM only in v1) and directs other ecosystems to deps.dev:version directly. Mentions partial failures and timing behavior, giving clear context.

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

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

Adds significant behavioral context beyond annotations: mentions embedding model (BGE-base-en), chunking (500-char overlapping windows), character cap (200K chars) with truncation flag, and that passages include offsets for verification. No contradiction with annotations.

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

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

Description is relatively long but densely informative. Each sentence serves a purpose: purpose, when to use, how it works, return info, pairing with other tools. Well-structured and front-loaded.

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

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

No output schema, but description fully explains return values: 'top-N passages with character offsets and similarity scores.' Also covers pairing with other tools, limitations (200K chars), and internal details (chunking). Completely adequate for agent to use correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the text parameter context ('text you already pulled'), providing query examples, and clarifying the limit default and range. This goes beyond the schema descriptions.

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

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

Clearly states it performs semantic search inside a fetched record. Distinguishes from sibling tools like ask_pipeworx_grounded by specifying it searches inside an already-fetched text.

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

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

Explicitly tells when to use: 'Use when the record is too big to cram into the prompt.' Also provides alternative: 'Pairs with ask_pipeworx_grounded: fetch with the gateway, ground over the relevant passages instead of the whole document.'

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 value beyond annotations by detailing OAuth requirements, type-specific parameters, and delivery channel constraints. However, it contradicts the idempotentHint annotation: it says 'Create... Returns the new subscription id' implying a new resource per call, while annotations indicate idempotency. This inconsistency misleads the agent.

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

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

The description is well-structured with a clear lead sentence, prerequisites, type examples, and delivery options. Every sentence adds necessary information with no fluff; it is appropriately sized for the tool's complexity.

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

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

Given no output schema, the description explains the return value (subscription ID) and fully covers prerequisites, types, parameters, delivery options, and constraints. It leaves no critical gaps for correct invocation.

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

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

The input schema covers all parameters (100% coverage), but the description enriches understanding with concrete examples per type (e.g., sec_8k items, polymarket_edge topic) and delivery details (SMS verification, webhook signing). This goes beyond the schema's basic descriptions.

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

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

The description clearly states the tool creates a proactive monitoring subscription to a live-data event stream, returns a new subscription ID, and distinguishes from sibling tools like list_subscriptions and unsubscribe by focusing on creation. It provides specific verb, resource, and scope.

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

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

It explains prerequisites (Pipeworx OAuth account), supported types with examples, and delivery constraints (SMS cap, phone verification). However, it does not explicitly mention when not to use or alternatives like list_subscriptions for existing subscriptions.

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 all behavioral traits: it is a read-only, idempotent operation (consistent with annotations) that returns category-bucketed example questions with tool shapes. It adds context about drawing from a live catalog and the ability to call with no args or a topic. No contradictions with annotations.

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

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

The description is front-loaded with example queries and is efficiently structured, but it is a single dense paragraph. While every sentence adds value, it could be slightly more concise by breaking into bullet points or shorter sentences. Overall, it is well-organized with no redundancy.

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

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

Given the tool is simple (one optional parameter, no output schema), the description covers purpose, usage examples, relationship to siblings, and what the return contains ('category-bucketed example questions'). It fully compensates for the lack of an output schema with clear behavioral 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% (one parameter 'topic' with description). The description adds value by listing example values ('finance', 'pharma', etc.) and explaining the behavior of omitting the parameter ('Omit for a cross-category spread'). This goes beyond the schema definition, justifying a score above the baseline of 3.

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

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

The description clearly states it is the onboarding entry point, returning example questions with tool calls to learn what Pipeworx can do. It explicitly distinguishes from sibling tools like ask_pipeworx, entity_profile, and compare_entities, stating 'Use this FIRST when you do not yet know what Pipeworx can do for you, or to learn how to call the meta-tools.' This provides specific verb+resource and differentiates from alternatives.

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

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

The description specifies when to use the tool (when unsure what Pipeworx can do, or to learn meta-tools) and lists example user queries ('What can I ask Pipeworx?', 'give me ideas', etc.). It implies alternatives by referencing the meta-tools themselves, but does not explicitly state when not to use it (e.g., when already knowing what to ask). This is clear but has a minor gap in exclusion guidance.

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

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

Adds significant behavioral context: ownership enforced, row is deactivated not deleted, history preserved for recent_alerts. No contradiction with annotations (readOnlyHint=false, destructiveHint=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?

Two sentences, front-loaded with core purpose, no wasted words. Perfectly 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?

For a 1-param tool with good annotations, the description covers ownership, side effects, and historical behavior. No output schema needed; complete for the domain.

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 only parameter 'id' is fully described in the schema ('Subscription id (uuid) returned by subscribe'). Description adds no extra meaning beyond schema coverage; baseline 3 applies.

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

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

The description clearly states 'Cancel a subscription by id' with a specific verb and resource, and distinguishes from sibling tools like 'subscribe' and 'list_subscriptions' by noting ownership enforcement.

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 says to cancel your own subscription, implying when to use, but does not give explicit when-not-to-use or alternative tools.

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

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

The description goes well beyond the read-only/idempotent annotations by detailing the two verification pipelines, return verdict types, and the crucial distinction between 'could_not_verify' (check didn't happen) and 'unsupported'. It even warns about not presenting could_not_verify as evidence, which is critical for safe invocation.

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?

Despite being lengthy, every sentence serves a purpose: examples, usage, pipeline, return values, and critical caveats. The description is well-structured and front-loaded with natural-language triggers, making it 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?

Without an output schema, the description fully explains the return payload (verdict, actual value, citation, reasoning) and the failure modes. It covers both financial and non-financial claim handling, making it complete for an agent to invoke correctly in all cases.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds minimal parameter-level meaning beyond the schema: it includes examples for the claim and mentions tolerance usage (hallucination detection) that already appears in the schema. No substantial new semantic details are provided.

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

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

The description clearly states a specific verb+resource: 'natural-language claim verification against authoritative sources'. It provides multiple trigger examples and distinguishes itself as a single-call replacement for a 4-6 call pipeline, setting it apart from sibling tools.

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

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

Explicitly states 'Use whenever the agent needs to check whether something a user said is factually correct', and further clarifies the two distinct paths (SEC EDGAR for company financials, grounded pipeline for anything else). It also hints at an alternative (replacing sequential calls), giving clear when-to-use guidance.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds behavioral context beyond annotations by explaining two invocation modes (by IDs vs. full index) and the return fields (name, population level), which helps the agent understand what to expect.

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

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

The description is a single sentence that front-loads the verb and resource, clearly covers both usage modes, and mentions key output fields. There is no wasted wording, 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 simple tool with one optional parameter, an output schema, and strong annotations, the description is complete. It explains both usage modes and what is returned, and the presence of an output schema means it doesn't need to detail return types.

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%; the input schema already explains the 'ids' parameter as 'Comma-sep ids; omit for index.' The description reiterates this but adds no significant new meaning beyond what the schema provides, so the baseline of 3 applies.

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

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

The description clearly states the tool's function: 'Fetch Guild Wars 2 world (server) details by comma-separated IDs, or return the full index of world IDs'. It names the specific resource (worlds/servers) and the output contents (world name and population level), distinguishing it from sibling tools like items or currencies.

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: for fetching world details by IDs or the full index. It doesn't explicitly name alternatives or exclusions, but given the tool is single-purpose and sibling tools are similarly specific, no further guidance is needed.

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

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

Annotations already indicate readOnly, idempotent, etc. Description adds 'current' implying temporal scope, but doesn't disclose other behaviors like pagination or data freshness.

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 very short (2 words) and front-loaded, but too terse, sacrificing useful detail. Every word earns its place, but more context would be beneficial.

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 has 1 optional parameter and an output schema, the description fails to explain what data the matches contain (e.g., scores, maps). Output schema may compensate, but description should provide a high-level overview.

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

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

Schema coverage is 0%, and description does not explain the 'world' parameter. Agent must infer it filters by world ID; no format or default provided.

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

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

Description 'Current WvW matches' clearly states the tool returns WvW match data. It distinguishes from sibling tools like 'worlds' or 'achievements' by focusing on matches, but could be more specific about scope.

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

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

No guidance on when to use vs alternatives. The description does not mention scenarios, prerequisites, or comparisons to other tools.

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