Canada Tenders

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, covering safety and behavioral traits. The description adds value by detailing the default model, cost implications for Anthropic, and the return structure ({score, confidence, signals, raw_response} + combined view). 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 very concise (4-5 sentences) with the main purpose front-loaded. Every sentence adds value, covering purpose, default behavior, optional parameters, and return format. 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 the tool's complexity (4 params, no output schema), the description is complete: it explains the task, parameters, return format, and use cases. The agent has all necessary information to invoke the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents parameters. The description adds context beyond schema: entity is a brand/business name; models lists supported values; _apiKey involves BYO key and direct payment; context for disambiguation. This enhances understanding for the agent.

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

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

The description clearly states the tool's purpose: probing LLMs to score visibility (0-100) per model. It specifies the verb (probe), resource (LLMs), and outcome (score). It also distinguishes by mentioning default and BYO model options, differentiating it from sibling tools like scan_competitor_ai_presence.

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

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

The description provides clear usage contexts: AI-marketing audits, pre-launch brand checks, competitive monitoring. It explains when to use the default model vs. providing an API key for Anthropic. However, it does not explicitly state when not to use this tool or mention alternatives among 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 already mark the tool read-only, idempotent, open-world, and non-destructive. The description adds valuable behavioral context: it routes to sub-tools, fills arguments automatically, and returns structured answers with stable pipeworx:// 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 key guidance is front-loaded, but the description repeats the same example list, 'START HERE', and 'even if web search could also answer it' verbatim, roughly doubling the length with no new information. This is more redundant than concise.

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

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

For a broad QA router with one required natural-language parameter and no output schema, the description supplies enough context: what to ask, how the routing works, and what the response contains (structured answer with citations). It could be slightly stronger on limits or error/ambiguity behavior, but it is functionally complete.

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

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

The input schema covers 100% of parameters and documents the question field plus aliases. The description only provides example queries and doesn't add parameter-level meaning beyond the schema, so the baseline 3 applies.

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

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

The description clearly identifies ask_pipeworx as a natural-language router that sends questions to a curated set of 5,908 tools and returns cited structured answers, which is a specific verb+resource. It does not, however, distinguish ask_pipeworx from the sibling tools ask_pipeworx_beta and ask_pipeworx_grounded, so the purpose is clear but not fully differentiated.

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?

Strong when-to-use guidance is present: 'PREFER OVER WEB SEARCH', 'Use whenever the user asks...', explicit trigger phrases, and examples. It lacks explicit when-not-to-use guidance and does not address sibling router variants, so it is not a full 5.

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

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

Annotations already declare read-only, idempotent, open-world, and non-destructive behavior. The description adds valuable context beyond annotations: it is an experimental edge that may enable live routing candidates, currently has no active candidate, is a full working router, and falls back to nothing. This is strong behavioral disclosure.

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 core purpose and current state are front-loaded, and each sentence contributes meaningful context. Some details, such as the retirement date and repeated emphasis on same arguments/response shape, are slightly redundant, but the description remains focused and reasonably concise.

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

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

The description fully covers the tool's experimental nature, current behavior, relationship to ask_pipeworx, and fallback stance. Since there is no output schema, the 'same response shape' reference relies on the sibling ask_pipeworx documentation, but that dependency is acceptable given the sibling is available and the tool is explicitly a variant.

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 input schema fully documents each parameter, including the required question field and its aliases. The description only says 'same arguments' and does not add any parameter-level meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly identifies this as a beta variant of ask_pipeworx, a universal router with the same 5,908 tools, arguments, and response shape. It also clarifies that it may include candidate routing improvements and is currently identical to ask_pipeworx because no candidate is active. This distinguishes it from the stable sibling tool while stating exactly what it does.

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

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

The description explicitly says to use it exactly like ask_pipeworx when wanting the newest routing, and explains that results are compared against the stable router. It also notes that currently no candidate is active, so behavior matches ask_pipeworx exactly. This provides clear when-to-use and alternative-selection guidance.

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

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

Beyond the readOnly/idempotent annotations, the description discloses concrete refusal reasons (not_in_source, no_tool_match, tool_error, data_truncated, llm_error), the exact success return shape with verbatim evidence, and the extra LLM call cost. No contradiction with annotations exists.

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

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

The description is dense but well-structured: purpose first, then behavior/return shape, then refusal mode, then usage guidance, then cost tradeoff. Every sentence adds decision-relevant information, and the structure is easy to parse.

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 fully explains success and refusal return structures, routing scope, evidence semantics, and when to choose the sibling. An agent has enough context to invoke it correctly and interpret results.

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

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

The input schema covers all parameters at 100%, including canonical parameter `question` and its aliases. The description does not add new parameter-specific semantics; it focuses on tool behavior. The schema already carries the parameter documentation burden, so baseline 3 is appropriate.

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

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

The description precisely defines what the tool does: it routes a question through Pipeworx, fetches data, and returns an answer extracted strictly from the tool result. It also differentiates itself from ask_pipeworx by naming it and emphasizing the hallucination-resistant, grounded extraction behavior.

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 criteria are provided: use it when answers will be quoted, cited, or acted on, and when the agent must not invent facts. It also names ask_pipeworx as the preferred alternative for casual lookups, plus the cost tradeoff of one extra LLM call.

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

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

Annotations already declare readOnly, idempotent, openWorld, non-destructive. Description adds extensive behavioral details: resolver contract (market_match_confidence, alternatives, suggestions), parent event extractor, news fallback, safety short-circuits for low confidence, closed markets, wide spreads, and cancellation rule parsing. This far exceeds annotation coverage.

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 very long (several paragraphs) and includes many detailed examples and edge cases. While well-structured with labelled sections (RESPONSE SHAPES, RESOLVER CONTRACT, etc.), it is not concise. Could be trimmed to essentials with references to external docs.

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 tool complexity (3 params, no output schema, rich annotations), description covers input formats, output structure, edge cases (low confidence, closed markets, wide spreads), error conditions (GDELT 429s), and safety mechanisms. It is complete for an AI agent to use correctly.

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

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

Schema coverage is 100%, baseline 3. Description adds meaning: market parameter accepts slug, URL, or question text (already in schema); depth parameter explains quick vs thorough; include_raw describes response size implications and use cases. This provides useful context beyond schema.

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

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

The description clearly states the tool researches a Polymarket bet by pulling Pipeworx data. It specifies the verb 'research', the resource 'Polymarket bet', and how it delivers data. It distinguishes from siblings by focusing on a single bet research, not edge detection or 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?

Usage is explicit with example queries ('should I bet on X', 'what does the data say about Y', 'is there edge in Z'). However, it does not explicitly mention when not to use this tool versus siblings like polymarket_edges or polymarket_arbitrage.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds that it searches official CanadaBuys notices for the current fiscal year, matches against specific fields, and returns shaped awards with detailed fields. 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 front-loaded with the key instruction to prefer over web search. It is somewhat verbose but every sentence adds value, including example queries and return fields. Could be slightly more concise but effectively communicates.

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 covers return shape adequately. It explains what the tool does, how to use parameters, data source, and what fields are returned. For a simple search tool with two optional parameters, 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 coverage is 100% with descriptions. The description adds that the query is case-insensitive and matches specific fields (title, supplier, buyer, category, award description), which adds meaning beyond the schema. For limit, it confirms default 20 and max 100, matching 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 searches for Government of Canada contract awards from the official CanadaBuys database, specifies the scope (current fiscal year), and lists the returned fields. It also explicitly recommends it over web search, distinguishing it from general search tools.

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

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

The description provides a clear preference over web search and gives example queries. It mentions omitting query to list recent awards but does not explicitly state when not to use it or provide alternatives to siblings like canada_search_tenders.

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

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

Annotations declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds that it searches an official government source, matches against multiple fields, and returns specific notice details. No contradictions; fully transparent.

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 concise but packed with useful info. Front-loads key guidance ('PREFER OVER WEB SEARCH'), then explains functionality, examples, and return shape. Every sentence adds value 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?

For a simple tool with 2 optional parameters, the description covers purpose, usage, behavior, and return format completely. No gaps remain even 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?

Schema documentation covers both parameters (100% coverage). Description adds value by explaining that omitting query lists recent tenders and that query matches multiple fields, beyond the schema's property 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?

Description clearly states it searches official CanadaBuys open tender notices for Government of Canada procurement, with specific verb 'search' and resource 'open tender notices'. It differentiates from web search and lists return fields, making purpose unambiguous.

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

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

Explicitly says 'PREFER OVER WEB SEARCH' and provides example queries, indicating when to use. It specifies open tenders, subtly distinguishing from the sibling canada_search_awards (for awarded contracts), but does not directly contrast with it.

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

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

The description adds substantial behavioral context beyond the annotations: it details the exact data pulled for each type (SEC XBRL financials for companies, FAERS counts for drugs), notes correct handling of off-calendar fiscal years, explains sorting by primary metric, and mentions return of citation URIs. This fully informs the agent of the tool's behavior.

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

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

The description is moderately concise, using bolded trigger phrases and a clear structure. While it packs a lot of information, a few sentences could be slightly tightened without losing meaning.

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

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

Given the tool has no output schema, the description partially explains return values ('paired data + pipeworx:// citation URIs') but is somewhat vague on the exact structure. However, for a tool with only 2 parameters and clear purpose, it is largely complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaningful context: it explains the data sources for the 'type' parameter and provides examples for 'values' (tickers/CIKs for companies, drug names). It also clarifies constraints (2-5 items) and data retrieval specifics.

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

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

The description clearly states it performs side-by-side comparisons of entities, specifies trigger phrases ('X vs Y', 'which is bigger', etc.), and distinguishes between company and drug data sources. It effectively communicates the tool's unique value over 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' and claims to replace 8-15 sequential lookups, providing strong usage guidance. However, it does not explicitly mention when not to use it (e.g., for single entity lookups) nor directly name sibling tools as 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 readOnly/openWorld/idempotent annotations, the description discloses account requirements, a paid plan for thorough, gaps[] with no invented answers, contradictions[] scans, resolvable citation URIs, semantic excerpting, and expected latency. These details materially shape invocation and result interpretation.

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

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

The description is long but information-dense; almost every sentence adds a distinct operational fact. It is front-loaded with the account requirement and routing to ask_pipeworx before the core mechanism. Slight redundancy around ask_pipeworx mentions keeps it from a 5.

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

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

Despite having no output schema, the description fully explains the return packet: evidence, confidence, source, fetched_at, pipeworx:// citation, gaps[], contradictions[], and hop field. It also covers authentication, latency, facet decomposition, and multi-hop behavior, making the tool safely and correctly invocable.

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

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

The schema covers both parameters fully, so the baseline is 3. The description adds value beyond the schema by explaining depth behavior in practice — standard adds gap recovery, thorough chases leads, contradiction scans occur, and thorough requires payment — and by giving concrete example questions for the question parameter.

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 and resource: 'grounded multi-source research across Pipeworx's 1540 STRUCTURED data sources' in one call. It clearly distinguishes this from open-web search and from ask_pipeworx, explicitly naming the sibling alternative it is not.

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

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

Usage guidance is explicit and actionable: use ask_pipeworx when not signed in, for single lookups, and for breaking/news topics; use deep_research for broad/multi-part structured-data questions. It also explains when to choose different depth levels, including the paid threshold for thorough.

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

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

Annotations indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds behavioral context: returns top-N tools with names, descriptions, full input schemas (with curated examples), ready to call immediately without a second lookup. No contradiction.

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

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

The description is concise yet comprehensive, front-loading the purpose and usage. Every sentence adds value, with no fluff.

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

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

Despite lacking an output schema, the description adequately explains the return value (top-N tools with names, descriptions, full schemas). It also notes curated examples are included. Minor gap: doesn't specify data format (e.g., JSON structure), but overall sufficient.

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

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

Schema coverage is 100%, so baseline 3. The description adds value by explaining that query accepts aliases (task, q, description, search) and provides example use cases in the description and schema examples, helping the agent understand parameter usage.

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

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

The description clearly states the tool finds tools by describing data or task, listing many domains. It distinguishes itself from sibling tools by positioning itself as the first call for discovery, unlike search_within or deep_research which have different purposes.

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

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

The description explicitly says 'Use when you need to browse, search, look up, or discover what tools exist for...' and 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' This provides clear when-to-use guidance.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint:false, so the description only needs non-redundant behavior — and it delivers: fans out across multiple sources, reports sources_used/sources_failed, treats empty sections as real no-data, resolves names via SEC EDGAR, and returns resolved:false with a note for private companies. This goes well beyond the annotations and is free of contradiction.

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

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

The description is front-loaded with the most decision-critical guidance ('ALWAYS PREFER') and concrete trigger phrases, and every sentence adds meaningful details. However, it is a dense, run-on paragraph with semicolons and parentheticals that could be more scannable if broken into bullet points; still, nothing is wasted.

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?

This is a complex multi-source tool with no output schema, and the description covers everything needed: each fan-out data source, exact return fields including URI formats, the sources_used/sources_failed keys, the meaning of empty sections, name-resolution behavior, and the private-company edge case. An agent can select, call, and interpret this tool properly without external lookups.

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

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

With 100% schema coverage, the baseline is 3, but the description adds substantial meaning: 'value' can be a ticker, zero-padded CIK, or company name, names resolve via SEC EDGAR, and 'type' accepts 'company' or 'ticker' interchangeably. Concrete examples like 'AAPL' and '0000320193' enrich the schema definition beyond its basic descriptions.

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

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

The description states a specific verb and resource: 'full cross-source profile of a US public company in ONE parallel call.' It distinguishes itself from chained single-source lookups with 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups,' and it lists concrete user trigger phrases. The resolved:false for private companies further clarifies scope boundaries.

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

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

It explicitly tells when to use this tool: when the user asks for a holistic view, with example prompts like 'Tell me about X,' 'research Acme,' and 'brief me on Tesla.' It also tells when NOT to use it by preferring it only for holistic requests over chained single-source lookups, and implicitly excludes private companies and non-company entities with 'person/place coming soon.'

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

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

Annotations already provide destructiveHint=true and idempotentHint=true. Description adds usage context but no new behavioral details beyond what annotations convey.

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

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

Two sentences, front-loaded with purpose, each sentence earns its place. No redundant or extra text.

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

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

With one parameter and no output schema, the description adequately covers the tool's effect and usage context. Lacks explicit mention of behavior when key missing, but idempotentHint mitigates that.

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

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

Schema coverage is 100% with parameter 'key' described. Description just says 'by key', adding no extra meaning beyond the schema.

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

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

Description states 'Delete a previously stored memory by key' – a specific verb-resource pair. Explicitly distinguishes from sibling tools 'remember' and 'recall' by naming them.

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

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

Clear when-to-use scenarios: stale context, done task, clearing sensitive data. Also advises to pair with remember and recall, guiding 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 indicate a read-only, idempotent, non-destructive operation. The description supplements this by detailing the steps (fetches, extracts, emits) and output nature, adding value beyond the annotations.

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

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

The description is concise with two sentences and a list, no unnecessary words. Information is front-loaded and every sentence is valuable.

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

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

For a simple tool with 2 parameters and clear annotations, the description fully explains the process, output, and usage context. 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%, so the description does not need to elaborate on parameters. It does not add new information beyond the schema, meeting the baseline.

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

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

The description clearly states the tool generates an llms.txt file for any URL, specifying the target (AI crawlers) and the output format. It is specific and distinguishes from sibling tools, none of which perform the same function.

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

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

The description provides explicit use cases (client site indexing, personal project, competitor auditing). It lacks explicit 'when not to use' or alternative tools, but the use cases are sufficiently clear.

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

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

Annotations already declare readOnlyHint, idempotentHint, etc. The description adds that it returns specific fields and the optional include_inactive parameter, which is consistent and adds some value.

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 no wasted words; the description is front-loaded with the purpose and immediately provides usage guidance.

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

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

For a simple list tool with one optional param and no output schema, the description provides sufficient detail including return fields and usage context.

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

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

Schema coverage is 100%, so the description does not need to add much. It only implicitly references the parameter via 'active' vs 'inactive', but the schema's description adequately covers the parameter.

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

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

The description clearly states the action ('List') and the resource ('the caller's active subscriptions'), and distinguishes from sibling tools like subscribe and unsubscribe by mentioning cancellation context.

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

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

The description 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 contextual guidance.

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

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

Beyond the all-false annotations, the description richly discloses behavioral traits: filing without an account returns a claim_token, how to later use it to read resolution status, that the team reads digests daily, a rate limit of 5 per identifier per day, and that it is free with no quota impact. This fully compensates for the sparse annotations and adds actionable specifics.

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

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

The description is longer than average but every sentence carries functional weight: purpose, when-to-use, exclusions, message guidance, token workflow, and rate limits. It is front-loaded with the core purpose and follows a logical sequence without redundancy or filler.

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

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

Given the tool's moderate complexity (4 optional params, nested object, no output schema), the description covers all essential aspects: when to use, what to include, how the token-based follow-up works, and operational limits. It leaves no significant gaps for an agent to resolve ambiguities, even with no output schema to define return values.

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

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

While schema coverage is 100%, the description adds meaning beyond the schema by explaining the claim_token workflow ('Filing without an account returns a `claim_token`; pass it back later as pipeworx_feedback({claim_token:"pwfb_…"}) to read whether it was fixed') and by advising on message content ('Describe the issue in terms of Pipeworx tools/packs — don't paste the end-user's prompt'). These additions are not present in the schema descriptions, elevating it above the baseline.

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

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

The description opens with a clear, specific verb and resource: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It then enumerates the exact feedback categories (bug, feature/data_gap, praise) and distinguishes itself from siblings by emphasizing its exclusive scope for Pipeworx tools, unlike any other tool in the 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?

Usage guidance is explicit: 'Use when a tool returns wrong/stale data (bug), when a tool you wish existed isn't in the catalog (feature/data_gap), or when something worked surprisingly well (praise).' It also provides an exclusion criterion—do not report issues for tools from other MCP servers—and a tie-breaker rule for uncertainty ('Pipeworx tool names are the ones this connection lists').

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

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

Description discloses the data source (CF analytics-engine), privacy (no PII), output format (pack, tool, count), and caching behavior (5min-1h). Annotations already declare read-only and idempotent; description adds valuable behavioral context without contradiction.

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

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

Three sentences cover purpose, use cases, and technical details without redundancy. Front-loaded with core function, then use cases, then behind-the-scenes info. Every sentence earns its place.

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

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

Given one optional parameter and no output schema, the description adequately explains what is returned (top tools, packs, total call volume) and provides caching details, making it complete for an AI agent to use correctly.

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

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

Schema coverage is 100% for the single parameter 'window', and the description adds semantic guidance: 'shorter windows surface what's hot right now; longer windows show steady-state demand', which adds meaning beyond the enum values.

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

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

The description clearly states it returns 'top tools, top packs, and total call volume over a recent window' with specific verb and resource. The three use cases distinguish it from siblings like 'discover_tools' which focuses on discovery rather than trending.

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

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

Three concrete use cases are provided (discovering hot data, confirming canonical tool, aligning with demand) and guidance on window selection ('shorter windows surface what's hot right now; longer windows show steady-state demand'). No explicit when-not-to-use or alternatives, but siblings don't overlap directly.

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, indicating a safe, read-only analysis. The description adds extensive behavioral details: monotonicity violation detection, partition-sum checks, fill check against CLOB depth, semantic anchor (Jaccard similarity), and partition filter logic. No contradiction with annotations.

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

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

The description is lengthy but well-structured, starting with a clear one-liner and using paragraph breaks for each mode. Bold terms improve readability. While every sentence is informative, some trimming could improve conciseness. A 4 reflects effective use of space without being overly verbose.

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 financial arbitrage tool with no output schema, the description is highly complete. It covers all modes, algorithms, fill check, semantic anchor, partition filter, and references a related tool for custom sizing. The annotations cover safety, leaving no critical gaps for agent invocation.

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

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

Schema description coverage is 100%, providing a baseline of 3. The description adds significant value beyond the schema: it explains the recommended usage for each parameter, provides example slugs and seed questions, and describes the internal logic differences between event and topic modes. This justifies a 4.

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

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

The description clearly states it finds arbitrage opportunities on Polymarket using monotonicity violations and partition-sum checks. It distinguishes three modes (no args, event, topic) and explains each. This differentiates it from sibling tools like polymarket_edges, polymarket_edge_tracker, and polymarket_fill_risk.

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

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

The description explicitly specifies when to use each mode: no args for trending scan, event for specific market, topic for cross-event scanning. It explains that cross-event mode catches patterns single-event misses, and advises not to trade if fill check shows realizable_edge_pp ≤ 0. Guidance on semantic anchor and partition filter is also provided.

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. The description goes far beyond by detailing caching (1h KV keyed on knobs), exclusion of Fed bets from ranking with reasoning, and inclusion of _diagnostics to explain empty segments. It also describes edge_pp_net, kelly_fraction, and the 24h-move warning, providing rich behavioral context.

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

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

The description is thorough but verbose (several paragraphs). It is well-structured with front-loaded purpose and clear sections, but could be more concise for an AI agent. Every sentence adds value, so no waste, but length reduces scanability.

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 9 optional parameters and no output schema, the description fully covers the expected response structure (by_segment, fed_candidates, _diagnostics) and explains each output field. It also describes the three model families and filtering logic, ensuring the agent understands what to expect and why segments might be empty.

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, baseline is 3. The description adds substantial meaning: for min_partition_leg_kelly, it explains why min_kelly doesn't apply to partitions and how this knob works. For slippage_pp and max_spread_pp, it gives practical guidance on setting values. Each parameter's role in the overall filtering and ranking is clarified, going well 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: 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price.' It specifies the resource (Polymarket markets) and the unique value (disagreement with Pipeworx data), distinguishing it from sibling tools like polymarket_arbitrage or polymarket_edge_tracker.

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

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

The description targets the use case 'what should I bet on today' and explains it avoids paging hundreds of markets. It details three segments and tradeable-edge knobs, implying when to use this tool. However, it does not explicitly compare to sibling tools or state when not to use it, leaving some ambiguity for an AI agent.

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

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

Beyond annotations (readOnly, openWorld, idempotent, non-destructive), the description explains snapshot mechanics (cache-miss, gaps), data structure (tracked, expired, snapshot_dates), and details like sign convention and decay computation. No contradiction.

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

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

The description is well-structured with a clear purpose, response breakdown, and limitations. It is slightly verbose but every sentence adds value; front-loading the core question aids quick comprehension.

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 comprehensively explains all return fields (tracked, expired, snapshot_dates) including sub-fields like trend and decay_pp_per_day. Limitations and edge cases are covered, making it complete for an agent.

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

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

Schema coverage is 100% with clear descriptions. The description adds context on default values and meaning (e.g., 'window' family, 'days' lookback clamp), 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 provides edge persistence and decay telemetry from daily snapshots, answering a specific question about edge history. It distinguishes from sibling tools like polymarket_edges by focusing on historical trends rather than current edges.

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

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

It explains when to use (to check edge longevity and decay) and includes limitations (history depth bounded by 60-day TTL, decay from daily closes). Although it doesn't explicitly name alternatives, the context and coverage are strong.

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 readOnlyHint=true, idempotentHint=true. Description adds rich behavioral context: walks the ladder, returns fill details (top_of_book, vwap_fill_price, slippage_pp, etc.), and warns about thin_legs and forced_directional_risk. No contradiction with annotations.

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

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

The description is detailed (~150 words) but well-structured with clear sections for single-market and basket modes. It front-loads the purpose. While concise, minor redundancy could be trimmed, but overall efficient 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?

Given the absence of an output schema, the description thoroughly explains return values for both modes (top_of_book, vwap_fill_price, capture_ratio, etc.) and includes risk warnings. For a complex tool with two modes and 4 parameters, it is complete and actionable.

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

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

Schema coverage is 100% with descriptions. The tool description adds significant nuance: explains single-market vs basket modes, default side logic for basket, and clarifies size_usd interpretation for each mode. This goes beyond the schema's field-level 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 checks 'realizable-vs-theoretical edge against live CLOB order-book depth' and distinguishes it from siblings by advising to use it before acting on polymarket_arbitrage signals. The verb 'check' and resource 'edge against order book' are specific.

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

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

Explicitly states when to use: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500'. Also explains why with warnings about uncapturable overround and partial fills converting arb to unhedged direction.

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

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

Goes far beyond the annotations (readOnly/openWorld/idempotent, all of which it respects): it discloses that unclassified legs are NEVER paired, that compatibility_warning and compatibility_codes can both be non-empty even when matched_pairs>0, that spreads are gross not net because Kalshi's fee schedule isn't modeled, and that pairing_unverified is set in EITHER mode because matching is keyword-based. Each safety code gets a plain-language meaning, and temporal_alignment null is explicitly distinguished from 'aligned'.

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?

Every sentence carries genuine information, but the description is an unusually long wall of text for a 3-optional-parameter tool, and the organization is rambling: safety codes, fee disclosure, skipped counters, and a closing marketing caution are interleaved rather than sectioned. Purpose and modes are front-loaded, but an agent must wade through dense prose to extract the call-critical facts.

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 the response, and it does: leg-by-leg prices, top_spreads_pp, compatibility_warning/codes, temporal_alignment shape, skipped_unclassified, low_confidence_pairs, fees_note, and skip counters. Given the tool's genuine complexity — cross-venue matching, two modes, many edge cases — almost nothing an agent needs to interpret results correctly 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%, so baseline is 3. The description adds real value on top: it explains the interaction between parameters ('kalshi_event_ticker overrides the topic-mapped Kalshi side', same for polymarket_event_slug), the semantics of the enumerated topic values, and why passing explicit tickers changes the pairing behavior (it doesn't — same matcher).

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?

Opens with a precise verb+resource statement: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' It clearly distinguishes this from Polymarket-only siblings (polymarket_arbitrage, polymarket_edges) by the two-venue scope, and reinforces the boundary with 'Real cross-venue spreads are rarer than the macro-shortcut list suggests.'

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?

Lays out TWO MODES explicitly — pre-mapped `topic` shortcuts vs explicit `kalshi_event_ticker` + `polymarket_event_slug` custom pairings — and states that both run the identical matcher. It also warns when NOT to expect success ('most pre-mapped topics return compatibility_warning today; pre-mapped ≠ tradeable'). It doesn't name sibling alternatives to switch to, so it stops short of a full 5.

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

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

Adds behavioral details beyond annotations: scoping to identifier, behavior when key omitted. Annotations already indicate read-only and idempotent, and description aligns.

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

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

Four concise sentences, each earning its place. Front-loaded with primary function, then rationale, scoping, and pairing suggestions.

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?

Complete for a simple tool with one optional param and no output schema. Covers retrieval, listing, scoping, and usage context.

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

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

Schema covers parameter fully with description. Description adds contextual nuance (omit to list all). Slight improvement over schema alone.

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

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

The description clearly states the tool retrieves values saved via 'remember' or lists all keys. It distinguishes itself from siblings '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?

Explicitly tells when to use: look up context stored earlier without re-deriving. Mentions pairing with siblings and scoping to agent identifier.

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=True, idempotent=True, destructive=False. The description adds beyond this by explaining the mark_read side effect (flags events read) and polling safety ('Polls work fine'), which are useful behavioral details. No contradictions with annotations.

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

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

The description is a single paragraph of four sentences, efficiently front-loading the main purpose. Every sentence adds value (output shape, filtering, mark_read, poll safety). No fluff; appropriately concise for a tool with five parameters.

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 usefully describes the return fields (source, citation_uri, payload). It explains filtering, mark_read, and polling. Slight gap: limit parameter behavior is only in schema, not elaborated in description (e.g., pagination). Otherwise complete for a read-only feed tool.

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

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

Schema coverage is 100%, so baseline is 3. The description does not add significant parameter meaning beyond the schema; it reiterates filtering by type (with example 'sec_8k') and since, but this is already clear from schema. No additional 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 the tool pulls 'fired events from your subscription feed', specifying the resource and action. It mentions return fields (source, citation_uri, payload) but does not explicitly distinguish from sibling tools like 'recent_changes' or 'list_subscriptions', so not a 5.

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

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

The description notes 'Polls work fine' and mentions an alternative HTTP endpoint, but provides no guidance on when to use this tool versus sibling tools (e.g., when to use list_subscriptions instead). No exclusions or when-not-to-use advice is given.

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

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

Annotations already indicate safe read-only, idempotent behavior; the description adds valuable behavioral details: parallel fan-out to multiple sources, GDELT preferred with GNews fallback, USPTO soft-fail due to API sunset, and output structure (changes[] grouped by source, total_changes, citation URIs). No contradictions with annotations.

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

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

Description is well-structured and front-loaded with common query patterns. At ~150 words it's slightly long but every sentence adds value. Could be marginally more concise, but the balance is good.

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 return format (changes[] grouped by source, total_changes, citation URIs). It also covers fallback behavior, potential failure modes, and parameter constraints. For a complex multi-source tool, this is complete and sufficient for correct invocation.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value with examples of relative shorthand for since ("7d", "30d", "3m", "1y"), typical monitoring suggestion ("30d" or "1m"), and alternative value format (zero-padded CIK). These clarifications go beyond the schema and justify a 4.

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

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

The description clearly defines the tool as a change feed for a company over a time window, with explicit example queries and a distinct sibling tool (entity_profile) for static profiles. It lists the specific sources fanned out (SEC EDGAR, GDELT/GNews, USPTO), leaving no ambiguity about what it does.

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

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

Provides explicit when-to-use guidance via example queries and direct contrast with sibling ("Use entity_profile instead when you want the static profile"). No ambiguity about when to invoke this tool versus alternatives.

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

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

Description adds value beyond annotations by explaining scoping by identifier, persistence details, and that it stores key-value pairs. No contradictions with annotations.

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

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

Two sentences, no waste, front-loaded with purpose. Uses concise examples and clear structure.

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

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

For a simple tool with 2 params and no output schema, the description covers purpose, usage, persistence, and pairing with siblings completely.

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

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

Schema covers both parameters (100% coverage). Description adds context with naming conventions and examples (e.g., 'subject_property'), enhancing the schema's meaning.

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

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

The description clearly states the tool saves data for reuse across conversations or sessions, with specific examples (ticker, address, preference) and pairs with recall/forget, differentiating it from siblings.

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

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

Explicitly says when to use (when discovering something worth carrying forward) and mentions alternatives (pair with recall/forget), plus persistence differences for authenticated vs anonymous users.

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, and idempotentHint, so the safety profile is known. The description goes far beyond that: it explains internal cascading of multiple endpoints, graceful degradation when GLEIF or OpenFIGI are unavailable, how identifiers are labeled by source, and how unresolved identifiers are explicitly listed. This is exactly the kind of context that saves an agent from misinterpreting results.

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

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

The description is long, but every clause earns its place given the tool's complexity. It front-loads the purpose with example queries, then organizes the supported types and their nuances in a readable structure. It could arguably be tightened, but the density is justified; the structure and flow make it usable rather than overwhelming.

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 two entity types, multiple upstream sources, and important edge cases, the description covers everything an agent needs to call it correctly: the behavior on multiple matches, the fallback behavior, the output fields like `figi_candidates` and `unresolved`, and even the fact that it replaces 2-3 manual lookups. Although there is no output schema, the description communicates the critical aspects of the return shape.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaning that would be impossible to infer from the schema alone. It clarifies that 'value' for a company can be a ticker, CIK, ISIN, or name, and for a bond the value must be the issuer name as printed. It warns against passing the full noun phrase and gives an example. This is rich, actionable 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 states a very specific verb ('resolve'), a resource (names to canonical identifiers), and gives concrete example queries that signal exactly when to use it. It clearly distinguishes itself from siblings like entity_profile or compare_entities by framing it as the 'first' step when you have a name but need an ID.

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 'Use FIRST whenever you have a name but need an ID' tells the agent when to reach for it. It gives detailed input formatting rules (e.g., pass issuer name only, not the full noun phrase), and walks through the two supported types and their sub-types. It even covers the multi-match case and what the tool returns versus what it does not assert.

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, etc.) are already present, but the description adds value by revealing it internally calls ai_visibility_check per entity, ranks by score, and returns score, confidence, and signal density. No contradictions.

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

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

Two well-structured sentences covering purpose, mechanism, and output. No fluff, every clause carries information. Front-loaded with the main 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?

With no output schema, the description fully explains return format (ranked list with score, confidence, signal density). Covers all parameters, use case, and internal sub-call behavior. Complete for an agent to invoke correctly.

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

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

Schema description coverage is 100%, but the description adds context beyond schema: first entity is 'subject', models default to workers-ai, _apiKey conditions, and context purpose for disambiguation. Adds meaningful nuance.

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

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

The description clearly defines the tool as comparing AI visibility across multiple entities, using specific verbs ('compare', 'probes', 'ranks') and resources ('competitor AI presence'). It distinguishes from siblings like ai_visibility_check (singular probe) and compare_entities (general comparison).

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

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

Explicit usage context is given: 'competitive AI-marketing audits' and an example question. It mentions the first entity is treated as 'subject', giving implicit guidance on parameter ordering. Lacks explicit 'when not to use' statements, but clear enough for appropriate 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 indicate readOnly, openWorld, idempotent, non-destructive. The description adds significant behavioral detail: composite two APIs, partial failures (bundlephobia may timeout 5-30s), sources_failed list, and specific return fields. This goes well beyond the annotations.

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

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

The description is somewhat lengthy but every sentence adds value. It is front-loaded with the purpose, then details behavior and return values. Could be slightly tighter but adequately structured.

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

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

No output schema is provided, so the description must cover return values. It lists the summary block fields, per-advisory detail, links, and recent alternative versions. It also explains partial failures, making the context complete.

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

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

Schema coverage is 100%. The description adds meaning beyond the schema: 'Scoped packages (e.g. '@types/node') are accepted.' and 'Defaults to the latest published version when omitted.' This provides useful context for parameter usage.

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

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

The description explicitly states the tool is a composite check for 'should I add this npm package to my project', fanning out across deps.dev and bundlephobia. It clearly identifies the action (scan) and resource (dependency), and distinguishes from siblings by focusing on npm packages and specific metrics.

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

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

The description provides clear usage cues: 'is X safe / popular / small' or 'what does adding lodash cost me'. It also notes NPM ecosystem only in v1, and that other ecosystems fall under deps.dev:version directly. However, it doesn't explicitly state when not to use it beyond the ecosystem limit.

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 behavioral traits beyond annotations: uses BGE-base-en embeddings, cosine similarity over 500-char overlapping windows, 200K char cap with truncation flag, and passages include offsets for verification. No contradiction with annotations.

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

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

Description is concise with 4 sentences, front-loaded with purpose and usage, followed by technical details. No redundant text.

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

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

Completely explains behavior, return format (passages with offsets and scores), and pairing with sibling tool. Adequate for a complex tool without output schema.

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

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

Schema coverage is 100% and the description adds meaning: maximum chars for 'text', query examples, and range for 'limit'. It also explains the algorithm, which enhances understanding of parameter usage.

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

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

The description clearly states it does semantic search inside a fetched record, specifying the verb 'search' and resource 'inside a fetched record'. It distinguishes from sibling tools like ask_pipeworx_grounded by explaining the use case of large records.

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

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

Explicitly says when to use: 'when the record is too big to cram into the prompt'. It also explains pairing with ask_pipeworx_grounded and implies not to use when the record is small.

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 important behaviors: requires Pipeworx OAuth account, each type's parameters, delivery channel constraints (phone verification, 10/day cap, webhook auto-disable). The idempotency hint is not addressed in the description, creating slight ambiguity but no contradiction.

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

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

The description is front-loaded with the main purpose. It is somewhat lengthy due to detailed examples, but every sentence adds necessary context. Could be slightly more concise without losing clarity.

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

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

Given no output schema, the description explains the return value (subscription ID) and webhook signing secret. It covers key behaviors like auto-disable and verification requirements. Missing details on idempotency or feed polling specifics, but overall complete for a creation tool.

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

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

The description adds significant value beyond the schema by providing concrete examples for each type (e.g., sec_8k with items codes, delivery details like webhook signing secret) and clarifying constraints. Schema coverage is 100%.

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

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

The description clearly states the tool creates a proactive monitoring subscription and returns the new subscription ID. It differentiates from sibling tools like list_subscriptions, unsubscribe, and recent_alerts by focusing on creation.

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 supported types and delivery options with constraints, providing context for when to use each type. However, it lacks explicit guidance on when to use this tool versus alternatives (e.g., using list_subscriptions for existing subscriptions).

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

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

The description goes beyond annotations by detailing the return format (category-bucketed example questions with exact tool + argument shape) and behavior (no args vs topic). Annotations already indicate read-only, open-world, idempotent, non-destructive; description adds significant behavioral context without contradiction.

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

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

The description is comprehensive but a bit lengthy. It is well-structured with examples first, then output description, then usage instructions. Every sentence adds value, but could be slightly more concise without losing context.

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

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

Despite lacking an output schema, the description fully explains the return value (category-bucketed example questions with exact tool + argument shape). It covers all aspects: purpose, usage, parameter, behavior, and is complete given the tool's simplicity.

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

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

Schema coverage is 100%, and the description adds extra context for the topic parameter by listing example values and explaining the behavior of omitting it. The description aligns with the schema and provides slight added value.

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

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

The description clearly states the tool's purpose as the onboarding entry point, using multiple example queries and explaining that it returns category-bucketed example questions. It distinguishes itself from sibling tools by mentioning it teaches meta-tools like ask_pipeworx, entity_profile, etc.

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

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

Explicitly says 'Use this FIRST when you do not yet know what Pipeworx can do', providing clear guidance on when to use. Also explains how to call with no arguments for a full spread or pass a topic for focus, and mentions alternatives indirectly by naming meta-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?

Discloses that the row is deactivated (not deleted) and historical events remain available, adding valuable behavioral context beyond annotations which only indicate idempotent and non-destructive.

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

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

Two sentences, front-loaded with action. Every sentence adds value; no redundancy or filler.

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

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

Single required parameter, no output schema. Description covers action, ownership constraint, and lifecycle behavior comprehensively.

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 id parameter. Description adds context about where the id comes from (returned by subscribe), slightly enhancing schema meaning.

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

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

Clearly states 'Cancel a subscription by id' with specific verb and resource. Distinguishes from siblings like subscribe and list_subscriptions.

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

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

Provides ownership enforcement context, indicating when it can be used (own subscriptions only). Does not explicitly list when not to use or alternatives, but the constraint 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?

Beyond the annotations (read-only, idempotent), the description discloses crucial behavioral nuances: `could_not_verify` means the check did not happen and must not be treated as evidence, while `unsupported` means no source covers it. It also explains the structured vs. grounded pipeline and the presence of `verification_error`. This adds significant context beyond the annotation hints.

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

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

The description is long but every sentence earns its place: trigger phrases, use cases, internal routing, return values, error semantics, and efficiency gains. It is well-structured, starting with user-friendly examples and progressing to technical details, making it dense but not bloated.

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

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

With no output schema, the description must fully specify return values, and it does: verdicts, actual values with citations, reasoning, and the special meaning of `could_not_verify`. It also covers fallback routing and error handling, making it complete for an agent to select and invoke correctly.

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

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

The input schema already provides 100% parameter coverage with rich descriptions, including examples and detailed tolerance semantics. The main description adds little parameter-specific meaning beyond what is in the schema, so the baseline 3 is appropriate; it does not need to compensate for any schema gaps.

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

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

The description clearly states the tool's function: natural-language claim verification against authoritative sources. It provides trigger phrases and explicitly differentiates the tool from generic search by noting it replaces a multi-step pipeline. This makes its purpose unambiguous and distinct from siblings.

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

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

The description explicitly tells the agent when to use the tool ('whenever the agent needs to check whether something a user said is factually correct') and distinguishes two paths (company-financial vs. any other factual claim). It also explains that it replaces 4–6 sequential calls, giving a clear reason to choose it over alternative multi-step approaches.

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