Maryland Open Data

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive hints. The description adds behavioral context: it is a 'probe' (non-destructive), requires a BYO key for Anthropic, and returns structured per-model results including score, confidence, signals, and raw_response.

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 (about 4 sentences) and front-loaded with the core purpose. Every sentence adds value, covering usage, model options, and return structure without unnecessary detail.

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

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

Given the tool has no output schema, the description compensates by detailing the return shape (per-model {score, confidence, signals, raw_response} + combined view). It also explains the optional parameters and default models. It is largely complete for a read-only probe 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 the description adds minimal new parameter info. It reiterates the entity field with an example and notes the default model, but the schema descriptions already cover the fields 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 clearly states the tool's purpose: it probes LLMs to score visibility (0-100) for a given entity. The verb 'Probe' and resource 'LLMs' are specific, and the output (score per model) differentiates it from sibling tools like scan_competitor_ai_presence.

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

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

The description explains when to use: for AI-marketing audits, pre-launch brand checks, competitive monitoring. It also clarifies model usage (default free Workers AI, optional Anthropic with API key). However, it does not explicitly exclude cases or compare to alternatives like scan_competitor_ai_presence.

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?

Despite strong annotations (readOnly, openWorld, idempotent, non-destructive), the description adds significant behavioral context: it routes to 5,529 tools, returns stable citation URIs, works on every tier, makes one fast call, and even handles breaking news. No contradictions with annotations; it enriches the agent's understanding of expected 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 longer than average, but every section earns its place: preference over web search, scope, examples, and escalation paths. It is front-loaded with the critical 'PREFER OVER WEB SEARCH' instruction and organized logically, though a few phrases are slightly redundant (e.g., 'START HERE' and 'default entry point').

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 broad, general-purpose tool with no output schema, the description is remarkably complete: it covers the tool's purpose, domain coverage, return format (structured answer with citation URIs), latency, availability, and when to escalate to sibling tools. Given the tool's complexity, this level of contextual detail is exemplary.

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 with six aliases for the single 'question' parameter. The description adds no additional parameter-level semantics beyond showing example questions, which the schema already includes. Baseline 3 is appropriate because the schema does the heavy lifting.

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

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

The description clearly states the tool's role: a general question-answering entry point that routes queries across thousands of verified sources and returns structured answers with citations. It explicitly distinguishes itself from siblings like ask_pipeworx_grounded and deep_research, making its purpose unambiguous.

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

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

Provides explicit when-to-use and when-not-to-use guidance: 'START HERE for most questions', and directs specific use cases to alternatives ('for a hallucination-resistant single answer... use ask_pipeworx_grounded; for a broad/multi-part question... use deep_research'). Also lists trigger phrases and examples, making selection straightforward.

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

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

Beyond the annotations (readOnly, idempotent, non-destructive), the description discloses the experimental nature, that routing improvements are enabled live when under test, and that currently no candidate is active so behavior matches ask_pipeworx exactly. It also clarifies 'falls back to nothing' meaning it is a full working router, preventing misinterpretation as a partial or stub.

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 'Beta version of ask_pipeworx,' and packs essential operational details (identical tools/arguments/response shape, live testing, current parity with stable, full router status) without fluff. Every clause contributes meaningful 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 router with no output schema, the description covers the return shape by reference ('same response shape') and fully explains the beta/experimental context, current behavior, and fallback semantics. It addresses the complexity of the 5,529-tool scope and provides sufficient context for an agent to select and invoke it appropriately.

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

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

Schema description coverage is 100%, with all six parameters documented as aliases for the main 'question' field. The description adds no additional parameter semantics beyond noting 'same arguments' as ask_pipeworx, which merely reflects the schema. Baseline 3 is appropriate since the schema carries the full burden.

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

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

The description states a specific verb and resource: it is a 'universal router' that routes natural-language questions to 5,529 tools, with the same arguments and response shape as ask_pipeworx. It explicitly differentiates from siblings by highlighting its beta status and live candidate routing improvements, making it clear this is the experimental variant of ask_pipeworx.

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

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

The description clearly states when to use this tool: 'Use it exactly like ask_pipeworx when you want the newest routing.' It also implies testing intent by noting results are compared against the stable router. However, it does not explicitly name alternatives or provide a when-not-to-use exclusion, though ask_pipeworx is implicitly the stable alternative.

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 critical behavioral traits beyond the annotations: it is refusal-capable with specific refusal_reason values (not_in_source, no_tool_match, etc.), returns structured evidence with verbatim quotes, and costs one extra LLM call. The annotations already indicate read-only/idempotent behavior, but the description adds valuable context about how the tool handles missing or ambiguous data and the cost tradeoff, which is essential for an agent to invoke it appropriately.

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, front-loaded with the core purpose. Each sentence provides distinct, high-value information: the process, the return format, refusal reasons, use cases, and cost comparison. A minor deduction because it reads as a single block of text without bullet points or paragraph breaks, but every sentence earns its place 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 tool with this complexity (routing across 5,529 tools, grounding, refusal logic), the description is remarkably complete. It covers what happens on success and failure, the exact return shape, the input type, the primary use case, and the cost tradeoff relative to the sibling. The absence of an output schema is compensated by the explicit return structure in the description. Sibling differentiation is also handled well via the mention of ask_pipeworx and the 'casual lookups' preference.

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 description coverage is 100% — every parameter has a description, including aliases. The description itself adds little about parameter semantics beyond noting that the tool 'fills arguments' internally, which is more about the tool's internal routing than the question parameter. The schema already explains that question is a natural-language query. Baseline 3 is appropriate when schema does the heavy lifting, and the description does not meaningfully extend parameter understanding.

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

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

The description clearly states the tool's purpose: a hallucination-resistant answer mode for high-stakes reads. It specifies the process (routing, fetching, extracting) and explicitly distinguishes itself from its sibling ask_pipeworx by focusing on grounded, evidence-based answers. The verb 'extracts' and the focus on 'ONLY what the tool result contains' unambiguously communicates what it does.

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

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

Usage guidance is explicit and actionable: use when an answer will be quoted, cited, or acted on and must not invent facts (financial verdicts, legal claims, medical lookups, public statements). It also provides a clear exclusion: prefer ask_pipeworx for casual lookups due to the extra LLM call cost. This directly addresses when and when-not to use the tool versus alternatives.

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

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

Adds extensive behavioral context beyond annotations: resolver contract, parent event extractor, safety mechanisms, resolution-rule risk, and error handling for closed/low-confidence markets.

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?

Very long description with dense information, but front-loads core purpose. Could be more concise; structure is functional but not optimized for quick scanning.

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

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

Comprehensively explains output shapes, evidence structure, edge cases (illiquid, closed, low-confidence), and cancellation rules—essential since no output schema is provided.

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

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

Schema coverage is 100%, and the description enriches parameter meaning with usage examples, format variations (slug/URL/question), and the effect of depth/include_raw.

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

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

The description clearly states the tool researches Polymarket bets and returns data, but does not explicitly differentiate from sibling tools like polymarket_edges or ask_pipeworx.

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

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

Provides clear use cases ('should I bet on X') and examples of classifiers and fan-outs, but lacks explicit when-not-to-use guidance or alternative tool suggestions.

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

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

Annotations mark it as read-only, idempotent, and non-destructive. The description adds detailed behavioral information: data sources (SEC EDGAR/XBRL for companies, FAERS for drugs), handling of off-calendar fiscal years, and sorting by primary metric.

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?

Packed with useful information but slightly verbose. Front-loads example queries effectively. Could be trimmed slightly without losing clarity.

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

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

Given the tool's complexity (two entity types with different data sources), the description is remarkably complete. It covers data sources, return format, sorting, and even mentions citation URIs. No output schema is needed.

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

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

Schema coverage is 100%, and the description significantly enhances understanding. It explains the meaning of the 'type' enum values and the 'values' array format, including examples and constraints.

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

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

The description clearly states the tool's purpose: side-by-side comparison of 2-5 companies or drugs. It provides specific example queries and distinguishes itself from sequential single-pack lookups.

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

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

Explicitly recommends this tool over sequential lookups and lists typical query patterns. Does not explicitly state when not to use, but the context is clear enough for an AI 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 already provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds context about the specific catalog and return fields, which is useful 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 two concise sentences, front-loading the purpose and results, with 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?

Together with the schema and annotations, the description provides complete context: what the tool does, its parameters, return values (via description), and behavioral traits. No output schema needed as return fields are listed.

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

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

The input schema covers all parameters with descriptions (100% coverage). The description does not add extra parameter-level details, so a 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 states the tool searches the Maryland Open Data catalog by keyword, lists the specific fields returned (resource_id, name, description, category, update date), and distinguishes from siblings by mentioning to pass resource_id to query/metadata.

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

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

The description explicitly says to use this tool to search by keyword and what to do with the results (use resource_id with query/metadata). It does not explicitly state when not to use it, but the use case is clear enough.

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

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

Annotations declare readOnly/openWorld/idempotent hints, but the description adds substantial behavioral context: account sign-in needed, paid tier for thorough, parallel routing to 5,529 tools, findings packet structure (verbatim evidence, confidence, source, fetched_at, pipeworx:// citation), gaps[] never invented, contradictions[] for standard/thorough, semantic excerpting of large records, and expected latency. 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 dense paragraph, not scannable, but every sentence carries operational value (latency, citation resolvability, gap handling, full return packet). It is longer than typical, but the tool's complexity justifies the detail; still, bullet points or section breaks would improve readability.

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

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

With no output schema, the description fully compensates: it details the return packet (verbatim evidence, confidence, source, fetched_at, pipeworx:// citation, gaps[], contradictions[], hop field), explains depth semantics and second-hop iteration, covers account/payment constraints, and sets time expectations. This gives an agent everything needed 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?

The input schema already documents both parameters with 100% coverage, so baseline is 3. The description adds meaning by explaining `depth` behavior (quick/standard/thorough with facet counts, gap-recovery hops, and contradiction scans) and by emphasizing that `question` can be broad/multi-part because decomposition is the point. This exceeds baseline.

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

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

The description clearly states the tool's purpose: 'Grounded multi-source research across Pipeworx's 1455 STRUCTURED data sources' in one call, explicitly noting it is NOT open-web search. It differentiates from sibling tools by naming ask_pipeworx as the alternative for single lookups and breaking news, and describes the decomposition/routing behavior that makes this tool distinct.

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 and when-not-to-use guidance: 'Best for broad/multi-part questions over structured data' and 'For a single lookup use ask_pipeworx' / 'For BREAKING or colloquial CURRENT-NEWS... prefer ask_pipeworx'. It also provides an account-gated conditional ('If you are not signed in, use ask_pipeworx instead') and explains depth-tier selection.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds context about the output being 'ready to call directly, no second schema lookup needed', which is a behavioral trait beyond annotations. No contradictions.

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

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

The description is well-structured: purpose first, followed by examples, output description, and usage guidance. It is slightly verbose but every sentence adds value. Could be tightened slightly but overall efficient.

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

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

For a tool with 6 parameters (100% schema coverage) and no output schema, the description explains the output format (top-N tools with schemas and examples) and the aliases. It covers all necessary context for an agent to use it effectively. Missing explicit details on pagination, but limit parameter covers that.

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

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

Schema description coverage is 100%, so baseline is 3. The description reiterates that query accepts aliases and gives examples, but does not add significant new meaning beyond the schema's parameter descriptions. It meets the baseline 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 clearly states 'Find tools by describing the data or task' and provides extensive examples of domains (SEC filings, FDA drugs, etc.). It distinguishes from sibling tools by instructing 'Call this FIRST when you have many tools available' and describing the output as a set of tools ready to call, which differentiates it from direct data query tools like 'query' or 'search_within'.

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

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

Explicitly says 'Call this FIRST' and lists many use-case examples. It implies when not to use (when you already know the tool), but could be more explicit about alternatives. Still, the guidance is clear and actionable.

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

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

Annotations already provide read-only and idempotent hints. Description adds valuable context about patent API sunsetting and soft-fail behavior, plus parallel call nature.

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

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

Single paragraph, front-loaded with example queries, dense but organized. Could benefit from bullet points for returned fields, but still concise given 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?

No output schema, but description fully enumerates all return fields (cik, company_name, recent_filings with URIs, fundamentals, patents, news, LEI), including limitations and data sources.

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

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

Schema coverage is 100% with descriptions; description reinforces formats (ticker vs zero-padded CIK), adds example values, and clarifies that names are not supported, adding beyond schema.

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

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

Description clearly states it provides a full cross-source profile of a US public company in one parallel call, with example queries and explicit distinction from chaining single-pack lookups.

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

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

Explicitly says to use when user asks for a holistic view, and warns that names are not supported (use resolve_entity first). Also states 'ALWAYS PREFER over chaining single-pack lookups'.

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 description confirms deletion but doesn't add new behavioral context beyond what annotations provide.

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

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

Two concise sentences with no redundant information, front-loaded with key 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 single-parameter destructive tool with clear annotations and sibling references, the description covers all necessary context.

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

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

Schema covers 100% of parameter documentation; description adds no extra meaning beyond schema's description of 'Memory key to delete'.

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

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

The description uses specific verb 'Delete' with resource 'previously stored memory' and explicitly mentions sibling tools 'remember' and 'recall', clearly distinguishing its purpose.

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

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

Provides explicit when-to-use guidance: 'when context is stale, the task is done, or you want to clear sensitive data' and directs agent to pair with related 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?

Describes the process (fetches, extracts, emits) and output format beyond annotations. Annotations already cover safety, so description adds behavioral detail.

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

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

Concise single-sentence introduction plus bullet uses. Slightly redundant 'Useful for' repeats purpose, but overall efficient.

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

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

For a simple tool with rich annotations and no output schema, description explains output format and process completely.

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 adequately. Description adds no extra meaning beyond schema defaults and max.

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

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

Clearly states the verb (generate), resource (llms.txt file), and purpose (AI crawler indexing). Distinguishes from siblings by unique output format and use cases.

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

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

Explicitly lists useful scenarios (client indexing, own project, competitor audit). Lacks explicit when-not-to-use, but context is clear.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false. Description adds that it returns specific fields and defaults to active subscriptions, but no major behavioral gaps.

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

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

Two concise sentences: first states purpose and return fields, second gives usage guidance. No redundant information.

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

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

With low parameter count and rich annotations, the description fully explains purpose, return values, and usage. No output schema needed as return fields are listed.

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

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

Schema covers the single parameter with description. Description repeats the schema info ('Include cancelled subscriptions... default false'), adding no new meaning beyond what schema already 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?

Description states exactly what the tool does: 'List the caller's active subscriptions' and lists the return fields. Clearly distinguishes from sibling tools like subscribe/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 explicit usage context: 'Use this to review what you're monitoring before adding more or to find an id to cancel.' Implicitly guides when not to use (e.g., for subscribing).

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

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

Annotations already indicate readOnly, idempotent, and non-destructive behavior. The description adds value by specifying the exact metadata returned (columns, types, row count, category, last-updated), which compensates for the absence of an output schema. No contradictory information.

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

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

The description is a single, well-structured sentence that efficiently conveys the tool's purpose, input, and output. Every word adds value, with no redundancy or unnecessary detail.

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

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

Given the simple input schema (one required parameter) and no output schema, the description completely specifies what the tool does and what it returns. It is sufficient for an AI 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 coverage is 100% with a clear description for resource_id. The description reiterates the parameter context and provides an example, but does not add new semantic depth beyond the schema. Baseline 3 is appropriate as the description reinforces but does not extend 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 verb 'Get' and the resource 'dataset's schema + metadata', with specific fields listed (columns, types, row count, category, last-updated) and an example resource_id. It effectively distinguishes this tool from siblings like 'datasets' which likely list available datasets.

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

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

The description implies usage by stating the need for a resource_id, but does not explicitly state when to use this tool versus alternatives, nor does it provide conditions or prerequisites. While clear enough for basic use, it lacks guidance on exclusions or preferred 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?

Beyond the neutral annotations (all false), the description discloses rate limits (5 per identifier per day), pricing (free, doesn't count against quota), the claim_token mechanism for later retrieval, and the human review process (daily digests, roadmap impact). This gives the agent a clear model of side effects and expectations.

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

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

The description is long but every sentence earns its place: purpose, exclusions, framing advice, claim_token flow, rate limits, pricing, and roadmap impact. It is front-loaded with the core purpose and logically structured, with no redundant phrases or vague filler.

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

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

For a tool with no output schema and a nested context object, the description fully covers the feedback lifecycle: how to submit, what to expect (claim_token), how to check resolution, and the human-side commitment (daily digests). The agent has everything needed to invoke and follow up correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful guidance for `message` (be specific, 1-2 sentences, 2000 chars max) and `claim_token` (pass it back later with no other arguments), though much of the claim_token behavior is already in the schema description. It improves but doesn't drastically transcend 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 opens with a specific verb+resource ('Tell the Pipeworx team something is broken, missing, or needs to exist') and immediately names concrete categories (bug, feature/data_gap, praise). It also scopes the tool exclusively to Pipeworx connection tools, making it unambiguous versus any sibling feedback or support tool.

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

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

Provides explicit when-to-use guidance for each feedback type and an explicit when-not-to-use for tools from other MCP servers, even directing the agent to file those elsewhere. It also gives practical framing advice ('describe in terms of Pipeworx tools/packs — don't paste the end-user's prompt'), which is actionable and distinct from 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 mark the tool as read-only, idempotent, and non-destructive. The description adds crucial behavioral details: data source (CF analytics-engine), PII handling ('no PII'), data shape (pack, tool, count), and caching behavior ('Cached 5min-1h depending on window'). No contradictions.

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

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

The description is a single tightly written paragraph: front-loaded with the core output, then use cases, then technical notes. Every sentence serves a purpose 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?

Despite no output schema, the description fully describes what is returned (top tools, top packs, total call volume) and key behavioral traits (caching, no PII). The tool is simple with one parameter, so completeness is high.

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

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

Schema has 100% coverage with a clear enum and description for the single parameter. Description adds semantic value by explaining the trade-off between short and long windows, which goes beyond the schema.

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

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

The description explicitly states it returns 'top tools, top packs, and total call volume over a recent window (24h, 7d, or 30d)'. This clearly distinguishes it from sibling tools like 'discover_tools' and 'ask_pipeworx' by focusing on aggregate trending data.

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

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

Three specific use cases are listed, and guidance is given for window selection ('Shorter windows surface what's hot right now; longer windows show steady-state demand'). No explicit when-not-to-use instruction, but context is clear enough.

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

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

Annotations declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds rich behavioral context: scans top ~200 markets, performs date-axis/threshold-axis ordering, partition-sum checks, Jaccard similarity filter, placeholder filtering, and fill check using CLOB depth. No contradiction with annotations.

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

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

Description is well-structured and front-loaded with purpose, but is lengthy due to detailed technical explanations. Every sentence earns its place, but could be slightly more concise. Still, the structure is logical and easy to follow.

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

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

Despite no output schema, description thoroughly explains return values (opportunities array with fields, partition_check object). Covers all aspects: mode differences, filtering criteria, fill check, and cross-event similarity. Complete guidance for an AI agent to select and invoke correctly.

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

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

Schema has 100% coverage with descriptions for both 'event' and 'topic'. Description greatly expands on each: provides examples of slugs, explains how each mode works internally (e.g., walks child markets, cross-event union), and adds critical details like semantic anchor and partition filter. Adds significant value beyond schema.

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

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

Description explicitly states 'Find arbitrage opportunities on Polymarket via monotonicity violations + partition-sum checks', specifies three distinct modes (trending_scan, event, topic), and distinguishes from sibling tools like polymarket_fill_risk. The verb-resource combination is clear and the tool's purpose is well-defined.

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

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

Provides explicit guidance: call with no arguments for trending_scan, use 'event' for specific markets, use 'topic' for cross-event scanning. Warns against trading when realizable_edge_pp ≤ 0 and directs to polymarket_fill_risk for custom sizing. All usage scenarios are clearly described.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint true, and destructiveHint false. The description adds rich behavioral context: caching (1h KV level), segmentation logic, diagnostics for empty results, and edge metrics (edge_pp_net, kelly_fraction, 24h-move warning). It also clarifies that Fed bets are excluded from ranking due to data limitations. 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 excessively long (over 300 words) and densely packed with technical details (model formulas, specific alpha values, funnel counters). While front-loaded with the core purpose, it lacks clear structure or sectioning, making it hard for an AI agent to parse quickly. Many sentences dive into implementation specifics that could be omitted or relegated to a separate guide.

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 the lack of an output schema, the description thoroughly covers the response structure (by_segment segments, fed_candidates, _diagnostics), caching behavior, and all parameter effects. It explains complex concepts like partition_overround and concentrated_longshot conditions, ensuring an agent can understand what the tool returns and how to interpret empty results.

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

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

Schema coverage is 100%, but the description goes beyond by explaining the purpose and recommended usage for each parameter (e.g., min_kelly skips small opportunities, slippage_pp accounts for bid/ask spread, min_partition_leg_kelly applies per-leg Kelly for partition arbs). It provides practical defaults and context (e.g., Polymarket zero fees but typical slippage).

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

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

The description clearly states the tool scans Polymarket markets to identify opportunities where Pipeworx data diverges from market price, specifically targeting the use case 'what should I bet on today'. It details three distinct segments (model-driven, structural arbitrage, concentrated longshot) and distinguishes itself from siblings like polymarket_arbitrage and polymarket_edge_tracker by focusing on Pipeworx data divergence.

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

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

The description provides explicit guidance on when to use the tool (discover opportunities without manual paging) and explains filtering knobs (min_liquidity, max_spread_pp, etc.). It also notes exclusions like Fed bets with a caveat about data unreliability. However, it lacks explicit comparison to sibling tools for specific scenarios, relying instead on the distinct purpose.

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 the tool is read-only and idempotent. The description adds valuable behavioral details: it reads from daily snapshots, uses only the latest snapshot for tracked data, and includes limitations like 60-day TTL and decay from daily closes.

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 key question and well-structured with sections for RESPONSE and LIMITS. It is informative but could be slightly more concise.

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

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

Without an output schema, the description comprehensively explains the response structure (tracked[], expired[], snapshot_dates[]) and includes limitations. For a tool with two optional parameters, this is thorough and covers all necessary context.

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

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

Schema coverage is 100%, so parameters are fully documented in the schema. The description adds usage context (defaults, clamps, snapshot family) but does not add significant meaning beyond the schema.

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

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

The description clearly states the tool provides edge persistence and decay telemetry from daily snapshots, answering the specific question of how long an edge has existed. It distinguishes from sibling tools like polymarket_edges by focusing on historical trends rather than 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: to differentiate between fresh wide edges and old wide edges. It implicitly contrasts with `polymarket_edges`, but does not explicitly state when not to use it or list 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 declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds behavioral context beyond annotations: it details that the tool walks the order book ladder, returns specific fields like slippage and verdict, and warns about forced directional risk. No contradictions.

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

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

The description is appropriately sized for the complexity. It front-loads the core purpose, then uses clear bullet-like structure for modes. Every sentence adds value, though slightly lengthy for a simple tool. Could trim some redundancy but overall 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?

Despite no output schema, the description fully documents return fields for both modes, usage prerequisites, and potential risks. It covers all four parameters thoroughly and provides enough context for an agent to invoke correctly.

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

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

Schema coverage is 100%, baseline 3. The description adds significant meaning: explains two modes (market vs event), side defaults and auto mode for baskets, and size_usd interpretation differs for single-market vs basket (max spend vs target proceeds, settlement notional). Adds value beyond schema.

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

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

The description clearly states the tool's purpose: 'Realizable-vs-theoretical edge check against live CLOB order-book depth.' It explicitly defines two modes (single-market and basket) and lists return fields, distinguishing it from siblings like polymarket_arbitrage and polymarket_edges.

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

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

Explicitly states when to use: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500.' Explains risks of not using it (partial fills, directional risk) and implies alternatives by naming 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 show read-only, idempotent, open world. Description adds safety fields, compatibility warnings, and temporal alignment checks. 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?

Dense but organized with sections. Slightly verbose but each sentence adds value.

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

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

Thorough coverage of response fields and safety conditions. Lacks explicit output JSON structure but compensates with detail.

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 descriptions are clear and complete (100% coverage). Description adds contextual semantics about modes and override behavior.

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

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

States it computes cross-venue spread between Kalshi and Polymarket. Distinct from sibling tools like polymarket_arbitrage which focus on a single venue.

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 describes two modes (topic vs explicit), warns about compatibility warnings, and explains when spreads are meaningless (e.g., temporal misalignment).

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 that the tool is read-only (consistent with readOnlyHint=true) and idempotent, returns matching rows as JSON, and uses SoQL clauses without leading $. It adds value beyond the annotations by detailing the query language and return format.

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

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

Two concise sentences: first sentence states the core action, second details filtering options. No wasted words, front-loaded with the essential verb and resource.

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 comprehensive schema descriptions (100% coverage), annotations, and no output schema required (just JSON), the description is fully sufficient for an agent to select and invoke the tool correctly. It covers the query language, required resource_id, and optional parameters.

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

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

With 100% schema description coverage, the baseline is 3. The description adds context about SoQL clauses (no leading $) and mentions limit/offset, which enhances understanding beyond the schema alone.

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 runs a Socrata SoQL query against a Maryland Open Data dataset by resource_id, with specific filtering options (where, select, group, order, limit, offset) and returns JSON. This distinguishes it from siblings like 'datasets' which are for listing datasets.

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 implicitly tells when to use the tool (to query a specific dataset with SoQL) via the specification of parameters and the resource_id. It does not explicitly contrast with sibling tools or state when not to use, but the context is clear enough for an AI 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 already declare readOnlyHint=true and destructiveHint=false. Description adds scoping to identifier and pairing with remember/forget, which are useful behavioral details beyond annotations.

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

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

Three sentences, each serving a distinct purpose: action, usage context, and pairing. Front-loaded with verb and resource. No 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?

No output schema, but description explains both retrieve and list behaviors, plus scoping. It could clarify error behavior (e.g., missing key), but not required for a simple read operation.

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

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

With 100% schema description coverage, the schema documents the key parameter. Description adds the dual behavior (retrieve vs list), reinforcing parameter meaning. The baseline is 3, and this adds value.

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 retrieves a value saved via remember or lists all keys when omitted. It distinguishes from sibling tools remember and forget by explicitly pairing with them.

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

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

It explains when to use (to look up stored context without re-deriving) and implicitly when not to use (use remember to save, forget to delete). No explicit alternatives mentioned, but the context is clear.

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

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

Annotations declare readOnlyHint: true, but the description states that setting mark_read:true will 'flag returned events read,' which is a mutation. This is a direct contradiction. Additionally, the description does not disclose other behavioral traits like rate limits or authentication needs, but the annotations already cover idempotency and non-destructiveness.

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 long, front-loaded with the core purpose, and each sentence adds value (filtering, mark_read, polling, alternative access). No fluff; every sentence earns its place.

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

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

Given no output schema, the description explains the return structure (source, citation_uri, payload). It covers all parameters, provides usage examples, and mentions alternative access. For a tool with 5 optional parameters and no required fields, this is complete.

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

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

With 100% schema description coverage, baseline is 3. The description adds meaningful context: explains type with example ('sec_8k'), specifies ISO timestamp format for since, clarifies mark_read and unread_only semantics. It slightly improves understanding 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 purpose: 'Pull fired events from your subscription feed. Returns the most recent alerts...' It uses specific verbs and resource names, and the scope is well-defined. It distinguishes itself from sibling tools like list_subscriptions or subscribe by focusing on retrieving alert 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 description provides guidance on filtering by type and timestamp, using mark_read for state management, and notes that polling is fine. It also mentions an alternative access method (direct URL). However, it does not explicitly state when to avoid using this tool or compare with siblings for similar functionalities.

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

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

Annotations already indicate safe read-only operation. Description adds: parallel calls to multiple sources, fallback logic, soft-failure for USPTO, output format with citations, and redirect to entity_profile for static data. No contradictions.

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

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

Description is well-structured and concise, starting with usage examples, then core functionality, parameter details, fallback, output, and sibling comparison. No wasted words.

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

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

Covers all necessary aspects: purpose, parameters, sources, fallback, output format, and when to use sibling. Despite no output schema, description provides sufficient return detail for an agent.

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

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

Schema coverage is 100% and description adds value beyond it: explains type constraint (only 'company'), since format with examples and typical values, value formats (ticker or CIK). All parameters are clearly documented.

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 defines the tool as a multi-source change feed for a company over a time window, using terms like 'What's new with X' and 'latest on Y'. It distinguishes from sibling tool entity_profile, leaving no ambiguity.

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

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

Provides clear when-to-use examples ('what's new with X', 'latest on Y'), fallback behavior (GDELT→GNews), and contrasts with entity_profile for static data. Offers parameter guidance ('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 provide idempotentHint=true and destructiveHint=false. The description adds valuable context: memory is scoped by identifier, authenticated users get persistence, anonymous sessions have a 24-hour TTL. 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?

Five sentences with no wasted words. Front-loaded with core purpose, then usage, scope, and technical details. Every sentence earns its place.

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

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

For a write tool with 2 parameters and clear semantics, description covers purpose, usage, persistence, and pairing. Missing: what happens on duplicate key, whether it returns success/confirmation, but overall 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?

Schema coverage is 100% with clear descriptions for both parameters. The description refers to 'key-value pair' but does not add meaning beyond the schema. Examples in description align with schema examples, 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: 'Save data the agent will need to reuse later.' It uses a specific verb ('Save') and resource ('data'), and distinguishes from siblings by mentioning pairing with 'recall' and 'forget'.

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

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

The description explicitly says 'Use when you discover something worth carrying forward' and lists concrete examples. It implies alternatives by naming sibling tools for retrieval and deletion, but does not explicitly state when not to use.

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

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

The description adds significant behavioral context beyond the readOnly/idempotent annotations: it details that identifiers come from SEC EDGAR, GLEIF, and OpenFIGI, that unresolved identifiers are explicitly listed under `unresolved`, and that LEI/FIGI enrichment degrades gracefully if sources are unavailable. It also discloses internal cascading through multiple lookup endpoints, giving a clear picture of tool 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 front-loaded with the core purpose and supported types, then structured into clear sections. It is long due to extensive examples and behavioral notes, but every part adds value—the example queries aid recognition, and the degradation note is important. It is verbose yet well-organized.

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

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

With no output schema, the description carries the burden of explaining return values. It does so thoroughly: for each type it lists the exact identifiers returned, mentions source labels, describes the `unresolved` field, and explains graceful degradation. This gives the agent a complete picture of what to expect and how failures are handled.

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 describes both parameters with 100% coverage, so the baseline is 3. The description adds meaning by explaining what each `type` resolves to (company: CIK/ticker/LEI/FIGI; drug: RxCUI/ingredient/brand) and clarifies input flexibility (ticker, CIK, or name). This enhances the agent's understanding of parameter impact 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 verb 'resolve' and the resource: 'user-spoken NAME to the canonical/official identifiers other tools require as input.' It lists concrete example queries and details the specific identifiers returned for each type, distinguishing it from sibling tools like entity_profile or query.

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 FIRST whenever you have a name but need an ID.' It also provides multiple example user utterances that should trigger this tool. However, it does not explicitly state when-not to use it or name alternative tools, though it implies that other tools consume these IDs.

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

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

Annotations declare readOnly, openWorld, idempotent, non-destructive. Description adds behavioral details: probes each entity with ai_visibility_check, ranks by score, returns ranked list with score/confidence/signal density. No contradiction with annotations.

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

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

Three concise sentences: first states main action, second explains mechanism, third gives usage example and output summary. No filler, front-loaded with purpose.

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

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

Despite no output schema, description clearly states return format: ranked list with score, confidence, signal density per entity. Covers input parameters and behavior completely for a comparison audit 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 has 100% coverage with descriptions for all 4 parameters. Description adds value by noting first entity is treated as subject for narrative and rest as competitors, and explains models parameter defaults. Provides context beyond schema.

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

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

Description clearly states verb 'compare' and resource 'AI visibility across multiple entities', with specific details about probing, ranking, and surfacing most/least recognized. Distinguishes from sibling ai_visibility_check (single entity) and compare_entities (generic comparison).

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

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

Explicitly frames usage as 'competitive AI-marketing audits' and provides an example question. Mentions underlying tool ai_visibility_check. Lacks explicit when-not-to-use or alternative naming but context is clear.

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

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

Describes partial failure degradation, timing (5-30s on bundlephobia), and return structure. No contradiction with annotations (readOnly, idempotent).

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

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

Single paragraph with front-loaded purpose and dense information. Every sentence adds value, though slightly lengthy.

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 content (summary block, advisories, links, alternatives) and failure behavior, making it complete for agent use.

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

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

Schema already covers both parameters with clear descriptions. The description adds no new parameter details beyond what is in the schema.

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

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

The description clearly states the tool performs a composite check for adding an npm package, covering license, advisories, version history, and bundle size. It distinguishes from siblings like scan_competitor_ai_presence by specifying the exact use case.

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

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

Explicitly tells when to use: when an agent asks about package safety, popularity, or cost. Also notes ecosystem limitations (NPM only) and directs other ecosystems to a different tool.

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

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

Annotations already declare readOnlyHint, idempotentHint, etc. The description adds critical behavioral details: truncation at 200K chars with flag, use of BGE-base-en embeddings, cosine similarity over 500-char overlapping windows, and return of character offsets for quote verification.

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

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

The description is relatively long but every sentence provides essential information. It front-loads the core purpose and then adds technical details. Could be slightly more concise, but 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?

Without an output schema, the description thoroughly explains return values (top-N passages, character offsets, similarity scores) and covers limitations (truncation). All necessary context for an agent to invoke correctly.

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

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

Schema coverage is 100%, and the description adds value beyond schema by explaining the text parameter's max size, providing query examples, and indicating the limit default. No further enhancement needed.

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

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

The description clearly states it performs semantic search inside a fetched record, provides concrete examples (SEC 10-K body, article), and distinguishes from sibling 'ask_pipeworx_grounded' by explaining how they pair together.

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

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

Explicitly says when to use (record too big for prompt, to save context) and when-not-to-use by suggesting alternative 'ask_pipeworx_grounded' for grounded querying over relevant passages.

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 idempotent and non-destructive behavior. The description adds value beyond annotations by explaining the return, subscription types, delivery constraints (e.g., 10/day SMS cap), and account requirements. No contradiction with annotations.

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

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

The description is dense but front-loads the core purpose. It covers prerequisites, types, and delivery options without wasted words. Could be improved with bullet points for readability, but remains efficient.

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

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

Given the tool's complexity (3 params, nested objects, no output schema), the description covers return value, type-specific params, and delivery constraints. It briefly mentions always-on feed and retrieval methods. Missing explicit details on subscription management, but those are covered by siblings.

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

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

The schema covers 100% of parameters with descriptions. The main description adds examples (e.g., items:['5.02'] = officer change) and clarifies the meaning of params for each type, improving understanding 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 verb 'Create' and the resource 'proactive monitoring subscription', and it specifies the return value 'Returns the new subscription id.' This distinguishes it from siblings like list_subscriptions (list) and unsubscribe (remove).

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 by stating the prerequisite (Pipeworx OAuth account), supported subscription types, and delivery channels. It does not explicitly exclude alternatives, but the context sufficiently guides when to use this tool (to create a subscription) versus other tools.

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

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

Annotations declare readonly, open-world, idempotent, non-destructive. The description adds context that it returns examples from a live catalog, but doesn't contradict annotations. No additional behavioral details beyond annotations.

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

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

The description is dense but slightly long (3 sentences). It front-loads the purpose and usage, but could be shortened slightly without losing meaning.

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

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

Given no output schema and rich annotations, the description fully explains the tool's output (category-bucketed examples with tool shapes) and when to use it. No gaps for this simple 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%, but the description adds example values (finance, pharma, etc.) and explains behavior with/without the topic parameter, providing extra clarity beyond the schema.

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

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

The description clearly states it returns category-bucketed example questions with tool+argument shapes, serving as the onboarding entry point. It distinguishes from sibling tools like ask_pipeworx by focusing on suggesting what to ask.

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

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

Explicitly says 'Use this FIRST when you do not yet know what Pipeworx can do for you' and mentions optional topic filtering. This provides clear when-to-use guidance.

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

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

Goes beyond annotations by explaining the row is deactivated (not deleted) and historical events remain accessible via recent_alerts. No contradiction with annotations; complements idempotentHint and destructiveHint.

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, no waste. Core function stated first, followed by key constraints and behavior.

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 single-parameter tool with no output schema, description covers ownership, idempotence (implied by deactivation), and historical data linkage. Provides sufficient context for correct invocation.

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

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

Schema coverage is 100%, so baseline is 3. Description adds minimal extra beyond referencing 'by id' and linking to subscribe; however, it does not elaborate on the id parameter's format 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?

Clearly states the action: 'Cancel a subscription by id.' Distinguishes from sibling tools like 'subscribe' and 'list_subscriptions' by specifying ownership enforcement and the deactivation mechanism.

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

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

Specifies ownership enforcement, implying when to use (own subscriptions) and hinting at limitations (cannot cancel others). Does not explicitly list alternatives but ties to recent_alerts 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?

Beyond the annotations (readOnly, idempotent, etc.), the description discloses crucial behavioral details: the two verification paths, the meaning of each return verdict, and especially the distinction between could_not_verify (check did not happen) and unsupported (no source exists). It also mentions verbatim evidence and citations, giving a rich understanding 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 long but densely packed with necessary information. It front-loads purpose and examples, then explains return values and edge cases. The 'IMPORTANT for callers' section is well-placed. While a bit verbose, every sentence serves a purpose, so it remains appropriate 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?

Given the tool's complexity and lack of output schema, the description provides a surprisingly complete picture: it explains return values, all possible verdicts, failure modes, pipeline selection, and usage constraints. It covers everything an agent needs to confidently invoke and interpret the results without additional documentation.

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

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

Schema coverage is 100% for both parameters, but the description adds valuable guidance: it explains tolerance_pct override semantics, recommends values for hallucination detection, and clarifies default behavior. It also provides example claims that illustrate the expected format. This goes beyond the schema descriptions.

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

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

The description clearly states the tool's purpose: natural-language claim verification against authoritative sources. It provides specific example phrasings and distinguishes itself from general Q&A or research tools by focusing on fact-checking claims. It also differentiates the two internal pipelines (SEC EDGAR for company financials, grounded otherwise), making the verb+resource specific.

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

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

The description explicitly states when to use the tool ('use whenever the agent needs to check whether something a user said is factually correct') and outlines the automatic routing logic. It does not explicitly name alternatives or say when not to use it, but it clearly implies this tool replaces multi-step manual lookup chains, providing effective usage guidance.

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