Missouri License Offices

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

Annotations already indicate readOnly, idempotent, openWorld hints, and description adds value by explaining cost implications (free default vs BYO key for Anthropic) and return structure (per-model score, confidence, signals, raw_response). No contradictions with annotations, and behavioral traits beyond what structured fields provide are disclosed.

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 (4-5 sentences) and front-loaded with the core action and outputs. Every sentence adds distinct value: action, default model, optional API key, return format, and use cases. No redundant or filler content.

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

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

Given the tool has 4 parameters, no output schema, but rich annotations, the description covers purpose, usage, parameter specifics, and return format. It is sufficiently complete for an AI agent to invoke correctly, though it could mention error handling or rate limits for API calls.

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

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

All parameters have descriptions in schema (100% coverage), and the description elaborates on their roles, including default models, API key purpose, and disambiguation via context. For example, it specifies that 'models' can be 'workers-ai' (free) or 'anthropic' (requires key), adding clarity beyond the schema.

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

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

Description clearly states the tool probes LLMs for knowledge about an entity and scores visibility (0-100). It identifies the action ('probe'), resource ('LLMs'), and output format. While it doesn't explicitly distinguish from similar siblings like 'scan_competitor_ai_presence', the use cases (AI-marketing audits, brand checks) provide enough context for differentiation.

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

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

The description explains default model usage and when to provide an API key for Anthropic, giving basic usage guidance. However, it lacks explicit instructions on when not to use this tool or comparisons to alternatives like 'scan_competitor_ai_presence'. The mention of 'AI-marketing audits' implies a context but is not definitive.

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

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

Annotations already establish read-only, open-world, idempotent, non-destructive behavior. The description adds useful operational context beyond that: it routes to 5,798 tools, fills arguments, and returns stable pipeworx:// citation URIs. This gives an agent a clear picture of how the tool behaves without contradicting the annotations.

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

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

The description is dense and front-loaded with the most important routing guidance, followed by examples and sibling distinctions. It is longer than average but nearly every sentence earns its place; the ending is slightly crammed, but the overall structure remains scannable.

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

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

For a complex routing tool with no output schema, the description is quite complete: it covers scope, example queries, return behavior (structured answer with citation URIs), and explicit alternatives. The only modest gap is that it does not describe the exact response shape or cite format, but the provided information is likely sufficient for correct tool selection and invocation.

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

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

The input schema already documents the `question` parameter and all five aliases with 100% coverage, so the schema carries the parameter semantics. The description adds example query phrasings but no new parameter-level detail, which matches the baseline of 3 for fully schema-covered parameters.

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 clear verb and resource: it routes a user's factual question to the right tool across verified sources and returns a structured, cited answer. It explicitly distinguishes itself from web search and from grounded/summarized sibling tools, so an agent can tell what ask_pipeworx is for.

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 opens with 'PREFER OVER WEB SEARCH' and gives explicit selection rules: use ask_pipeworx_grounded for a single grounded answer, deep_research for broad/multi-part questions, and asks_pipeworx handles breaking news via live news packs. It also lists trigger phrases and concrete example questions, making when-to-use guidance concrete and unambiguous.

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

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

Beyond the readOnly, idempotent, openWorld, and non-destructive annotations, the description discloses that candidate routing improvements are only enabled live when under test, that no candidate is currently active, and that this is a full working router with no fallback. This prevents the natural assumption that a beta tool is degraded or partially functional.

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: it front-loads the core definition, then gives current status, usage guidance, and a key caveat. Each sentence contributes operational context, with no filler, though the specific date and tool count are more detail than strictly necessary.

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

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

For an experimental router with no output schema, the description fully covers current behavior, equivalence to ask_pipeworx, invocation expectations, and evaluation context. An agent has enough information to decide when to call this tool and what to expect from it.

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

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

The input schema already documents all six parameters and aliases with 100% coverage. The description adds only the cross-reference that it takes the same arguments as ask_pipeworx, which is helpful but does not materially expand on the schema-provided parameter semantics.

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

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

The description clearly states this is the beta version of ask_pipeworx, a universal router with the same 5,798 tools, arguments, and response shape, plus candidate routing improvements. It is immediately distinguishable from the sibling ask_pipeworx and does not merely restate the tool name.

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 it exactly like ask_pipeworx when you want the newest routing, and clarifies that results are compared against the stable router. It does not explicitly state when not to use it, but the stable ask_pipeworx is implied as the alternative for non-experimental use.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, and the description adds substantial behavioral detail beyond that. It discloses that the tool extracts using ONLY the tool result, returns an explicit refusal with specific reasons such as not_in_source and data_truncated, and costs an extra LLM call, which is valuable operational transparency.

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

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

The description is longer than average but front-loaded with the most important distinction first, and every sentence earns its place by covering routing, behavior, return shape, refusal reasons, use cases, and cost trade-off. It is detailed but not padded, though it could be slightly trimmed around the internal routing explanation.

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

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

For a tool with no output schema, the description fully compensates by specifying the exact success response fields and all refusal reason variants. Combined with annotations, full parameter coverage, and sibling differentiation, an agent has everything needed to select and invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already fully documents the question parameter and all its aliases. The description adds no parameter-specific meaning, but with full schema coverage the baseline of 3 is appropriate.

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

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

The description uses a specific verb and resource: it is a hallucination-resistant, grounded answer mode that routes through Pipeworx and extracts answers only from tool results. It clearly differentiates itself from ask_pipeworx by emphasizing grounded extraction and high-stakes reads, so an agent can distinguish it from siblings immediately.

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 gives explicit when-to-use guidance with concrete high-stakes examples like financial verdicts, legal claims, medical lookups, and public statements. It also states when NOT to use it: prefer ask_pipeworx for casual lookups because grounded mode costs one extra LLM call. This is ideal routing guidance.

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

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

Annotations already indicate read-only and idempotent. The description adds extensive behavioral details: fan-out patterns, low-confidence short-circuit, closed market handling, wide-spread illiquidity, resolution-rule risk, and response structure. 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 thorough but verbose, with multiple paragraphs and repeated details. It could be more concise by omitting redundant classifier lists and examples. The structure is front-loaded with purpose, but overall length reduces conciseness.

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

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

Without an output schema, the description fully explains response shapes, including market analysis, evidence packet, resolver contract, parent events, news fields, and safety. It covers all necessary context for the tool's complexity.

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

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

Schema coverage is 100% with descriptions for each parameter. The description adds further context, such as the meaning of 'depth' (quick vs thorough) and 'include_raw' (when to set true), enhancing 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 it researches Polymarket bets by pulling Pipeworx data. It specifies inputs (slug, URL, or question text), process (resolve, classify, fan out), and outputs. While distinct from siblings, it could explicitly contrast with other Polymarket tools like polymarket_edges or polymarket_arbitrage.

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

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

Explicitly says 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z".' Provides context on when to use but does not specify when not to use or alternatives, though the use cases are 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 read-only, idempotent, non-destructive. The description adds valuable context: off-calendar fiscal year handling, sorting by primary metric, parallel call efficiency, and citation URIs. 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 well-structured, front-loaded with trigger phrases, and each sentence adds value. It is slightly verbose but appropriate for the tool's complexity.

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

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

Despite no output schema, the description mentions 'paired data + citation URIs' giving a general idea of return structure. For a 2-parameter tool, this is fairly complete, though more detail on output format could help.

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

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

Schema coverage is 100% with good descriptions. The description adds meaning beyond the schema: explains what data each entity type pulls and how results are sorted, enhancing parameter understanding.

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

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

The description uses explicit trigger phrases and clearly states it performs side-by-side comparison of 2–5 companies or drugs. It distinguishes between 'company' (SEC financials) and 'drug' (FAERS/fda counts) and highlights replacing sequential lookups, making it distinct from single-entity sibling tools like entity_profile.

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

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

The description explicitly says 'ALWAYS PREFER over sequential single-pack lookups when comparing entities,' providing strong guidance on when to use. It also explains what each type pulls, but does not explicitly mention when NOT to use or list alternative tools.

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

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

Annotations already signal read-only, open-world, idlempotent, non-destructive behavior, but the description adds substantial context: it never invents answers, returns explicit gaps[], includes fetchable citation URIs with a stability guarantee, flags contradictions at certain depths, semantically excerpts long records, and gives expected latency. It is exceptionally transparent about how the tool behaves beyond its structured metadata.

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 non-redundant information; nearly every clause adds operational value. Parenthetical asides and run-on sentences hurt readability slightly, but the most important usage signals (account requirement, alternative tool, top-level capability) are front-loaded. It is more verbose than the ideal but earns its length.

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

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

For a complex research tool with no output schema, this description covers everything an agent needs: authentication, input semantics, output packet structure, citation resolvability, failure behavior, timing, depth differences, and explicit exclusions. The description fully compensates for the lack of an output schema and leaves no major operational gap.

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

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

Schema coverage is 100%, so the schema already fully documents both parameters and the depth enum. The description adds real value by explaining that the question is decomposed into facets, that 'thorough' requires a paid plan, and providing example question shapes that reinforce the natural-language usage. This exceeds the baseline but the schema already does most of the parameter documentation work.

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 action: grounded multi-source research across 1,517 structured data sources in one call, explicitly distinguishing itself from open-web search. It also names what it is not and gives concrete example use cases. This clearly separates deep_research from siblings like ask_pipeworx and compare_entities.

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 ask_pipeworx for single lookups and for users not signed in, while deep_research is best for broad/multi-part questions. It also mentions the account requirement and paid tier for 'thorough' depth. This gives direct when-to-use and when-not-to-use guidance with a named 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?

Annotations declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description does not contradict them. The description adds value by disclosing that results include full schemas with curated examples and are ready to call, which goes 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 concise with no fluff. Front-loaded with the primary action and key usage scenario, then lists specific domains and what results contain. Every sentence adds value.

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

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

Although there is no output schema, the description adequately explains what the tool returns (top-N tools with names, descriptions, full schemas). It mentions curated examples and that results are ready to call. Given the tool's complexity and lack of output schema, this is sufficient.

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

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

Schema description coverage is 100%, with all 6 parameters documented. The description provides no additional meaning beyond repeating that query is a natural language description and noting aliases, which are already in the schema. Baseline of 3 is appropriate since 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 uses a specific verb ('Find tools by describing') and clearly identifies the resource (tools). It distinguishes itself from siblings by focusing on discovery of available tools, while siblings like 'search_within' or 'deep_research' handle data within tools. The extensive domain list further clarifies scope.

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

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

Explicitly states 'Call this FIRST when you have many tools' which provides clear when-to-use guidance. It implies using this before other tools to see options. However, it does not explicitly mention when not to use or compare with alternatives, though context is sufficient.

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

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

Annotations already declare readOnly/openWorld/idempotent/non-destructive, and the description adds substantial behavior beyond that: parallel fan-out semantics, sources_used/sources_failed meaning ('an empty section is a real "no data", not a bug'), soft-fail behavior for USPTO PatentsView, the expectation that FDA sections may legitimately be empty for small-molecule companies, resolved:false instead of bare failure for private companies, and 'LATEST 10-K' labeling. 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?

This is one massive wall of text — a single run-on paragraph packing query examples, source enumeration, output fields, edge cases, and failure semantics. Every sentence carries substance, and the core purpose does appear near the front after the examples, but the lack of paragraph or bullet structure makes key directives like 'ALWAYS PREFER' and 'sources_failed means no-data, not a bug' harder to scan. The content justifies length; the formatting does not.

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

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

With no output schema, the description carries the full burden of explaining return values, and it does: cik, company_name, resolved_from/resolved_to, recent_filings (up to 5 with URIs), fundamentals fields, and the sources_used/sources_failed contract. Edge cases (private companies, empty FDA sections, soft-failing patents) are covered. Minor gaps remain — the exact nesting/shape of the hiring and LEI sections is glossed — but for a tool of this complexity, coverage is strong.

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

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

Schema coverage is 100%, so the baseline is 3; the schema already documents both parameters and their accepted shapes. The description reinforces with concrete examples ('AAPL', '0000320193', 'Moderna') and clarifies that 'company' and 'ticker' are interchangeable, but this mostly restates what the schema's enum descriptions already convey. Marginal value added over the structured data.

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 a specific verb+resource: 'full cross-source profile of a US public company in ONE parallel call', with query examples and an enumerated fan-out list (SEC EDGAR, XBRL, USPTO, USAspending, Purple Book, DOL LCA, GDELT/GNews, GLEIF). Explicitly differentiates from 'chaining single-pack SEC/XBRL/news lookups', making it distinguishable from siblings like resolve_entity or compare_entities without opening their schemas.

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?

Contains an explicit directive: 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view', which clearly states the primary trigger condition. It also explains input flexibility and the private-company fallback path. However, it does not name alternative siblings (compare_entities for comparisons, resolve_entity for single-entity lookup) or state when NOT to use this tool, leaving some routing to inference.

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

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

Annotations already indicate destructiveHint=true and idempotentHint=true. Description adds context about why deletion is appropriate (stale data, task completion, sensitive data removal), but does not mention idempotency or other behavioral traits.

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, no wasted words. First sentence states action, second provides usage context and sibling references.

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 single parameter, clear annotations, and no output schema, the description fully covers when and why to use the tool. No gaps.

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

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

Schema coverage is 100% with a clear description for the 'key' parameter. The description adds no additional semantic information beyond the schema, resulting in baseline 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?

Description clearly states it deletes a previously stored memory by key. The verb 'Delete' and resource 'memory by key' are specific and unambiguous.

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

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

Explicitly lists use cases: when context is stale, task is done, or clearing sensitive data. Also mentions pairing with 'remember' and 'recall', providing guidance on alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, etc. Description adds that it fetches page and extracts info, which is consistent but not deeply 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, front-loaded with purpose, no unnecessary words. Highly 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?

No output schema, but description explains output format and deployment location. Sufficient given low complexity (2 params, no enums).

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 100%; description adds example URL format and numeric limits for max_links, providing value beyond basic 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?

States specific verb ('Generate'), resource ('llms.txt file'), and context ('for any URL'). Distinguishes from siblings by focusing on AI crawler indexing.

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?

Lists clear use cases (client site, own project, competitor audit) but lacks explicit when-not-to-use or alternative tool references.

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

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

Annotations already indicate readOnlyHint, idempotentHint, and non-destructive. The description adds valuable behavioral information such as the returned fields (id, type, params, etc.) and the default of active subscriptions, enhancing agent understanding beyond structured data.

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

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

Two sentences, no redundancy, front-loaded with the core action. Every sentence adds value.

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

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

Despite lacking an output schema, the description lists the returned fields. Combined with usage guidance and annotations, the tool is fully understandable for an AI agent.

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

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

Schema coverage is 100% with a single boolean parameter fully described. The description implicitly references it ('active subscriptions') but adds no new semantics beyond the schema. Baseline of 3 is appropriate.

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

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

The description clearly states 'List the caller's active subscriptions', specifying the verb (list) and resource (subscriptions). This distinguishes it from sibling tools like 'subscribe' and 'unsubscribe'.

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

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

Explicitly advises when to use the tool: 'Use this to review what you're monitoring before adding more or to find an id to cancel.' This provides clear context and exclusions relative to siblings.

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

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

Annotations declare readOnlyHint, idempotentHint, destructiveHint=false. Description adds value by noting daily data refresh and specifying exact return fields, exceeding what annotations provide. No contradiction.

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

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

Single paragraph, no wasted words. Starts with purpose, lists returned fields, gives concrete examples, and ends with scope. Efficient and front-loaded.

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

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

Describes all return details (since no output schema) and data freshness. Does not explicitly state default behavior when no parameters given (returns first 50 offices?), but limit param covers that. Adequate for a lookup 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 covers all four parameters with descriptions. The description adds context with examples like 'Columbia' for city and '63101' for ZIP, and explains usage patterns (substring matching, prefix). This enhances understanding beyond 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?

Description clearly states 'Find a Missouri license office' and enumerates returned fields (address, phone, hours, coordinates, etc.). Provides example queries that differentiate from sibling tools (e.g., 'DMV office in Springfield MO' vs. unrelated tools like deep_research).

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?

Examples of use cases (closing dates, office hours, location queries) implicitly guide when to use. No explicit exclusions or alternatives, but context of sibling tools makes it clear this is the DMV office 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 provide no hints (all false), so the description carries the full burden. It discloses the claim_token return behavior, daily review cadence, rate limiting (5 per identifier per day), and that it is free and does not count against tool-call quota. It also advises not to paste end-user prompts, adding important behavioral nuance.

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 efficient, with the first sentence stating the core purpose, followed by usage conditions, exclusions, follow-up mechanics, and constraints. Every sentence contributes necessary information, though it is slightly long for a 10% weight dimension.

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

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

No output schema exists, but the description explains what the tool returns (claim_token) and how to use it later to read status/resolution. It also covers prerequisites (none), alternative routing for other servers, rate limits, and privacy guidelines, making it fully complete for a feedback 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 covers all parameters (100% coverage), so baseline is 3. The description further clarifies claim_token semantics ('pass it back later as pipeworx_feedback({claim_token:"pwfb_…"})' and 'with no other arguments'), sets message length guidance, and gives context examples, adding value beyond the schema.

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

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

The description opens with a specific verb and resource: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It clearly distinguishes this feedback tool from all sibling tools, none of which handle user feedback.

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

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

Explicit usage conditions are given: use for bug, feature/data_gap, or praise; and explicit exclusion for tools from other MCP servers, directing the user to file elsewhere. It also explains the claim_token follow-up mechanism and states the rate limit, leaving no ambiguity about when or how to invoke.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive. The description adds critical behavioral details: data source (CF analytics-engine), no PII, caching behavior (5min-1h), and that it's self-aggregating. These go 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 concise: 4 sentences starting with a clear purpose, followed by bullet-point use cases, then technical details. Every sentence adds value, and the structure is front-loaded with the most important 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?

Despite no output schema, the description explains what is returned (top tools, top packs, total call volume), the data source, caching, and privacy. It is complete for a read-only, single-parameter tool with comprehensive annotations.

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

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

Schema coverage is 100% (one parameter with enum). The description adds semantic value by explaining that shorter windows surface 'what's hot right now' and longer windows show 'steady-state demand', which aids parameter selection.

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 top tools, packs, and call volume over a time window. It uses a specific verb ('Returns') and resource ('top tools, top packs, total call volume'), distinguishing it from siblings like discover_tools or ask_pipeworx.

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

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

The description lists three concrete use cases (discovering hot data sources, confirming canonical tool, aligning use case) and provides guidance on window selection. It lacks explicit 'when not to use' but makes context 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 indicate read-only, open-world, idempotent, non-destructive. Description adds detailed behavioral context: algorithmic steps (Jaccard similarity threshold, placeholder filter, fill check), failure modes (low similarity, placeholder majority), and reliance on external tool (polymarket_fill_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?

Description is detailed and informative but slightly verbose. It front-loads the core purpose and then breaks down modes, but could be more concise while retaining all necessary information.

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

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

Despite no output schema, description thoroughly explains response structure (opportunities array, partition_check fields, fill check results). Covers all modes, edge cases (low similarity, placeholder filtering), and references to companion tools. Complete for a complex multi-mode 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% description coverage for both parameters. Description adds significant meaning beyond schema: explains event slugs vs topics, how each mode works (walking child markets, cross-event Jaccard similarity, partition check details).

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

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

The description clearly states the tool finds arbitrage opportunities via monotonicity violations and partition-sum checks. It distinguishes from sibling tools like polymarket_edges and polymarket_fill_risk by specifying its unique scanning modes (trending_scan, event, topic).

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 explains when to use each mode: no args for trending scan, event for specific market, topic for cross-event scanning. Provides example inputs and warns when not to trade (realizable_edge_pp ≤ 0).

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

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

Annotations already indicate read-only, open-world, idempotent, non-destructive behavior. The description adds rich behavioral details: caching at 1h, Fed bet exclusion reasoning, three model family mechanics, response structure with diagnostics, and knob effects. No contradictions with annotations.

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

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

The description is lengthy (~500 words) but dense and well-structured. It front-loads purpose, then details segments, response, and knobs. Every sentence adds necessary information for a complex tool; no redundancy. The length is justified by the tool's complexity.

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

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

Given the complexity (3 model families, 9 parameters, no output schema), the description covers response structure, model formulas, tradeable-edge knobs, caching, and limitations. It thoroughly explains return values and diagnostics. Some explicit field listing for each segment would be ideal, but overall it's highly complete.

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

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

With 100% schema coverage, the schema already describes all 9 parameters. The description adds value by explaining parameter interactions (e.g., min_kelly vs min_partition_leg_kelly), providing usage examples (e.g., 'Set to 5000...'), and contextualizing default values. This exceeds the baseline of 3.

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

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

The description explicitly states the tool scans Polymarket markets for discrepancies with Pipeworx data, and contrasts it with the use case 'what should I bet on today'. It clearly distinguishes from sibling tools like polymarket_arbitrage by focusing on Pipeworx disagreement and specific model families.

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 use (discovering betting opportunities) and details three model families with their rationales. It implies when each segment might be relevant but lacks explicit 'when not to use' comparisons with siblings. Overall, guidance is strong but not exhaustive.

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

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

Annotations already declare readOnly, openWorld, idempotent, non-destructive. The description adds significant detail: response structure (tracked, expired, snapshot_dates), decay computation, edge signed by trade direction, and snapshot gaps. 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 with sections for response and limits, but it is relatively long. It could be slightly more concise while retaining 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 no output schema, the description thoroughly explains the return fields (tracked, expired, snapshot_dates) and their sub-fields (trend, decay_pp_per_day, lifespan_days, etc.). It also covers edge cases like snapshot gaps and the 60-day TTL, making it self-contained.

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

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

Schema covers both parameters with descriptions. The description adds defaults (days=14, window='1wk'), clamps (days 2-30), and explains that window corresponds to snapshot families. This adds value beyond the schema.

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

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

The description clearly states the tool's purpose: answering questions about edge persistence and decay using daily snapshots. It distinguishes itself from the sibling 'polymarket_edges' by focusing on telemetry and time-series analysis.

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 context on when to use the tool (to differentiate fresh vs aged edges) and mentions limits (60-day TTL, snapshot gaps). However, it does not explicitly contrast with sibling tools like 'polymarket_arbitrage' or 'polymarket_fill_risk'.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint true, and destructiveHint false. The description adds extensive behavioral detail: walks the ladder, returns specific fields like top_of_book, vwap_fill_price, slippage_pp, verdict, and in basket mode explains thin_legs and forced_directional_risk. No contradictions with annotations.

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

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

The description is moderately long but well-structured with clear sections for single-market and basket modes. Every sentence provides useful information, though slight verbosity in explaining forced_directional_risk could be tightened. Overall, it earns its length.

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

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

Given the complexity (no output schema, 4 params, no nested objects), the description is remarkably complete. It explains return values for both modes, use cases, risks (thin books, partial fills), and provides explicit guidance. No gaps remain.

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

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

Schema coverage is 100% (all 4 parameters described in the input schema), so baseline is 3. The description adds significant meaning beyond the schema: it explains the auto default for side in basket mode, clarifies size_usd as settlement notional in basket, and details return fields not in the schema. This enrichment justifies a score above baseline.

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

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

The description clearly states the tool performs a 'realizable-vs-theoretical edge check against live CLOB order-book depth'. It distinguishes two modes (single-market and basket) and explicitly contrasts with sibling tools like polymarket_arbitrage and polymarket_edges by providing context on when to use this tool before those.

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

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

The description explicitly directs: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500'. It explains why—partial basket fills convert arbs into unhedged directional positions, a common loss mode. This provides clear when-to-use and when-not-to-use guidance.

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

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

Annotations already carry readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, and the description is fully consistent with them (analysis/read operation, no contradiction). Beyond that, it discloses substantial non-obvious behavior: the gross-vs-net fee caveat (Kalshi fees not modeled), the nuanced temporal_alignment null semantics ('null means it could not be computed... not that the two sides align'), the rule that 'unknown' metric_type/match_subtype legs are never paired, and the pairing_unverified caveat that matched pairs are keyword-based, not source-verified. This is exactly the kind of context annotations cannot express.

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 justified by the tool's genuine complexity (2 modes, 7 compatibility codes, alignment semantics, fee disclosure, no output schema to lean on). It is front-loaded with purpose and uses scannable delimiters (TWO MODES, RESPONSE, SAFETY FIELDS, Codes:) that aid navigation. There is some redundancy — temporal_alignment_unknown is explained in the code list, again in the temporal_alignment paragraph, and appears in the top_spreads_pp flags — and the codes are re-enumerated in multiple places, which could be tightened.

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 3 parameters, 2 modes, and no output schema, the description carries the full burden of explaining return structure — and it does: leg-by-leg prices, matched spread[].top_spreads_pp, compatibility_warning/codes[], temporal_alignment month fields and null semantics, fees_note, skipped_cross_type/subtype counters, and low_confidence_pairs. Edge cases (unparseable dates, subject mismatches, inequality mismatches) are all covered. Nothing an agent needs to call and interpret this tool is missing.

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

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

Schema coverage is 100% — all three parameters have descriptions in the schema, so the baseline is 3. The description adds genuine value on top: it enumerates all 10 valid topic values, explains the mode interplay (topic auto-fetches both sides, while kalshi_event_ticker and polymarket_event_slug 'override' the mapped side, enabling mixed custom pairings), and clarifies that all three are optional yet mode-conditional. This override semantics and cross-parameter relationship goes beyond what the flat schema descriptions provide.

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

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

The first sentence states a precise verb+resource: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' It defines scope (same outcome, cross-venue) and clearly distinguishes from neighboring siblings like polymarket_arbitrage and polymarket_edges by focusing on the Kalshi↔Polymarket comparison rather than single-venue strategies. Even without opening schemas, an agent knows exactly what this tool computes.

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 mode-selection guidance — TWO MODES with the 10 pre-mapped topic shortcuts listed verbatim, plus the explicit kalshi_event_ticker + polymarket_event_slug path, and states that both run the identical matcher. It also sets expectations with 'pre-mapped ≠ tradeable' and 'most pre-mapped topics return compatibility_warning today.' However, it never explicitly routes away to an alternative sibling (e.g., when to use polymarket_edges or polymarket_arbitrage instead), so it stops short of a full when-not-to-use statement.

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 the tool as read-only and idempotent. The description adds value by explaining the dual behavior (retrieve vs list) and scoping, without contradicting annotations.

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

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

The description is concise (60 words), front-loaded with the main action, and every sentence provides useful information without redundancy.

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

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

Given the simple parameter schema and the presence of annotations, the description covers all necessary behavioral and contextual information for correct tool usage.

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

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

Schema description coverage is 100% and the parameter description is already clear. The description does not add new 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 uses specific verbs ('Retrieve', 'list') and identifies the resource ('value previously saved via remember', 'all saved keys'). It clearly distinguishes from sibling tools 'remember' and 'forget'.

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

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

The description states when to use this tool (to look up context stored earlier) and provides concrete examples (target ticker, address, research notes). It mentions scoping but does not explicitly 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 already mark the tool as read-only, idempotent, and non-destructive. The description adds context about the feed persistence, the effect of `mark_read` on subsequent calls, and the data returned (source, citation_uri, raw event). This goes beyond what annotations provide.

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

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

The description is three sentences, each earning its place: purpose, return details, filtering and mark_read usage, and polling guidance. No redundancy, clear front-loading.

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

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

Despite lacking an output schema, the description explains what the tool returns (source, citation_uri, raw payload). All parameters are covered, usage guidance is given, and behavioral aspects (feed persistence, mark_read effect) are disclosed. The tool is simple, and the description is complete.

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

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

With 100% schema coverage, the baseline is 3. The description adds practical meaning: it gives an example for `type` ('sec_8k'), explains `since` as ISO timestamp, and clarifies that `mark_read` flags events as read so next calls show only newer events. This is useful beyond the schema's minimal descriptions.

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

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

The description starts with a specific verb-resource pair ('Pull fired events from your subscription feed') and clearly distinguishes the tool from siblings like 'list_subscriptions' and 'subscribe'. It states exactly what the tool returns (source, citation_uri, raw payload).

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 notes that polling works fine and provides an alternative access method via a GET endpoint, which guides when to use this tool vs. manual fetching. However, it doesn't explicitly mention when not to use it, though the read-only nature is clear from annotations.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and not destructive. The description adds rich behavioral details: fans out to SEC EDGAR, GDELT→GNews fallback, and USPTO (soft-fail until reactivated), with structured return format including citation URIs. 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 front-loaded with example queries, then explains the multi-source logic, parameters, and return format in a structured, non-repetitive way. Every sentence adds value, and the length is appropriate for the 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?

Despite lacking an output schema, the description thoroughly explains the return structure (changes grouped by source, total_changes count, citation URIs). It also covers limitations (USPTO soft-fail) and the fallback behavior. The tool is fully described for an agent to use correctly.

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

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

Input schema has 100% description coverage. The description adds value by explaining the `since` parameter accepts ISO dates or relative shorthand (with examples like '7d', '3m'), and that `value` accepts ticker or CIK. It also provides guidance on typical usage for `since`.

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 a change feed for a company in a recent time window, with example queries like "What's new with X" and "latest on Y." It explicitly distinguishes itself from the sibling tool entity_profile, which handles static profiles regardless of time window.

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 guidance on when to use (for time-window change queries) and when not to (for static profiles, pointing to entity_profile). It also advises on the `since` parameter with examples like '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?

The description adds critical behavioral context beyond annotations: 'scoped by your identifier,' 'Authenticated users get persistent memory; anonymous sessions retain memory for 24 hours.' No contradictions with annotations (readOnlyHint=false, destructiveHint=false, idempotentHint=true).

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

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

Four sentences, each serving a distinct purpose: purpose, usage guide, behavioral details, and tool pairings. No fluff or repetition. Front-loaded with the core action.

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

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

Given the simple parameter set (2 required strings) and no output schema, the description covers all necessary aspects: purpose, when to use, persistence behavior, scoping, and sibling tool relationships. No gaps remain.

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

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

The input schema already provides descriptions for both parameters (100% coverage). The description adds value by suggesting example keys ('subject_property', 'target_ticker') and the nature of values ('findings, addresses, preferences, notes'), clarifying usage 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 'Save data' and the resource 'key-value pair', and distinguishes from siblings recall and forget. It specifies the tool is for storing reusable data across sessions, which is specific and unambiguous.

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

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

The description explicitly advises when to use: 'when you discover something worth carrying forward.' It also mentions complementary tools: 'Pair with recall to retrieve later, forget to delete.' This provides excellent guidance on tool 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, openWorldHint, idempotentHint, and destructiveHint=false. The description adds substantial non-obvious behavior: identifiers are labelled with their source, unresolvable identifiers are exposed under `unresolved` rather than omitted, LEI/FIGI enrichment degrades gracefully, and each call cascades through multiple endpoints. It also documents ISIN-to-LEI resolution and that non-equity instruments without tickers still resolve. 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 information-dense but poorly structured—the 'company' type is a long run-on parenthetical mixing input formats, output fields, and edge cases into one complex clause. It is front-loaded with purpose and usage, and length is arguably justified by complexity, but the organization would be far clearer with bullet points or separate sentences for each concern.

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

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

There is no output schema, so the description bears full responsibility for explaining return values—and it does. It enumerates returned identifiers (CIK, ticker, company_name, LEI with ownership, FIGI, RxCUI/ingredient/brand/citation), describes the `unresolved` field, covers graceful degradation, and gives input constraints. An agent has enough context 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%, so the baseline is 3. The description adds real parameter meaning beyond the schema: it states that `value` for company accepts ticker, CIK, ISIN, or company name (ISIN is not mentioned in the schema), explains the exact-ticker vs name-search resolution path, and clarifies that non-equity instruments without tickers still resolve. This adds semantic value for an agent choosing what to pass.

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

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

The description states a specific verb-resource pair: 'resolve a user-spoken NAME to the canonical/official identifiers other tools require as input.' It lists example user queries and explicitly positions itself as the name-to-ID tool, distinguishing it from siblings that consume those IDs. This is more than a vague statement—it tells an agent exactly what job the tool performs.

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

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

The description gives an explicit trigger condition: 'Use FIRST whenever you have a name but need an ID.' It also reinforces this with 'using resolve_entity replaces 2-3 manual lookups.' However, it does not name specific alternatives or state when not to use it, so the guidance is clear but lacks explicit exclusions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, etc., indicating safe, non-destructive behavior. The description adds value by detailing the process: 'Probes each entity... with ai_visibility_check, ranks by score' and output fields (score, confidence, signal density), which are not in 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 concise (two sentences) and well-structured: first sentence states action and method, second provides use case and output. Every part adds value with no redundancy.

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

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

For a tool with 4 parameters, no output schema, and rich annotations, the description fully explains functionality, process, output fields, and use case. It covers all necessary context for an AI agent to select and use the tool correctly.

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

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

Schema coverage is 100%, but the description adds meaning: specifies entities range '2-8', clarifies that the first entity is 'treated as the subject', gives examples for context, and notes that models can be omitted for default. This provides context 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: 'Compare AI visibility across multiple entities side-by-side' with specific actions (probes, ranks, surfaces). It differentiates from sibling tools like ai_visibility_check (single entity) and compare_entities (generic comparison) by detailing its method and output.

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

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

The description provides a clear use case: 'competitive AI-marketing audits' with an example question. It implies when to use it (comparing multiple entities) but does not explicitly state when not to use or list alternatives, though the context of sibling tools is available.

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

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

Annotations already indicate readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds significant behavioral context: it fans out across two external services (deps.dev and bundlephobia), mentions that bundlephobia's first measurement can take 5-30s, and explains that partial failures degrade gracefully with a sources_failed field. 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 paragraph but packs a lot of information efficiently. It is front-loaded with the purpose and key details. Minor improvement could be using bullet points for the return summary, but it remains concise and clear.

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 comprehensively explains the return value: a summary block with 9 fields, per-advisory detail, links, and a list of alternative versions. It also covers partial failure behavior and ecosystem limitations. This is more than adequate for an agent to understand the tool's capabilities.

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?

Input schema has 100% description coverage, so baseline is 3. The description adds minor context (scoped packages accepted, version defaults to latest), but these are already inferrable from the schema descriptions. No extra semantics beyond what the schema provides.

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

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

The description clearly states the tool's purpose: a composite check for npm packages covering license, advisories, version history, and bundle size. It uses specific verbs like 'fans out across' and explicitly answers questions like 'is X safe / popular / small' or 'what does adding lodash cost me'. This distinguishes it from sibling tools which are unrelated to dependency scanning.

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

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

The description provides explicit usage guidance: when to use (for npm packages when evaluating safety/popularity/size), when not to use (other ecosystems like PyPI, Maven, Cargo, Go, which should use deps.dev:version directly), and the behavior for partial failures (graceful degradation with sources_failed field). This is exemplary.

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 (readOnlyHint, idempotentHint, destructiveHint) indicate safe, non-destructive behavior. The description adds significant behavioral context: embedding model (BGE-base-en), similarity metric (cosine), chunking strategy (500-char overlapping windows), input limit (200K chars with truncation flag), and output details (character offsets, similarity scores). This far exceeds what annotations provide.

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

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

The description is a single, well-structured paragraph with no wasted words. The first sentence states the purpose, followed by usage context, then technical details. Each sentence adds essential information without redundancy.

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

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

The tool has no output schema, so the description must explain return values. It states passages with 'character offsets and similarity scores' and mentions truncation behavior. However, it could be more precise about the output format (e.g., JSON structure) and handling of empty results. Still, it provides enough for an agent to invoke and interpret the tool.

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

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

Schema coverage is 100% with basic descriptions for all three parameters. The description enriches understanding by providing concrete query examples and clarifying the text parameter's max length and the limit parameter's default (5) and range (1-20). It also explains how parameters fit into the overall search logic (e.g., overlapping windows).

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

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

The description clearly identifies the tool's core action: semantic search inside a specific record. It uses a strong verb ('Search Within') and specifies the resource type ('fetched record'). It differentiates from siblings by explicitly stating when to use it ('record too big to cram into prompt') and mentions pairing with ask_pipeworx_grounded, distinguishing it from other search tools in the sibling list.

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

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

The description provides explicit usage guidance: 'Use when the record is too big to cram into the prompt — search_within saves context, returns only the passages that matter.' It also suggests a complementary tool (ask_pipeworx_grounded). However, it does not explicitly state when not to use it or list alternatives for small records.

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 implies each call creates a new subscription (returns new id), but annotations set idempotentHint=true, suggesting the same subscription would be returned for identical parameters. This is a contradiction; description does not address idempotency.

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

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

The description is lengthy but each sentence provides necessary detail. It is front-loaded with the main purpose. Slightly more structured formatting (e.g., bullet points) 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?

Given the complexity (multiple types, nested parameters, delivery channels, no output schema), the description is highly complete. It covers account prerequisites, type-specific filters, delivery methods with limitations, and webhook security.

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 substantial meaning beyond the schema: it explains type-specific parameters (e.g., items codes for sec_8k), delivery options with constraints (phone verification, daily cap, webhook signing), and examples.

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

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

The description clearly states 'Create a proactive monitoring subscription to a live-data event stream. Returns the new subscription id.' It uses specific verbs and resources, distinguishing from sibling tools like list_subscriptions and unsubscribe.

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

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

The description provides explicit context: 'Requires a Pipeworx OAuth account (anonymous + BYO cannot persist subscriptions).' It lists supported types and delivery channels, though it does not explicitly state when not to use or alternative tools.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds value by explaining it returns category-bucketed example questions with exact tool + argument shapes drawn from live catalog, which is consistent 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 well-structured and front-loaded with common queries. It is slightly long but every sentence adds value; no wasted words.

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

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

Given good annotations and a single simple parameter, the description is complete. It covers the return type (category-bucketed examples with tool+argument shapes) and usage scenarios. 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 description coverage is 100% for the one parameter. The description adds meaning by listing example values (finance, pharma, etc.) and explaining the effect of omitting the topic.

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

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

The description clearly states the tool's purpose: returning category-bucketed example questions for onboarding. It uses specific verbs like 'returns' and distinguishes from siblings by positioning it as the first tool to use when unsure what Pipeworx can do.

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

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

The description explicitly instructs to 'Use this FIRST when you do not yet know what Pipeworx can do for you' and explains when to use the optional topic parameter. It does not explicitly list alternatives, but the context is clear.

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

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

Discloses key behaviors beyond annotations: ownership validation, deactivation instead of deletion, and idempotency hint is aligned. 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?

Two sentences with clear action and important constraints, 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?

With minimal parameters and clear annotations, the description provides sufficient context for the tool's operation and side effects.

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 completely; description adds slight value by linking 'id' to subscribe's return 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?

Description clearly states the verb 'cancel' and resource 'subscription by id', distinguishing it from sibling tools like subscribe and list_subscriptions.

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

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

Explicitly mentions ownership enforcement (only cancel own subscriptions) and that deactivation preserves historical data, guiding proper use without listing alternatives.

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

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

Beyond the annotations (readOnly, openWorld, idempotent, non-destructive), the description reveals significant behavioral details: the exact percent-delta math for financial claims, fallthrough routing, and the critical warning that could_not_verify means no verification happened and must not be presented as evidence. It also defines unsupported as a coverage gap, adding valuable nuance absent from annotations.

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

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

The description is front-loaded with search-like trigger phrases, then moves from purpose to routing to output to caveats. Despite its length, every sentence adds unique information—no filler or redundancy—and the structure guides the reader from 'when' to 'how' to 'what to expect.'

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 (routing, multiple verdicts, error handling) and the absence of an output schema, the description compensates admirably. It covers expected return values, citation format, error semantics, and the distinction between could_not_verify and unsupported, making the tool fully understandable without an output schema.

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

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

Although schema coverage is 100%, the description enriches both parameters: claim gets realistic examples, and tolerance_pct gains practical meaning (overrides claim wording, range 0.5–50, recommended 1–2 for hallucination detection, default cap 5). This is exactly the extra semantic value expected.

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 natural-language trigger phrases and explicitly states 'natural-language claim verification against authoritative sources,' making the tool's purpose unmistakable. It details specific output verdicts and distinguishes itself from generic lookups by noting it replaces 4–6 sequential calls.

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

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

It explicitly instructs to use the tool 'whenever the agent needs to check whether something a user said is factually correct,' and explains the routing behavior for company-financial claims versus any other factual claim. The caveat about could_not_verify vs unsupported further clarifies correct usage and interpretation.

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