Coinbase Exchange

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

Beyond the annotations (read-only, idempotent, non-destructive), the description discloses cost implications (BYO Anthropic key, direct billing) and default model behavior. This adds meaningful behavioral context that annotations do not cover.

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

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

The description is three sentences with no redundancy. The first sentence conveys the core function and output, the second details model options and cost, and the third lists use cases, each earning 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?

Since there is no output schema, the description helpfully outlines the per-model return shape (score, confidence, signals, raw_response) plus a combined view. It also explains model selection and cost, making it complete for a moderately complex tool.

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

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

The schema already provides 100% parameter coverage, so the baseline is 3. The description adds value by explaining that the default model is free and clarifying the _apiKey parameter's cost pass-through, going 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 probes multiple LLMs for knowledge about a business/brand/product/topic and produces a 0-100 visibility score per model. It specifies the default model and return structure, making it distinct from generic search or data-retrieval tools.

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

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

The description provides specific use cases (AI-marketing audits, pre-launch brand checks, competitive monitoring), giving clear context for when to use it. However, it does not mention alternative tools or when-not-to-use scenarios, so it lacks explicit exclusions.

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

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

Annotations already declare readOnly, idempotent, openWorld, non-destructive, so the description need only add context. It does: routes to 5,578 tools, fills arguments, returns pipeworx:// citation URIs, works on all tiers, one fast call. This goes beyond the annotations without contradicting them.

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

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

The description is long but every sentence earns its place: it defines scope, lists examples, sets expectations, and gives alternatives. It starts with the key directive 'PREFER OVER WEB SEARCH', is well-structured, and avoids redundancy. It is efficiently packed with actionable 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 general-purpose question-answering tool with no output schema, the description fully covers usage context: what it returns (structured answer + citations), when to use it (default), and when to use alternatives. It even notes handling of breaking news. There are no significant 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 coverage is 100% (all six parameters are aliases for the single 'question' string). The description provides usage examples that clarify question phrasing but does not add technical parameter details beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: routes questions to a large set of verified sources and returns structured answers with citation URIs. It lists specific categories (SEC filings, FDA data, etc.) and explicitly distinguishes itself from siblings ask_pipeworx_grounded and deep_research, providing strong differentiation.

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

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

Extensive guidance is given: 'PREFER OVER WEB SEARCH', when to use (factual questions about real-world entities), and when to step up to alternatives (grounded for verbatim evidence, deep_research for broad/multi-part). It also clarifies behavior for breaking news. This is explicit and thorough.

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, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is well-covered. The description adds valuable context about beta status, that it currently matches ask_pipeworx exactly when no candidate is active, and that it is a full working router rather than a fallback. This goes beyond the annotations without contradicting them, meriting a score above 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 three sentences and front-loaded with the purpose, but contains some redundancy (repeats 'same 5,578 tools, same arguments, same response shape' and 'matches ask_pipeworx exactly'). It is efficient overall, though slightly verbose; a tighter version could omit the duplicate phrase 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?

The description covers the tool's nature, current state, usage, and relationship to ask_pipeworx. With no output schema, it references the same response shape as ask_pipeworx, which is sufficient given the sibling is known. It also clarifies it is not a fallback but a full working router. For a single-parameter tool, this is adequately complete, though a direct description of the response format would improve self-containedness.

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 the question parameter and its five aliases fully documented in the input schema. The description adds no additional parameter semantics beyond stating it has the same arguments as ask_pipeworx, which is redundant given the schema completeness. The baseline of 3 is appropriate; the description does not enhance parameter understanding further.

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 this as a beta version of ask_pipeworx, a universal router with 5,578 tools, and explicitly differentiates it from the stable ask_pipeworx. The verb 'ask' and resource 'pipeworx' are clear, and it positions itself as the experimental edge version with candidate routing improvements.

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 instructs to use it exactly like ask_pipeworx when wanting the newest routing and explains that results are compared against the stable router to decide merges. This provides clear when-to-use guidance and contrasts with the sibling ask_pipeworx, satisfying the requirement for explicit usage alternatives.

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

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

The description adds substantial behavioral context beyond the annotations (readOnly, openWorld, idempotent, non-destructive). It details the refusal mechanism with specific refusal reasons, the evidence quote in the return object, the extra LLM call cost, and the structure of the return payload. There is no contradiction with annotations; instead, it enriches the agent's understanding of the tool's safeguards and limitations.

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, starting with the core purpose, then details on routing, refusal, use cases, and cost. Every sentence contributes useful information to the agent. It is front-loaded and avoids extraneous wording, achieving high information density in a compact form.

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

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

For a tool that routes across many underlying tools and has a complex refusal behavior, the description provides a complete picture: it explains what happens on success and failure, the return object structure, the extra cost, and when to prefer this over the sibling tool. Although there is no output schema, the description itself details the expected return values, making it sufficient for an agent to invoke and interpret results 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 schema already documents all parameters as aliases for 'question' with 100% coverage. The description adds value by clarifying that the question should be in natural language and explicitly listing the accepted aliases (query, q, prompt, text, input). While this is redundant with schema text, it reinforces the intended usage without overcomplicating, and the single conceptual parameter makes the description adequate.

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 as a 'hallucination-resistant answer mode' that extracts answers only from tool results. It specifies the resource (grounded answer) and distinguishes it from the sibling 'ask_pipeworx' by contrasting its cost and use cases, making the differentiation explicit.

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

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

It provides explicit guidance on when to use the tool: 'Use whenever an answer will be quoted, cited, or acted on...' and also states when to avoid it: 'prefer ask_pipeworx for casual lookups.' This gives clear context and an alternative, fully satisfying the usage guideline requirement.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds rich behavioral context: fan-out to category-specific data packs, resolver contract with market_match_confidence and alternatives, parent_event extractor, news fallback mechanisms, low-confidence short-circuit statuses, closed-market handling, wide-spread illiquidity warnings, and cancellation rules. This far exceeds what annotations convey.

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

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

The description is well-structured with bold section headers and prioritizes the core purpose first. It is lengthy (~300 words) but every section earns its place given the tool's complexity, covering classifiers, fan-out examples, response shapes, safety statuses, and resolution-rule risk. It could be tightened by trimming redundant explanations (e.g., the closed-market dual-path nuance), but overall it is appropriately detailed for a complex tool.

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

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

There is no output schema, so the description must fully describe return values. It does so comprehensively: result.market fields (best_bid, spread_pp, price_change), result.analysis (model_probability, edge_pp, kelly_fraction), result.evidence, resolver contract fields, parent_event structure, news fallback fields, and status enums. It also covers edge cases like illiquid markets and cancellation rules, making it complete for the tool's complexity.

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

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

Schema description coverage is 100%, so the baseline is 3. The description restates that 'market' accepts a slug, URL, or question text, which the schema already documents. It adds examples of fan-out behavior (BTC bet → coingecko + fred + gdelt+gnews) but does not provide new syntax or format details for parameters. Thus it meets the baseline but does not meaningfully 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 opens with a specific verb+resource: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It clearly distinguishes from siblings (e.g., product_ticker, polymarket_edges) by emphasizing market resolution, classification, fan-out, and evidence packet generation.

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".' It also gives practical guidance like checking resolution-rule risk before sizing sports bets. However, it does not explicitly state when not to use this tool or name alternative tools, so it falls slightly short of a perfect 5.

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

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

Beyond the readOnly/idempotent annotations, the description discloses data sources (SEC EDGAR/XBRL for companies, FAERS/FDA for drugs), correct handling of off-calendar fiscal years, sorting by primary metric, and output includes paired data with citation URIs. 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 dense but every clause carries operational value: trigger phrases help recognition, the preference rule guides tool selection, and the type-specific details justify invocation. It is front-loaded with purpose and avoids filler.

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

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

With no output schema, the description compensates by stating what is returned (paired data, sorted results, citation URIs) and what data fields each type covers. It provides enough for an agent to select, invoke, and interpret results without additional lookups.

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

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

Although the schema already documents both parameters (100% coverage), the description adds meaningful behavioral context: choosing 'company' pulls specific financial fields while 'drug' pulls adverse-event/trial counts. It also provides examples for the values array and reinforces the 2–5 constraint.

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 frames the tool as a side-by-side comparison of 2–5 companies or drugs, with natural-language trigger phrases and a clear contrast to sequential lookups. It clearly identifies the resource (entities) and the verb (compare/rank), distinguishing it from other entity 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?

It states when to use ('when comparing entities') and explicitly prefers this tool over sequential single-pack lookups. It also clarifies entity-type-specific behavior (company vs drug) and result sorting, giving the agent actionable selection criteria.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description 'List currencies' adds no additional behavioral context such as data scope, return format, or safety nuances. Since it provides no value beyond the annotations, it scores 2.

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 exactly two words, 'List currencies.' For a zero-parameter listing tool, this is appropriately sized and front-loaded. There is no wasted wording, so it earns 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?

Given the low complexity, zero parameters, strong annotations, and presence of an output schema, the description is minimally complete. It could optionally mention what currencies are included (e.g., fiat, crypto) but does not need to for a simple list-all operation, so it scores 4.

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 tool has zero parameters, so the baseline is 4. The schema is empty with 100% coverage, and the description does not need to explain parameters. Thus, it fulfills the requirement adequately.

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 'List currencies' uses a specific verb and resource, clearly stating what the tool does. It does not explicitly differentiate from the sibling tool 'currency', though the plural form hints at a listing versus single-item lookup. This is clear but lacks explicit sibling differentiation, so it is a 4.

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?

There is no guidance on when to use this tool versus alternatives like 'currency'. The description only states the action without any context for selection, so it scores 2 for no 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 indicate read-only, open-world, idempotent behavior. The description adds no additional behavioral context such as data source, return fields, or limitations, so it does not go beyond the structured annotations.

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

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

It is very short but under-specified rather than concise; the two-word phrase does not earn its place because it communicates almost nothing about the tool's 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 one-parameter tool, the description still lacks the core action and usage context needed to select and invoke it. The presence of an output schema helps, but the description leaves the agent guessing what the tool actually does.

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

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

The schema has a single required currency_id with examples but no descriptions; the description does not explain parameter semantics or accepted values. With 0% schema coverage, this leaves the agent without any compensation.

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 'Single currency.' merely restates the tool name and lacks an actionable verb (e.g., 'get', 'fetch'). It provides minimal differentiation from the sibling 'currencies' tool only by implying singular 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 is given about when to use this tool versus 'currencies' or other product tools. There is no mention of use cases, exclusions, 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?

Discloses extensive behavioral traits beyond annotations: account/payment requirements, decomposition into facets, parallel routing, gaps[] never invented, hop field and citation_uri validity, contradictions scan, semantic excerpting, and latency expectations. This far exceeds the annotation hints.

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

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

Although long, every sentence adds critical information (auth, scope, alternatives, output format, caveats, latency). The description is front-loaded with the account requirement and structured logically, making the length appropriate for the tool's complexity.

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

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

For a complex research tool with no output schema, the description fully explains return values (findings packet with evidence, confidence, source, gaps[]), process, second-hop behavior, and constraints. It leaves no ambiguity about what the tool returns or when it is appropriate to use.

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

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

The schema already covers both parameters at 100%, so baseline is 3. The description adds meaningful extra context: depth:'thorough' requires a paid plan, depth behaviors are further elaborated, and question accepts broad/multi-part input. This additional pricing and behavior detail justifies a 4.

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

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

The description clearly states the tool's function: 'Grounded multi-source research across Pipeworx's 1463 STRUCTURED data sources' with decomposition and parallel routing. It explicitly contrasts with ask_pipeworx and open-web search, making it distinct from siblings.

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 and when-not-to-use guidance: 'Best for broad/multi-part questions over structured data', 'For a single lookup use ask_pipeworx', and 'For BREAKING or colloquial CURRENT-NEWS... prefer ask_pipeworx' with reasoning about gaps[].

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

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

Annotations already establish readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context by disclosing the return format: 'Returns the top-N most relevant tools with names, descriptions, and full input schemas (with curated examples) — each result is ready to call directly, no second schema lookup needed.' This goes beyond simple safety declarations to explain what the agent can expect from the output, though it doesn't mention limit behavior or pagination.

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 and front-loaded. It starts with the core purpose, then usage context, then output details, then a strategic note ('Call this FIRST'). The list of domains is long but necessary to clarify scope. Every sentence earns its place, and the overall length is justified for a discovery tool.

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

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

For a read-only meta-search tool, the description is complete. It covers input (natural language query), output (tool names, descriptions, schemas), and usage guidance (when to call first). Even without an output schema, the description fully explains the return value. The combination of annotations and description leaves no significant 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 coverage is 100%, with all parameters (q, task, limit, query, search, description) already documented. The description adds little beyond the schema: it emphasizes 'describing the data or task' and provides examples via a list, but this is already captured in the query parameter's description. The 'top-N' mention relates to limit but doesn't add new semantic detail. Baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Find tools by describing the data or task.' It specifies a concrete verb ('find'), a resource ('tools'), and a method ('by describing the data or task'). It also lists broad categories (SEC filings, financials, FDA drugs, etc.), making it easy to distinguish from siblings. The directive 'Call this FIRST when you have many tools available' reinforces its role as a discovery meta-tool.

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

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

Explicit guidance is provided: 'Use when you need to browse, search, look up, or discover what tools exist for...' and 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' This clearly communicates when to invoke this tool versus directly calling a specific tool, though it does not name alternative tools individually.

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 readOnlyHint/idempotentHint annotations, the description discloses important behavioral details: fans out across specific sources (SEC EDGAR, XBRL, USPTO, news, GLEIF), returns up to 5 filings with pipeworx URIs, fundamentals sorted by period_end DESC, patents API sunset May 2025 with soft-fail, and GDELT→GNews fallback. It also states the input format restriction (ticker/CIK only). This goes well beyond the annotations.

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

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

The description is a dense paragraph but well-structured: example queries first, then a clear purpose statement, usage preference, detailed output breakdown, and input requirements. Every sentence adds value, though it could be slightly more compact by separating examples from the formal description. Front-loaded with user-intent examples for quick pattern matching.

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 meticulously lists all return fields: cik + company_name; recent_filings (up to 5 with URIs); fundamentals (latest 10-K Revenues, NetIncomeLoss, Cash, sorted); patents (with sunset status); news mentions via fallback; and LEI via GLEIF. It also notes the soft-fail behavior and naming limitation. For a tool with this many data sources and no output schema, the description is exceptionally complete.

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

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

Schema description coverage is 100%, so the schema already explains type (enum "company") and value (ticker or zero-padded CIK, names not supported). The description repeats this information without adding new parameter semantics. It provides examples ("AAPL", "0000320193") but these are illustrative rather than novel. Baseline 3 applies due to full schema coverage.

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

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

The description states a specific verb+resource: "full cross-source profile of a US public company in ONE parallel call." It clearly distinguishes from siblings like compare_entities, resolve_entity, and deep_research by focusing on a holistic company profile. Example queries like "Tell me about X" reinforce the intent.

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: "ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view." It also directs users with only a name to use resolve_entity first, and warns that names are not supported. This clearly differentiates when to use this tool vs alternatives.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, which cover the main safety profile. The description adds minimal behavioral context beyond the action itself; it mentions clearing sensitive data but does not elaborate on irreversibility or non-existent key behavior.

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

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

Two concise sentences, front-loaded with the core purpose. Every word earns its place without unnecessary fluff.

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

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

The tool is simple (one parameter, no output schema), and the description plus annotations cover purpose, usage, and destructive/idempotent behavior adequately. Nothing essential is missing.

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

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

The schema has 100% description coverage for the single 'key' parameter, and the description simply repeats it as 'by key.' It adds no additional semantic 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 action with a specific verb and resource: 'Delete a previously stored memory by key.' This distinguishes it from sibling tools like remember (store) and recall (retrieve).

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 scenarios: 'Use when context is stale, the task is done, or you want to clear sensitive data the agent saved earlier.' Also mentions complementary tools: 'Pair with remember and recall.'

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 the operational behavior: fetches the page, extracts title/description/key links, and emits standard llms.txt markdown. It also clarifies the output is a single text blob. Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds process details beyond that, without contradicting the annotations.

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

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

The description is three sentences with a clear structure: purpose and value, process, and use cases. Every sentence is informative and no words are wasted. The use cases are neatly listed after a colon, 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?

The tool is simple (2 params, no nested objects, no output schema), and the description covers the process, output format, and use cases. Combined with rich annotations and complete schema descriptions, the description is fully adequate for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters (url and max_links). The description provides minimal additional parameter meaning—only indirectly referencing what the url is used for. It does not add beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: generating a production-ready llms.txt file for any URL. It specifies the resource (llms.txt), the action (generate), and the output format, distinguishing it from any sibling tool by its unique deliverable.

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

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

The description provides explicit use cases ('getting a client's site indexed by AI, drafting llms.txt for your own project, or auditing how an AI crawler would see a competitor'), giving clear context for when to use the tool. However, it does not mention when not to use it or name alternative sibling tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds caller scoping ('caller's active subscriptions') and return field details, but no additional behavioral context like rate limits or authentication. Consistent with the calibration example where annotations cover safety and description adds modest 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 two sentences, front-loaded with the verb and resource. It efficiently includes return fields and practical usage guidance without any fluff or redundancy.

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

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

For a simple list tool with one optional parameter and no output schema, the description covers purpose, return format, and practical usage. Minor gaps exist (e.g., no explicit mention of default exclusion of inactive subscriptions), but the schema fills that gap. Overall sufficiently complete for the tool's complexity.

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

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

The input schema has 100% description coverage: the only parameter `include_inactive` is clearly documented with its default. The description adds no additional parameter semantics 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 with a specific verb ('List') and resource ('the caller's active subscriptions'). It also distinguishes from sibling tools like subscribe/unsubscribe by framing it as a review step before adding or canceling. The return fields are listed, adding further clarity.

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

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

The description provides explicit use cases: 'review what you're monitoring before adding more' and 'find an id to cancel.' This implies when to use it relative to subscribe/unsubscribe, though it does not explicitly state alternatives or exclusions. Clear context is present, but it falls short of fully 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?

Discloses rate limiting (5/day/identifier), free usage, non-quota nature, and the claim_token workflow (no-account filing returns a token that can be used later to read resolution status). These behaviors are not captured by the annotations (all false), so the description carries the full burden and fulfills it.

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

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

The description is longer than average but every sentence carries distinct information: purpose, use cases, exclusions, content guidance, claim_token workflow, operational guarantees. It front-loads the core purpose and then layers details logically, so length is justified.

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 must explain return behavior, and it does explain the claim_token response for anonymous filing and later status retrieval. It also covers rate limits and quota impact. One could want more detail on the exact response envelope, but for a feedback tool this is sufficient.

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

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

All four parameters are already fully described in the schema (100% coverage), so the baseline is 3. The description adds extra value by explaining the claim_token round-trip workflow and by advising users to reference Pipeworx tools rather than paste end-user prompts, which clarifies the intended content for `message` and `claim_token`. This raises it to 4.

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

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

The description opens with a specific verb-resource pair ('Tell the Pipeworx team') and enumerates the four feedback categories (bug, feature/data_gap, praise). It also differentiates from sibling tools by scoping to Pipeworx-owned tools, distinguishing it from ask_pipeworx or discovery 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 (bug, missing tool, praise) and when NOT to use (tools from other MCP servers), including instruction to file elsewhere. Also provides guidance on what to include (Pipeworx tool/pack names, not end-user prompts). This is textbook when/when-not 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?

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description reveals the data source ('derived from CF analytics-engine'), states 'no PII', and adds caching details ('Cached 5min-1h depending on window'). This gives the agent a solid behavioral model.

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

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

The description is three sentences, front-loaded with the core output, followed by use cases and technical context. Every sentence adds value and the structure is easy to scan.

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

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

For a simple read-only tool with one optional param and no output schema, the description fully covers the return format ('pack, tool, count'), use cases, privacy, and caching. There are no significant gaps for an agent to invoke it correctly.

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

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

Schema coverage is 100% with a well-documented window param; the tool description repeats the three window values but doesn't reinterpret their meaning. It does mention cache duration varies by window, which is a subtle behavioral link, but not significant enough to elevate beyond baseline.

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

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

The description opens with a clear purpose: 'What other AI agents are calling on Pipeworx right now' and specifies the exact outputs ('top tools, top packs, and total call volume'). It also names the time windows, making the tool's function unambiguous and distinct from generic discovery tools like discover_tools.

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

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

The description provides three explicit 'Useful for' scenarios, giving clear context for when to use this tool. It doesn't explicitly contrast with alternatives, but the guidance is practical and sufficiently scoped.

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

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

Annotations already establish readOnly and non-destructive behavior, but the description adds rich detail: 'deviations >3pp emit a BUY/SELL EVERY LEG signal', Jaccard similarity threshold of ≥0.30, placeholder filter with >20% returning null, and the fill check meaning 'realizable_edge_pp ≤ 0 means the overround exists only at last-trade, not in the book; do not trade it.'

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

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

The description is long but well-structured with labeled sections (SEMANTIC ANCHOR, PARTITION FILTER, FILL CHECK). It front-loads the purpose and usage, and while dense, most sentences carry essential information, though it could be slightly tighter without losing value.

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

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

Given the tool's complexity and lack of output schema, the description thoroughly explains return values: 'Response: opportunities[] (gap_pp, suggested_trade, reasoning, monotonicity violation context), and in event mode partition_check{...}'. It covers modes, filters, thresholds, edge cases, and fill pricing, making it complete for an agent to use.

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

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

Both parameters have 100% schema coverage, but the description substantially augments that with behavior: event mode 'walks child markets, checks date-axis / threshold-axis ordering AND computes the partition_check', while topic mode 'searches related events across the platform'. It also provides concrete example values for both event and 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 opens with 'Find arbitrage opportunities on Polymarket via monotonicity violations + partition-sum checks,' clearly identifying the verb, resource, and method. It distinguishes itself from sibling tools like polymarket_edges by focusing on arbitrage and even references polymarket_fill_risk for custom sizing.

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

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

Explicit usage instructions are provided: 'Call with NO args for a trending_scan', 'pass event for the strongest per-event partition_check', and 'topic for a themed cross-event scan', with examples and a recommendation. It also offers an alternative, noting 'For custom sizing use polymarket_fill_risk.'

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 extensive behavioral traits beyond annotations: response structure (by_segment, fed_candidates, _diagnostics), the specific model logic (lognormal barriers, GDELT ratios, partition overround corrections), the 24h-move warning, placeholder-slug filtering, and KV-level caching keyed on knobs. It fully aligns with readOnlyHint and idempotentHint, adding significant context 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 a single dense paragraph containing a wealth of technical detail—model families, response segments, gate relaxations, and caching. It front-loads the primary purpose, but the sheer length (many sentences with nested clauses) hurts scannability. It could be restructured with bullets or sections 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 there is no output schema, the description must explain return values, and it does so thoroughly: top-level fields (by_segment, fed_candidates, _diagnostics), per-opportunity fields (edge_pp_net, kelly_fraction, market liquidity/spread), and why segments may be empty. It also covers parameter effects, caching, and the Fed signal caveat—making it 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%, so baseline is 3. The description adds value by explaining how parameters interact: e.g., min_partition_leg_kelly behaves differently for partition arbs (parent-level Kelly always 0), and min_liquidity/max_spread_pp are 'tradeable-edge' filters beyond schema text. This contextualizes knobs beyond their individual 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 opens with a specific verb+resource+outcome: 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price.' It clearly positions the tool for the 'what should I bet on today' use case, distinguishing it from siblings like polymarket_arbitrage and polymarket_edge_tracker.

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

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

It provides clear usage context ('Built for what should I bet on today'), explains why certain features exist (tradeable-edge knobs, diagnostics to see why segments are empty), and gives exclusions (Fed bets excluded from ranking). However, it does not explicitly name alternative tools for when not to use this one.

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

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

Annotations already declare readOnly/openWorld/idempotent, and the description adds substantial behavior not in annotations: snapshots are only written on cache-miss (so gaps occur), history is bounded by a 60-day TTL, and decay is computed from daily closes net of slippage. This deep transparency goes well beyond the structured hints.

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

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

Though long, every sentence carries essential information: purpose, parameters, detailed response fields, and important limits. The text is organized into clear sections (Args, RESPONSE, LIMITS) and front-loads the core purpose. Nothing feels redundant.

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

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

With no output schema, the description fully specifies the response structure (tracked[], expired[], snapshot_dates[]) and explains the meaning of each field. It also covers limitations (TTL, snapshot gaps) and computation details, making it complete for a complex telemetry tool.

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

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

Schema coverage is 100%, so parameters are already documented. The description does add slight context (e.g., 'snapshot family' for window, and that days is a lookback), but it mostly restates the schema defaults and meaning. No extra syntax or edge cases are introduced beyond what the schema provides.

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

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

The description uses a specific verb+resource ('Edge persistence and decay telemetry built from daily polymarket_edges snapshots') and clearly states the tool's unique purpose: answering whether an edge has existed and whether it is shrinking. This differentiates it from sibling tools like polymarket_edges, which presumably lists current edges.

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

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

The description provides clear context for when to use this tool by framing it as the answer to 'how long has this edge existed and is it shrinking?' and contrasts fresh vs. old wide edges. It does not explicitly name alternatives or state when not to use it, but the implied context is strong, and the LIMITS section adds practical usage constraints.

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

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

Beyond the readOnly/idempotent annotations, the description reveals critical behavioral traits: it 'walks the ladder' and returns detailed metrics (top_of_book, vwap_fill_price, slippage_pp, shares_filled, max_fillable_usd), and it explicitly warns about partial basket fills converting arbs into unhedged positions. This explains the 'forced_directional_risk' naming and the dominant loss mode, adding depth not available from annotations alone.

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

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

The description is long but every sentence earns its place. It is front-loaded with the core purpose, then systematically covers prerequisites, mode-specific behavior, return fields, and usage guidance. There is no redundancy or filler; the density is justified by the tool's complexity.

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

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

Given the tool's complexity (two modes, four parameters, rich output), the description is fully complete. It enumerates all return fields for both modes, explains edge cases (thin_legs[], forced_directional_risk), and provides thresholds and use-case context. Without an output schema, the description carries the full burden of explaining return values, which it does thoroughly.

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

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

Although schema coverage is 100%, the description adds significant semantic nuance: size_usd means 'max spend on buys, target proceeds on sells' in single-market mode, while in basket mode it is 'settlement notional S (shares per leg; each share pays $1).' It also explains default values and clamps (10–1,000,000), far exceeding the schema's basic parameter descriptions.

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

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

The description opens with a specific verb+resource: 'Realizable-vs-theoretical edge check against live CLOB order-book depth.' It clearly distinguishes the tool from siblings by focusing on fill-risk verification rather than arbitrage detection or edge listing, and explicitly breaks down single-market vs basket modes.

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

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

Provides explicit guidance: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500.' It names specific sibling tools and explains why (theoretical overround not capturable on thin books, partial fills create unhedged directional positions), making the when-to-use unambiguous.

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

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

Annotations declare readOnlyHint, openWorldHint, and idempotentHint, but the description adds rich behavioral detail: it discloses the compatibility_warning logic, temporal_alignment constraints, and skipped_cross_type/subtype counters. It explicitly explains what happens in edge cases (e.g., matched_pairs:0 scenarios) and makes the mathematical validity conditions transparent. This exceeds what annotations alone convey.

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

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

The description is long but information-dense. It is front-loaded with the core purpose, then explains modes and safety fields in a logical order. Every sentence contributes useful information, though a few sections (e.g., detailed counter explanations) could be tightened. For a complex tool with no output schema, the length is justified.

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

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

There is no output schema, so the description carries the full burden of explaining return values. It covers the response structure (leg-by-leg prices, top_spreads_pp), safety fields (compatibility_warning conditions, temporal_alignment, counters), and how to interpret edge-case results. This is exceptionally complete for a tool with this complexity and no 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?

The input schema has 100% coverage with descriptions for all three parameters, so the baseline is 3. The description adds meaningful semantics beyond the schema: it explains how topic maps to pre-mapped shortcuts and how explicit tickers override the topic side, including example values. This clarifies parameter interdependencies and usage intent, which is valuable on top of 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 opens with a specific verb+resource: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' It clearly defines the tool's function, differentiates from sibling tools like polymarket_arbitrage by focusing on the spread between two venues, and outlines two distinct modes (topic shortcuts and explicit tickers). The purpose is unambiguous.

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

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

The description explicitly explains TWO MODES with concrete examples and clearly states how to use each. It also provides a critical usage caveat: 'Real cross-venue spreads are rarer than the macro-shortcut list suggests — most pre-mapped topics return compatibility_warning today; pre-mapped ≠ tradeable.' However, it does not name explicit alternative tools or exclusion conditions, so it falls slightly short of a 5.

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

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

The description adds no behavioral context beyond the annotations. It does not disclose expected return behavior, data scope, or any operational constraints. The annotations already declare it safe and read-only, but the description contributes nothing additional.

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?

At two words, it is extremely concise but under-specified. Conciseness should not come at the cost of clarity; the phrase 'Single product.' does not earn its place because it conveys almost no useful 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?

Although the output schema exists and annotations provide safety context, the description does not state the tool's primary function or identify the resource being acted upon. A 1-parameter tool can be adequately documented with a clear verb and resource, but 'Single product.' leaves the operation ambiguous.

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 product_id parameter. No format, meaning, or examples are given in the description, leaving the agent to guess that 'BTC-USD' might be a currency pair. The description fails to compensate for the schema's lack of parameter details.

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 'Single product.' is a noun phrase with no verb or action, so it does not clearly state what the tool does. It hints at a singular resource versus the plural sibling 'products', but fails to specify whether it retrieves, creates, or modifies a product.

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 given on when to use this tool versus alternatives like product_ticker or product_stats. There is no mention of use cases, prerequisites, or exclusions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that the data is 'live' from a 'US-regulated crypto venue' and that 'Levels 1-3 control depth,' providing useful behavioral context beyond the annotations. No contradictions with annotations.

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

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

The description is a single, front-loaded sentence with three concise clauses: what the tool provides, how a parameter works, and intended uses. Every phrase adds value without redundancy or filler.

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

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

With only two parameters, an output schema present, and helpful annotations, the description covers purpose, parameters, and usage context in a compact manner. It mentions the venue's regulatory status and depth levels, leaving no critical gaps for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must explain parameters. It does so effectively: 'product_id' is clarified with examples like 'BTC-USD', and 'level' is explicitly said to control depth with values 1-3. This fully compensates for the lack of schema descriptions.

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

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

The description clearly states it provides a live order book with bids and asks for a crypto pair, explicitly naming Coinbase Exchange and example product IDs. This distinguishes it from sibling tools like product_trades, product_candles, and product_ticker by specifying the order book resource and its depth levels.

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

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

The description gives explicit use cases: 'spread analysis, liquidity assessment, market making.' While it doesn't name alternative tools or state when not to use it, the context is clear enough for an agent to determine when an order book is needed versus other market data 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 that the data source is Coinbase Exchange and lists granularity options, but does not disclose additional behaviors such as time range limits or pagination. Annotations already declare readOnlyHint and idempotentHint, covering safety, and the description aligns with these without contradiction, offering minimal extra behavioral context.

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

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

The description is two sentences long, front-loaded with the core action, and contains no filler or redundant words. Every clause contributes meaning, making it highly concise and well-structured.

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

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

The tool is simple, but the description lacks an explanation of the start/end parameters and how to specify time ranges. It also uses human-readable granularities (1m) while examples use seconds (3600), which could confuse. The presence of an output schema offsets the need to describe return values, but the parameter 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?

With 0% schema description coverage, the description must explain parameters. It explains granularity via the list of intervals and calls the pair 'crypto pair' (product_id), but it does not describe the start and end parameters, which are essential for time range filtering. The schema examples show sample values but lack explicit semantics, leaving a gap.

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 OHLC candles for a crypto pair on Coinbase Exchange, with a specific list of granularities. It distinguishes from sibling tools like product_ticker and product_book by explicitly focusing on candle data, 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 phrase 'Use for charting and backtesting' provides clear context for when to use this tool. While it doesn't explicitly mention alternatives or exclusions, the context is sufficient given the sibling tool family and the specific use case stated.

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, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds useful context about response content ('base/quote currency, min order size, status, and trading rules') and scope ('all available'), but does not mention pagination, rate limits, or other behavioral nuances. With annotations doing the heavy lifting, this is adequate but not exceptional.

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, focused sentence that front-loads the core purpose ('list all available trading pairs') and immediately follows with the key fields. Every word contributes value, with no redundancy or fluff.

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

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

Given the tool's simplicity (no parameters, clear purpose), the rich annotations (read-only, idempotent, open-world), the existence of an output schema, and the sibling context that clarifies its 'all products' role, the description is complete. It conveys the necessary information for an agent to select and invoke it correctly.

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

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

The tool accepts zero parameters (input schema is empty), so the baseline is 4. There are no parameter descriptions needed, and the description does not attempt to invent any, making it 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 'list' with a clear resource 'all available trading pairs (products)' and enumerates the included fields (base/quote currency, min order size, status, trading rules). It clearly distinguishes itself from sibling tools like 'product' (singular) and product-specific tools by emphasizing 'all'.

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 phrase 'list all available trading pairs' provides clear context that this tool is for the full catalog, implicitly differentiating it from singular product tools. However, it does not explicitly mention alternatives or when not to use it, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, covering safety and idempotency. The description adds context about the rolling 24-hour window and the inclusion of 30-day volume, which is useful but not extensive. It does not contradict annotations.

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

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

The description is a concise two-sentence statement, front-loaded with the primary function and followed by a useful usage note. Every word contributes 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?

For a simple read-only tool with one parameter and an output schema, the description is largely complete. It explains the key data points and suggests a use case. It lacks explicit alternative differentiation, but given the richness of annotations and output schema, it is not a critical gap.

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

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

The schema has 0% description coverage, so the description must compensate. It states 'for a crypto pair' which links the product_id parameter to a trading pair, but it does not specify the exact format (e.g., 'BTC-USD') beyond what the schema example already provides. This is adequate but not thorough.

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 'Coinbase Exchange 24-hour rolling stats for a crypto pair' and enumerates the specific data points (open, high, low, last, volume, 30-day volume). This distinguishes it from sibling tools like product_ticker or product_candles, which focus on different aspects of product 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?

The phrase 'Use for daily summary' provides a clear usage context, implying this tool is appropriate for periodic summaries. However, it does not explicitly mention when not to use it or name alternative tools, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds context about the data source (US-regulated venue) and the type of data (current pricing), but does not disclose additional behaviors like rate limits or response quirks. This is adequate but not highly detailed.

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, with two sentences that front-load the core function and follow up with usage guidance. No wasted words.

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

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

For a simple one-parameter tool with good annotations and an output schema, the description is complete. It states what the tool does, why it exists, and when to use it, without leaving critical 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 coverage is 0% for the product_id parameter, so the description must compensate. It does by describing the parameter's meaning as a 'crypto pair' on 'Coinbase-listed pair,' which aligns with the example 'BTC-USD' in the schema. This adds essential semantic context beyond the raw 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 best bid/ask, last trade price, and volume for a crypto pair on Coinbase Exchange. It uses specific verbs and a specific resource, distinguishing itself from sibling tools like product_book (order book), product_candles (historical candles), and product_trades (recent trades).

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

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

The description explicitly says 'Use for current pricing on a Coinbase-listed pair,' giving clear context for when to use it. However, it does not name alternatives or exclusions, such as suggesting product_candles for historical data.

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

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

Annotations already establish read-only, idempotent, and non-destructive behavior. The description adds the return field list and pagination support (limit, before/after), providing additional behavioral context. 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?

Two sentences, front-loaded with the key source ('Coinbase Exchange') and purpose ('recent trade tape'), with a clear enumeration of returned fields. 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 the presence of an output schema (which covers return structure) and annotations covering safety, the description adequately covers the resource scope, parameters, and pagination behavior. It is a complete description for a simple read-only listing 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 0%, so the description's explanation of product_id as a crypto pair like 'BTC-USD' and mention of limit and before/after cursor pagination adds critical meaning beyond the bare schema. However, it doesn't detail exact cursor semantics or limit defaults.

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 returning the recent trade tape for a crypto pair on Coinbase Exchange, listing specific fields (trade ID, price, size, side, timestamp). This distinguishes it from sibling tools like product_ticker or product_candles by focusing on the trade tape.

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 the tool is for retrieving recent trades for a product but does not explicitly state when to use it over alternatives such as product_ticker or product_candles, nor does it provide exclusion criteria. The usage context is clear but not explicitly differentiated.

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 cover readOnly, idempotent, and non-destructive. The description adds valuable behavioral context: scoping to identifier types and the behavior of omitting the key to list all saved keys. This goes beyond the annotations.

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

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

Four concise sentences, each earning its place: main action, usage context, scoping, and relationship to sibling tools. No fluff or redundancy; the most important information is front-loaded.

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

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

For a simple one-parameter tool with strong annotations, the description covers purpose, usage, scoping, and related tools. It omits return format or error behavior, but given the low complexity and schema coverage, it is sufficiently complete.

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

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

Schema coverage is 100% with the key parameter described as 'Memory key to retrieve (omit to list all keys)'. The description echoes this and explains the relationship to 'remember', but does not add substantial new meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description uses a specific verb and resource: 'Retrieve a value previously saved via remember, or list all saved keys'. It clearly distinguishes from sibling tools by explicitly pairing with remember and forget, and by framing the tool as a memory lookup for prior context.

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

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

It explicitly states when to use: 'Use to look up context the agent stored earlier... without re-deriving it from scratch.' It also describes scoping and mentions related tools (remember, forget). However, it does not explicitly state when not to use or mention alternatives for fresh data.

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 explicitly discloses a mutating operation (mark_read:true flags events as read), which contradicts the annotation readOnlyHint=true. This is a serious inconsistency that could mislead an agent about side effects. While other behaviors (return payload, filters) are mentioned, the contradiction undermines trust.

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, all relevant and front-loaded with the primary action. It contains no filler and efficiently covers purpose, return format, filtering, state change, and an alternative endpoint.

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

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

Given the lack of an output schema, the description adequately explains the return payload (source, citation_uri, raw event payload) and covers all parameters and their interactions. The mark_read side effect and polling guidance are present. However, the contradiction with readOnlyHint creates a potential gap in the agent's understanding of mutability, slightly reducing completeness.

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

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

Although schema coverage is 100%, the description adds valuable meaning beyond the schema. It provides a concrete example for type ('sec_8k'), explains that mark_read affects the next call, and clarifies that since is an ISO timestamp. This enriches the parameter 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 clearly states it pulls fired events from the subscription feed, using a specific verb ('Pull') and resource ('fired events'/'alerts'). It distinguishes itself from siblings like recent_changes by focusing on subscription alerts written by the evaluator to a persisted feed.

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

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

The description provides practical usage context: how to filter by type and since, the effect of mark_read on subsequent calls, and notes that polling works fine. It also mentions an alternative HTTP endpoint for scripts/dashboards, giving an explicit alternative. However, it does not explicitly contrast with sibling tools like list_subscriptions or recent_changes.

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 richly details behavior beyond annotations: fans out to SEC EDGAR, GDELT→GNews fallback logic (GDELT preferred, GNews on rate limit/5xx), USPTO soft-fail due to API sunset, parallel call execution, and return structure (changes[] grouped by source + total_changes + citation URIs). No contradictions with annotations (readOnlyHint, idempotentHint, etc.).

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

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

The description is slightly long but every sentence earns its place: user intents, core definition, source fan-out details, parameter format, return structure, and alternative tool guidance. It is well-structured and front-loaded with the most useful info.

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

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

For a moderate-complexity tool with 3 params, no output schema, and no nested objects, the description fully covers the necessary context: what the tool does, how it works (sources, fallback), what it returns, and when to use an alternative. It is self-contained and actionable.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by clarifying 'since' semantics ('filings since `since`') and giving a concrete recommendation ('Use "30d" or "1m" for typical monitoring'). It also reinforces the type parameter's limitation to 'company'.

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

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

The description clearly identifies this as a 'change feed for a company in the last N days/weeks/months' with specific verbs like 'what's new' and 'latest'. It also distinguishes itself from the sibling tool entity_profile by explicitly stating when to use that 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?

Provides explicit usage scenarios: 'What's new with X' / 'latest on Y' and the alternative: 'Use entity_profile instead when you want the static profile...'. It also gives specific guidance for the 'since' parameter ('Use "30d" or "1m" for typical monitoring').

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 non-read-only, non-destructive, and idempotent. The description adds useful context beyond annotations: scoping by identifier, persistent memory for authenticated users, and 24-hour retention for anonymous sessions. This gives meaningful behavioral detail without contradicting annotations.

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

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

The description is front-loaded with the core action and purpose. Sentences are purposeful, covering what, when, storage, persistence, and companion tools. It is slightly longer than strictly necessary but all information is relevant and no filler exists.

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 write tool with no output schema, the description adequately covers purpose, use cases, persistence behavior, and related tools. It does not describe return values or overwrite behavior, but given the tool's simplicity and annotations, these are not critical 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 100% of parameters with descriptions that include examples. The description reinforces the key-value pair concept and provides domain examples (ticker, address, preference, research subject), but does not add substantial new parameter-level 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?

Description states a specific verb ('Save data') and resource ('data the agent will need to reuse later') with clear scope ('across conversation or sessions'). It distinguishes from siblings by explicitly pairing with recall and forget, showing this is the write operation in a memory triad.

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

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

Provides clear context: 'Use when you discover something worth carrying forward' and gives concrete examples. It also notes session vs authenticated persistence. However, it does not explicitly state when NOT to use or name alternative tools other than recall/forget, so it lacks full exclusion criteria.

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

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

Annotations already mark the tool as readOnly, idempotent, and non-destructive. The description adds significant behavioral detail: cascading internal lookups, graceful degradation (if GLEIF/OpenFIGI unavailable, EDGAR still returns), and explicit labeling of unresolved identifiers under an 'unresolved' field. This goes well beyond the annotations and fully informs the agent of the tool's behavior.

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

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

The description is informative but lengthy (multiple paragraphs). It is front-loaded with examples and purpose, which is good, but includes redundant detail (e.g., repeated mention of graceful degradation, internal cascading). A more streamlined structure would improve readability without losing essential information.

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

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

Given the complexity (two entity types, multiple identifiers, cascading lookups, unresolved handling) and the lack of an output schema, the description covers return behavior thoroughly: identifiers by source, unresolved marker, graceful degradation. It does not explicitly state the output format (e.g., JSON object), but the agent can infer from the verbal description. Slightly more detail on the structure would raise this to 5.

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

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

Schema coverage is 100% with both parameters described. The description adds meaning beyond the schema by explaining how to use the 'value' parameter (e.g., 'An ISIN like "CH0038863350" resolves to the LEGAL ENTITY that issued the security'). It also clarifies acceptable input formats for 'company' type (ticker, CIK, ISIN, name). This enriches 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 opens with clear example queries and states the tool's purpose: 'resolve a user-spoken NAME to the canonical/official identifiers other tools require as input.' It specifies supported types (company, drug) and what identifiers are returned. However, it does not explicitly distinguish itself from the sibling tool 'entity_profile', which may also resolve entities, so differentiation is incomplete.

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 FIRST whenever you have a name but need an ID.' It gives numerous query examples to illustrate when to invoke. It does not describe when NOT to use the tool or mention alternatives like 'entity_profile', but the context is clear enough for most name-to-ID 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, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds value by explaining the internal process ('Probes each entity with ai_visibility_check, ranks by score') and the return shape ('ranked list with score, confidence, signal density per entity'). This goes beyond redundant safety disclosure, though it doesn't address rate limits or failure modes.

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, each earning its place: purpose, method, use case, and output. It is front-loaded with the main action, uses precise language, and contains zero filler. The structure allows rapid parsing for an agent.

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

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

Given the tool's moderate complexity, no output schema, and strong sibling differentiation, the description is complete. It explains the orchestration (probes with ai_visibility_check), the input semantics (entities with first-as-subject), and the return fields (score, confidence, signal density). Annotations cover safety, and the use case clarifies when to invoke it. No critical information is missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add parameter semantics beyond what the schema already provides (e.g., 'First entry treated as the subject' is already in entities description). It reinforces the 'probe' concept but does not explain parameter formats or constraints beyond schema. Thus it meets the baseline without exceeding 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 opens with a specific verb+resource: 'Compare AI visibility across multiple entities side-by-side.' It clearly distinguishes from siblings like ai_visibility_check (single entity) by mentioning 'multiple entities' and the probe/rank behavior. It also states what it surfaces (most/least recognized), 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 provides clear context: 'Useful for competitive AI-marketing audits' with a concrete example question. It implies when to use it (multi-entity comparison) and even references the underlying ai_visibility_check, suggesting the single-entity alternative. However, it does not explicitly state when NOT to use it or name alternative sibling tools, so it stops short of full 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?

The description adds substantial behavioral context beyond the annotations: it reveals the fan-out architecture, the 5-30s possible delay on first bundlephobia measurement, graceful degradation with sources_failed, and NPM-only scoping. This goes far beyond the readOnlyHint/idempotentHint annotations and poses 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 front-loaded with a concise purpose statement, then efficiently covers use cases, return payload fields, ecosystem limitations, and failure behavior in four more sentences. Every sentence carries unique, necessary information with no filler.

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

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

Given there is no output schema, the description compensates by enumerating all return fields (summary block fields, per-advisory details, links, alternative versions), covering partial failures and timeout behavior, and noting ecosystem exclusions. This makes the tool fully understandable and safe to invoke.

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

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

The input schema already has 100% coverage for both parameters with accurate descriptions. The tool description adds contextual ecosystem framing but no new parameter-level semantics, so the baseline score for high schema coverage 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 defines a composite 'should I add this npm package' check with specific verb and resource, spanning deps.dev and bundlephobia and listing the exact output categories. It distinguishes itself from sibling tools (e.g., scan_competitor_ai_presence, compare_entities) by focusing on npm dependency evaluation.

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

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

Explicit usage triggers are given: 'is X safe / popular / small' or 'what does adding lodash cost me'. It also states when NOT to use it (non-NPM ecosystems) and directs users to deps.dev:version directly for PyPI, Maven, Cargo, and Go.

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

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

Annotations already declare readOnly/idempotent/non-destructive, but the description goes well beyond: it discloses the embedding model (BGE-base-en), the 500-char overlapping window, the 200K char cap with truncation flagging, and the exact output shape (passages with offsets and similarity scores). This gives the agent a thorough understanding of behavior.

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

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

The description is dense but every sentence earns its place: what it does, when to use it, return value details, and a caveat about truncation. It is front-loaded with the core purpose and avoids fluff.

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

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

Despite lacking an output schema, the description fully explains the return format (top-N passages, offsets, similarity scores), the algorithmic behavior, and the integration with ask_pipeworx_grounded. This gives an agent everything needed to predict tool output and handle edge cases like truncation.

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 rich descriptions (e.g., limit range, query examples, text max chars). The description adds little beyond repeating what the schema already says. It reinforces the text cap and query purpose but does not introduce novel parameter semantics, so the baseline of 3 applies.

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

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

The description opens with a specific verb+resource: 'Semantic search INSIDE a fetched record.' It clearly distinguishes itself from siblings by explaining how it pairs with ask_pipeworx_grounded and by emphasizing that it returns only relevant passages with offsets, unlike a full-document retrieval approach.

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

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

Explicit usage context is given: 'Use when the record is too big to cram into the prompt.' It also provides a clear alternative pathway via ask_pipeworx_grounded and implies when not to use (when you need the whole document). This is strong practical guidance for an agent.

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

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

Annotations are present (readOnly=false, destructive=false, idempotent=true, openWorld=true) and the description richly supplements them. It discloses authentication prerequisites, supported subscription types, delivery channel behavior, phone verification, SMS caps, webhook HMAC signing, one-time secret return, and auto-disable after 10 consecutive failures. 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 a single dense paragraph but every sentence adds value. It front-loads the core action and return value, then covers types and delivery. It could be improved with bullet points for readability, but it avoids fluff and 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 the tool's complexity (3 params, nested objects, multiple subscription types, multiple delivery channels), the description is remarkably complete. It covers auth prerequisites, type-specific parameters, delivery options with operational details, limits, and security behavior. The absence of an output schema is mitigated by the explicit 'Returns the new subscription id'.

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

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

Schema coverage is 100%, but the description adds semantic meaning beyond the schema by explaining what each subscription type does (e.g., sec_8k = 8-K filings matching ticker + item codes, polymarket_edge = cross-venue mispricings) and by elaborating delivery channel semantics (e.g., webhook signing secret returned once). This exceeds the schema's structural examples.

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

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

The description opens with a specific verb-resource pair: 'Create a proactive monitoring subscription to a live-data event stream' and notes the return value. It enumerates supported types (sec_8k, polymarket_edge, fred_series, etc.), distinguishing it clearly from sibling tools like list_subscriptions and unsubscribe.

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

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

Provides clear usage context: requires a Pipeworx OAuth account, anonymous/BYO cannot persist subscriptions, and mentions alternative pull mechanisms ('pull via recent_alerts or GET registry.pipeworx.io/alerts.json'). It does not explicitly state when not to use this tool vs alternatives, but the proactive-monitoring framing and auth caveat offer solid 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, idempotentHint=true, and destructiveHint=false, so safety is covered. The description adds value by disclosing the return structure—category-bucketed example questions with tool+argument shapes—and noting that results come from a 'live catalog of thousands of tools.' This goes beyond the annotations without contradicting them.

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

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

The description is long but every sentence earns its place: it front-loads natural language examples, explains the return value, covers usage modes, and ends with a clear directive. There is no redundant or filler 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?

With only one optional parameter and no output schema, the description fully compensates by detailing the return format (category buckets, tool+argument shape), the two calling modes (full spread vs. topic focus), and the onboarding context. It leaves no critical gap for an agent deciding how and when to call it.

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

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

Schema coverage is 100% and the schema already describes the 'topic' parameter with its allowed values. The description reinforces this with examples ('finance', 'pharma', 'betting'), which is helpful but does not add substantive new meaning beyond the schema's own 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 that the tool is an onboarding entry point that returns category-bucketed example questions with the exact tool and argument shape to answer them. It distinguishes itself from sibling tools by explicitly telling agents to 'Use this FIRST' when unsure of Pipeworx's capabilities, rather than being a general query tool.

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

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

The description gives explicit when-to-use guidance: 'Use this FIRST when you do not yet know what Pipeworx can do for you, or to learn how to call the meta-tools.' It also explains the two invocation modes (no args vs. a topic), providing clear context for the agent.

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

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

The description adds no behavioral context beyond the annotations, which already declare the tool as read-only, idempotent, and non-destructive. It does not mention timezone, format, or any potential 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 the minimum possible: two words. It is front-loaded and contains no filler.

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

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

Given the tool's simplicity (no parameters) and the presence of an output schema, the description is nearly sufficient. However, it could specify timezone or format for full clarity.

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 tool has zero parameters and the input schema is empty, so the description need not elaborate on parameter meanings. The baseline score for zero-parameter tools is 4.

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

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

The description 'Server time.' clearly identifies the resource as time from the server, but lacks an explicit verb. It is sufficiently specific to distinguish from sibling tools, none of which are time-related.

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 regarding when to use this tool versus alternatives. The description is just a noun phrase with no context or exclusions.

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

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

Annotations indicate not read-only, idempotent, and non-destructive. The description adds significant behavioral context: ownership is enforced (can only cancel your own), the row is deactivated not deleted, and historical events remain available via recent_alerts. This goes beyond the structured hints and clarifies 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?

Three sentences with zero waste: purpose, ownership constraint, and non-destructive consequence. Each sentence earns its place and is front-loaded with the core action.

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

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

For a simple one-parameter tool, the description covers the action, ownership rule, and outcome regarding historical data. It doesn't explicitly mention error behavior, but given the simplicity and good annotations, it is largely complete. A small gap is what happens on invalid id or unauthorized attempt, but that is not critical.

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 already describes the id parameter as 'Subscription id (uuid) returned by subscribe.' The description adds no further parameter meaning beyond 'by id', 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 'Cancel a subscription by id' is a specific verb+resource+method statement. It clearly distinguishes from sibling tools like subscribe (create), list_subscriptions (list), and recent_alerts (historical events).

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

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

The intended usage is clear: use this to cancel a subscription. It mentions ownership enforcement and that deactivation preserves history via recent_alerts, which implies the alternative for viewing historical events. It does not explicitly state 'when not to use' but the context is sufficient.

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

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

Annotations already declare read-only and non-destructive, but the description adds crucial behavioral context: it distinguishes could_not_verify (check did not happen, must not be shown as evidence) from unsupported (no source found). It also details the internal pipeline routing, which is beyond what annotations provide. 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?

Though lengthy, every sentence earns its place: trigger phrases, usage, routing logic, verdict semantics, and caller warnings are all packed into a well-structured, front-loaded description. No fluff or redundancy.

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

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

Despite no output schema, the description fully explains the return values (verdict list, actual value, citation, reasoning) and the special meanings of could_not_verify and unsupported. It covers purpose, usage, behavior, and parameter context comprehensively, making it highly invokable.

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 (claim, tolerance_pct) have clear descriptions in the schema. The description does not add significant parameter-specific meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly identifies the tool as natural-language claim verification with explicit trigger phrases ('fact check', 'verify the claim that...'). It distinguishes from siblings by describing the structured SEC EDGAR fast path for company-financial claims and the grounded pipeline for all other claims, making its unique role 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?

Usage is explicitly stated: 'Use whenever the agent needs to check whether something a user said is factually correct.' It also explains the routing between financial and non-financial claims and notes it replaces 4-6 sequential calls, steering agents away from alternative pipelines. This is strong when-to-use/why guidance.

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