Data Nola

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds value by explaining the default model (Workers AI Llama-3.3-70b), the BYO key requirement for Anthropic, and the return structure (per-model score, confidence, signals, raw_response + combined view). It does not contradict annotations and provides useful behavioral context beyond what annotations offer.

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

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

The description is three sentences, front-loaded with the core purpose, followed by model details and use cases. Every sentence adds necessary information 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 has 4 parameters (all with schema descriptions), no output schema, and annotations, the description is complete. It explains the return format, default behavior, and typical use cases, enabling an AI agent to understand when and how to use the tool effectively.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by clarifying the relationship between 'models' and '_apiKey': it explains that Anthropic probing requires the _apiKey and that the default model is free. This goes beyond the schema descriptions, which are already present. The description also reinforces the purpose of the 'entity' 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 tool's action: probing LLMs for knowledge about an entity and scoring visibility (0-100) per model. It specifies the verb 'probe', the resource 'one or more LLMs', and the output format. It also differentiates from sibling tools by mentioning specific use cases like AI-marketing audits and competitive monitoring.

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

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

The description provides clear context for when to use the tool: AI-marketing audits, pre-launch brand checks, competitive monitoring. It explains default model behavior and how to include Anthropic via _apiKey. However, it does not explicitly state when NOT to use the tool or mention alternative sibling tools, so it's slightly below a 5.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. Description adds that it returns structured answers with citation URIs and routes to the right tool. No contradictions. Could mention rate limits or response time, but overall good.

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 verbose but well-structured. Front-loaded with key directive ('PREFER OVER WEB SEARCH'), then flows into details, examples, and comparisons. Every sentence adds value; could be slightly trimmed but effective.

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,552 tools, 1,160 sources) and no output schema, the description covers purpose, usage guidelines, examples, and sibling differentiation. No gaps for typical use.

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

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

Schema has 6 parameters (question + 5 aliases) with 100% coverage. Description adds value by explicitly listing aliases ('Accepts query, q, prompt, text, input') and explaining the main parameter is a natural language question. Examples in schema further clarify 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 routes questions to 4,552 tools across 1,160 sources to answer factual questions about specific domains like SEC filings, FDA data, etc. It distinguishes itself from siblings like ask_pipeworx_grounded and deep_research.

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

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

Explicitly says 'PREFER OVER WEB SEARCH', provides when to use (factual questions, 'what is', 'look up', etc.), when to step up to alternatives (ask_pipeworx_grounded, deep_research), and gives examples. No ambiguity.

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., establishing safety. The description adds valuable behavioral context: it costs one extra LLM call, returns explicit refusal reasons, and extracts answers using ONLY the tool result. No contradiction with annotations. A higher score is not given because annotations already cover the core safety profile.

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 fairly long but every sentence adds value: purpose, routing, extraction mechanism, return structure, usage context, and cost trade-off. It is front-loaded with the key phrase 'Hallucination-resistant answer mode.' Minor redundancy exists (e.g., mentioning both routing and extraction), but overall efficient. Score 4 because it could be slightly more concise without losing substance.

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 (high-stakes reads, structured refusals, cost implications), the description covers all essential aspects: when to use, how it works, return format with possible values, and trade-off against sibling. Without an output schema, the return structure is fully described, making the tool usable without external documentation.

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

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

Schema coverage is 100%, so the schema already documents all six parameters (with aliases). The description mentions that the question should be in natural language and lists aliases, but does not add deeper meaning beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly identifies the tool as a hallucination-resistant answer mode for high-stakes reads. It specifies the verb (extracts answers from tool results) and resource (returns structured response with evidence and refusal reasons). It distinguishes itself from the sibling ask_pipeworx by noting it is for high-stakes reads versus casual lookups.

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

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

The description explicitly states when to use the tool: whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts, with examples like financial verdicts and medical lookups. It also provides a clear exclusion: 'prefer ask_pipeworx for casual lookups.' The cost difference is noted, helping the agent decide.

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 extensively details behavioral traits beyond the annotations (which already declare readOnlyHint and idempotentHint). It covers classification, fan-out logic, response shapes, resolver contract with confidence levels, parent_event extraction, news field fallbacks, safety short-circuits for low confidence, closed market handling, wide spread warnings, and resolution-rule risk parsing. 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 very long and dense, with extensive detail that reads like a reference manual. It is well-structured with clear sections (CLASSIFIERS, FAN-OUT EXAMPLES, RESPONSE SHAPES, etc.), but it is not concise. The critical information is front-loaded in the first sentence, but subsequent details, while valuable, overwhelm brevity.

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

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

Given the tool's complexity (3 parameters, no output schema, rich behavioral nuances), the description is exceptionally complete. It covers input variations, internal processing, output structure (market, analysis, evidence), resolver contract, parent events, news fallbacks, safety mechanisms, closed market handling, and cancellation rules. The absence of an output schema places the burden on the description, which it fully meets.

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

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

Schema description coverage is 100% with good parameter descriptions. The tool description adds meaningful context beyond the schema, such as default values for 'depth' (thorough) and 'include_raw' (false), and clarifications like 'keeps responses under ~20KB' for include_raw. This enhances the agent's understanding of parameter behavior.

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

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

The description clearly states the tool's purpose: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies the resource (Polymarket bet), the action (research via data pulling), and the input types (slug, URL, question text). It distinguishes from sibling tools like 'ask_pipeworx' and 'polymarket_edges' by emphasizing comprehensive one-call research with fan-out to multiple data sources, giving it a distinct role.

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

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

The description provides explicit usage context: 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z".' It includes examples of fan-out for different bet types, but does not explicitly say when not to use the tool or mention alternatives. The guidance is clear and context-rich, but lacks exclusionary statements.

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

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

The description adds significant behavioral context beyond annotations: it explains that for type='company' it pulls latest 10-K revenue/net income/cash/debt from SEC EDGAR/XBRL, handling fiscal year variances. For drugs, it pulls FAERS counts. It notes results are sorted by primary metric. Annotations (readOnlyHint, idempotentHint) are consistent with read-only, idempotent 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 thorough but slightly verbose; it front-loads the key query patterns and use cases, then details behavior. Every sentence adds value, though some phrases (e.g., '— side-by-side comparison of 2–5 companies or drugs in ONE parallel call') could be tightened. Still very efficient for the information density.

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 specifies that returns include paired data and citation URIs. It covers input constraints, data sources, sorting behavior, and the scope of entities. For a comparison tool replacing 8–15 sequential lookups, the description is fully complete.

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

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

Schema coverage is 100%, and the description enriches meaning: it explains the 'type' enum with what data each returns, and details 'values' format (tickers/CIKs for company, drug names for drug) with concrete examples. This goes beyond the schema's minimal descriptions.

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

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

The description clearly states the tool's function: side-by-side comparison of 2–5 companies or drugs. It distinguishes itself from sibling tools (e.g., entity_profile) by explicitly advocating preference over sequential single-pack lookups. Example queries like 'Compare X and Y' and 'which is bigger' make the purpose instantly clear.

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

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

The description provides explicit guidance on when to use this tool (for comparing entities, with examples of user intents) and when to prefer it over alternatives (sequential lookups). It details the expected input for each type (tickers/CIKs for companies, names for drugs) and the number of entities (2–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?

Describes internal behavior (question decomposition, parallel tool routing), output format (findings packet with evidence, confidence, source, citation, gaps[]), and important traits (never invents, returns empty gaps for uncataloged topics, expected latency 15-60s). Annotations already indicate read-only, open-world, idempotent; description adds rich 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?

Concise yet comprehensive at ~150 words across 3 paragraphs. Front-loads essential prerequisites (account requirement) and alternatives, then core functionality, then usage guidance. Every sentence provides 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?

Given the tool's complexity and lack of output schema, the description covers all necessary aspects: purpose, prerequisites, usage boundaries, behavioral details, parameter specifics, expected output, and alternatives. No gaps or missing information.

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

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

Schema coverage is 100% with descriptions for both parameters, so baseline is 3. Description adds valuable context about depth pricing (paid plan for 'thorough') and clarifies that questions can be broad and multi-part. This extra information enhances 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?

Clearly states the tool performs grounded multi-source research across 1160 structured data sources, decomposing questions into facets and routing to tools in parallel. Distinguishes itself from siblings like ask_pipeworx by specifying it's not open-web search and is best for broad questions.

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 provides when to use (broad/multi-part questions over structured data) and when not to use (single lookup, breaking news, colloquial current news) with directions to alternative tools (ask_pipeworx). Also notes account requirement and alternative for non-signed-in 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 and idempotentHint; description adds valuable context about returning ready-to-call tools with full schemas, 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?

Concise, front-loaded sentence 'Find tools by describing the data or task.' followed by well-structured details without fluff.

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

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

Given 6 parameters, no output schema, and high schema coverage, the description sufficiently explains purpose, return format, 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%, and description adds meaning beyond schema by explaining the query's natural language nature, aliases, and what the tool returns (top-N, curated examples).

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

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

The description clearly states the tool finds tools by describing data or task, lists many specific domains, and explicitly says to call it first to see options, distinguishing it from sibling tools.

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

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

Provides explicit use cases and timing ('Call this FIRST'), and implies when not to use (not for a single answer). However, does not list explicit alternatives or when-not conditions.

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, and destructiveHint. The description adds behavioral context: it fans out across multiple sources, notes the USPTO patent API sunset May 2025 and soft-fail, and explains the GDELT→GNews fallback. It also clarifies that names are not supported.

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

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

The description is relatively long but efficiently packs information. It front-loads with example queries, then details sources and return fields. Every sentence adds value, though it could be slightly more structured. Overall, it is appropriately concise for the tool's complexity.

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

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

Given no output schema, the description fully covers return values: cik, company_name, recent_filings (with URIs), fundamentals, patents (with sunset note), news (with fallback), LEI. It also explains supported inputs and limitations. For a 2-parameter tool with no nested objects, this is comprehensive.

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 extra context: for 'type' it says only 'company' supported, with 'person/place coming soon'; for 'value' it reiterates the ticker/CIK format and the name restriction. While the schema already includes these details, the description reinforces the name prohibition and future plans, adding moderate 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: 'full cross-source profile of a US public company in ONE parallel call'. It lists specific data sources (SEC EDGAR, XBRL, USPTO, news, GLEIF) and return fields. It distinguishes from sibling tools like chained lookups by emphasizing preference for this single call.

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

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

The description provides explicit usage scenarios: when users ask 'Tell me about X', 'research Acme', etc. It states 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups'. It also advises that names are not supported and to use resolve_entity first for names.

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. The description states 'Delete' which aligns with destructive, but adds no new behavioral details beyond what annotations cover.

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

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

Two sentences that front-load the action, then provide usage context and pairing advice. Every sentence is informative with no redundancy.

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

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

For a simple tool with one parameter and no output schema, the description is complete. It covers purpose, usage guidelines, and pairing, and annotations cover behavioral traits.

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

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

Schema covers 100% of parameters with a description for 'key': 'Memory key to delete'. The description uses 'by key' but adds no additional semantic value beyond the schema.

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

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

The description clearly states 'Delete a previously stored memory by key', specifying the verb (Delete) and resource (memory). It distinguishes from sibling tools 'remember' and 'recall' by explicitly mentioning deletion and pairing.

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

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

The description provides explicit when-to-use scenarios: 'when context is stale, the task is done, or you want to clear sensitive data'. It also advises pairing with remember and recall. No explicit when-not-to-use, but the guidance is clear and contextual.

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 details beyond annotations: fetches page, extracts title/description/key links, emits markdown format. Annotations indicate readOnly, idempotent, non-destructive, which align with description. 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?

Three concise sentences with no filler. Front-loaded with purpose and ends with practical use cases. Every sentence adds value.

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

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

For a 2-param, no-output-schema tool, the description explains process and output format adequately. Minor gap: exact llms.txt format not described, but it's a known standard. 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% and descriptions cover both parameters. Description adds no additional meaning beyond what's in the schema (e.g., default and max values already stated). Baseline score 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?

Clear verb 'generate' and resource 'llms.txt file' with specific use cases. No sibling tool duplicates this function, making it easily distinguishable.

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

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

Explicitly lists three use cases (client indexing, own project, competitor audit) but does not mention when to avoid using it or name alternative tools. Still clear enough.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds behavioral details beyond annotations, such as that it returns specific fields and only active subscriptions by default. 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 three sentences with no extraneous information. It front-loads the purpose, then provides usage guidance. Every sentence is essential.

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

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

Given the tool's simplicity (one optional boolean parameter, no output schema), the description covers the purpose, return fields, and usage context. The annotations cover safety and idempotency. The description is complete for the tool's complexity.

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

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

There is only one parameter (include_inactive) with a schema description that already explains its purpose. The tool description does not add further semantic detail beyond what is in the schema. Schema coverage is 100%, so baseline score of 3 is appropriate.

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

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

The description clearly specifies 'List the caller's active subscriptions' and enumerates the returned fields. It distinguishes from sibling tools like subscribe and unsubscribe by explicitly listing 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?

The description states when to use this tool: 'to review what you're monitoring before adding more or to find an id to cancel.' This provides clear context and implies when not to use (e.g., when you want to modify subscriptions, use subscribe/unsubscribe instead).

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive. The description adds that it returns dataset names, descriptions, and resource IDs for use with nola_query, which provides useful behavioral context beyond the schema but does not contradict annotations.

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

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

The description is a single, well-structured sentence that front-loads the action and purpose. Every part is necessary and there is no redundant or verbose language.

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 low complexity, presence of annotations, and no output schema, the description is complete. It explains the functionality, output, and relationship to a sibling tool, which is sufficient for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 100% for all 4 parameters. The description does not add additional parameter-level semantics beyond what the schema already provides, so baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: search the New Orleans open-data catalogue by keyword for datasets. It specifies the output (names, descriptions, Socrata resource IDs) and connects to sibling tool nola_query, distinguishing it from other tools like nola_recent.

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

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

The description implies when to use the tool: when you need to find dataset IDs for querying with nola_query. It doesn't explicitly exclude alternatives, but the context from sibling names (nola_recent, nola_query) helps. An explicit 'when not to use' would improve clarity.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds domain-specific context (SoQL syntax, resource id format) and mentions the optional _apiKey for rate limits, aligning 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 concise, front-loaded, and contains only three sentences with no redundant information. Every sentence adds value.

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

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

Given the complexity (8 parameters, no output schema), the description covers purpose, resource discovery, and SoQL syntax. It does not describe the return format or error handling, but the annotations provide adequate safety guidance.

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 each parameter. The description adds a high-level overview of SoQL clauses and an example resource id, but does not significantly enhance beyond the schema.

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

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

The description explicitly states the tool runs a raw SoQL query against New Orleans open-data resources, identified by Socrata id. It clearly differentiates from sibling tools by mentioning nola_datasets and nola_recent for resource discovery.

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 mentions full SoQL capabilities and directs users to siblings for finding resource ids. It does not explicitly state when not to use this tool, but the guidance is clear and sufficient for typical use cases.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds behavioral details: 'Returns the latest rows (newest-first)', optional limit, SoQL where filter, and default keyless endpoint. No contradictions. Slight deduction for not mentioning output format or rate limits.

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

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

The description is concise (three sentences), front-loads purpose and usage guidance, and avoids fluff. Every sentence adds value: purpose, preference over web search, dataset names, behavior, and fallback to nola_query.

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

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

Given the tool's simplicity and the absence of an output schema, the description covers the core functionality, usage context, and limitations. It mentions the datasets, ordering, filtering, and when to use alternatives. Could optionally mention return format, but this is sufficient for an agent to invoke correctly.

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

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

Schema coverage is 100%, so the schema describes all parameters. The description adds context beyond the schema by explaining the dataset names ('311, crime, permits') and the purpose of the where parameter ('Add a SoQL `where` to filter; for anything else use nola_query'). This enriches understanding beyond raw schema definitions.

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

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

The description clearly identifies the tool's purpose: returning recent records from New Orleans open datasets by friendly name, avoiding the need for Socrata IDs. It specifies the verb ('returns the latest rows') and resource ('common New Orleans open dataset'), and distinguishes from sibling tools like nola_query and web search.

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

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

The description explicitly states when to prefer this tool over web search (e.g., for 'recent crime in New Orleans') and directs users to use nola_query for anything beyond a SoQL where clause. This provides clear guidance on tool selection.

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

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

The description discloses rate limiting (5 per identifier per day), cost (free, no quota impact), and how feedback is used (team reads digests, influences roadmap). Since annotations are all false, the description carries the full burden and handles it well, with 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 three sentences with clear front-loading. Each sentence adds value: purpose, usage, behavioral details. While succinct and well-structured, a slight improvement could be more explicit separation of usage scenarios, but it remains effective.

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

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

Given the tool's simplicity (3 parameters, no output schema), the description covers all necessary aspects: what inputs to provide (type, message, context), how to format them, rate limits, and cost. It does not need to explain return values as the tool is fire-and-forget. Completeness is high.

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

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

Schema coverage is 100%, so baseline is 3. The description adds extra guidance for the message parameter, instructing users to describe issues in terms of Pipeworx tools/packs and not paste end-user prompts. This adds meaningful context beyond the schema, justifying a 4.

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

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

The description clearly states the tool's purpose: sending feedback to the Pipeworx team about bugs, missing features, or praise. It uses specific verbs and resources, and distinguishes itself from sibling tools that are query/research-oriented. The description includes explicit categories (bug, feature, data_gap, praise) and what not to do, making it highly specific.

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

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

The description provides explicit when-to-use scenarios: for bugs when tools return wrong data, for feature requests when tools don't exist, and for praise. It also advises against pasting end-user prompts. This guidance helps an agent decide when to invoke this tool versus others.

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. The description adds valuable behavioral context: aggregation source (CF analytics-engine), no PII, and caching (5min-1h). 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 concise (4 sentences) with clear bullet-like structure for use cases. Every sentence adds value without redundancy. Appropriately sized for a simple tool.

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

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

The tool has no output schema, so the description should explain the return format. It mentions 'top tools, top packs, and total call volume' but does not detail structure (e.g., list, counts, sorting). Lacking complete output specification.

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?

Only one parameter (window) with 100% schema coverage. The description adds meaning beyond the schema by explaining the trade-off between window lengths ('hot right now' vs 'steady-state demand'), which helps the agent choose.

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

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

The description clearly states that the tool returns 'top tools, top packs, and total call volume' over a specified window, using the verb 'Returns'. It distinguishes itself from siblings like 'ask_pipeworx' and 'discover_tools' by focusing specifically on trending usage statistics.

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 explicit use cases are listed: discovering hot data sources, confirming canonical tools, and checking alignment. Window selection guidance is provided (shorter for hot, longer for steady-state). It doesn't explicitly state when NOT to use, but the context is clear.

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

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

Annotations declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, which are consistent with the description. The description goes beyond annotations by detailing the scanning scope (top ~200 markets), partition filter logic (placeholder slugs, Jaccard similarity >0.30), and the fill check against live CLOB depth. It transparently states that deviations under 3pp are ignored and warns when book depth is insufficient.

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 fairly long but well-structured with capitalized section headers (SEMANTIC ANCHOR, PARTITION FILTER, FILL CHECK) that aid scanning. It is front-loaded with the core purpose and mode choices. While it could be slightly more concise, every sentence adds necessary detail for correct tool usage.

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 (arbitrage detection with multiple checks, two modes, and fill verification), the description is thorough. It explains the response structure (opportunities[], partition_check, etc.) despite no output schema, and references a sibling tool for custom sizing. The description leaves no significant gaps for an agent to misunderstand.

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 significant meaning beyond the schema. For 'event', it clarifies that full Polymarket URLs are accepted and provides examples. For 'topic', it explains that it acts as a seed question for cross-event scanning. This helps the agent understand parameter usage correctly.

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

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

The description clearly states that the tool finds arbitrage opportunities on Polymarket using monotonicity violations and partition-sum checks. It distinguishes from sibling tools by specifying the unique approach and explicitly differentiates the two modes (event vs topic). The purpose is immediate and unambiguous.

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

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

The description provides explicit guidance: call with no args for trending scan, use 'event' for a specific market slug, and 'topic' for cross-event scanning. It explains when to use each mode, including that cross-event mode catches patterns missed by single-event mode. It also warns when not to trade (realizable_edge_pp <= 0) and directs to polymarket_fill_risk for custom sizing, offering clear 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?

Despite annotations already declaring readOnlyHint, openWorldHint, and idempotentHint, the description adds extensive context: caching behavior (1h KV-level cache keyed on all knobs), response structure (segments and diagnostics), edge calculation details (model families, slippage, Kelly sizing), and tradeable-edge filters. It also explains why certain data (Fed bets) is excluded from ranking due to unreliability.

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

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

The description is lengthy but well-structured with sections for model families, response segments, tradeable-edge knobs, response top-level, and diagnostics. It front-loads the purpose and uses clear separation. However, it could be more concise; some detailed technical explanations (e.g., model-specific α values) might be better suited for documentation.

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 9 optional parameters and no output schema, the description is remarkably complete. It covers all response fields (including diagnostics), explains why segments might be empty, and describes caching behavior. The tradeable-edge knobs are thoroughly explained, and edge metrics are defined (edge_pp_net, kelly_fraction, etc.). The agent can fully understand what to expect from a call.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining parameter interactions (e.g., min_kelly vs min_partition_leg_kelly, tradeable-edge knobs like min_liquidity and max_spread_pp). It provides context beyond the schema, such as default values (e.g., min_edge_pp default 0.5) and advice (e.g., 'bump for very thin partitions').

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 core function: 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price.' It specifies the verb (scan), resource (Polymarket markets), and unique value (disagreement with Pipeworx data). This distinguishes 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 explicitly targets the use case 'what should I bet on today' and notes that it saves agents from paging hundreds of markets. It implies utility over alternatives but does not explicitly state when not to use it or compare directly to sibling tools like polymarket_arbitrage. The tradeable-edge knobs provide guidance on parameter settings for realistic execution.

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?

Disclosures beyond annotations: explains output structure (tracked, expired, snapshot_dates), limits (60-day TTL, gaps from cache miss), and computation details (decay from daily closes). 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?

Front-loaded with core purpose, then logically breaks down response fields, ends with limitations. Every sentence adds value; no redundancy.

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

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

Given no output schema, the description fully covers return values, edge cases (expired opportunities, gaps), and limitations. Provides sufficient context for an agent to understand and use the tool.

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

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

Schema already provides descriptions for both parameters (100% coverage). Description adds defaults and clarifies constraints (e.g., 'max 30' vs schema's 'clamp 2-30'), and explains how parameters affect output.

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

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

Clearly states it provides edge persistence and decay telemetry from daily snapshots, answering a specific question about edge age. Distinguishes itself from related tools like polymarket_edges by focusing on historical persistence.

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?

Implicitly guides when to use this tool by contrasting fresh vs old edges, but does not explicitly state when not to use it or reference sibling tools like polymarket_arbitrage for alternative use cases.

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

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

Annotations declare readOnlyHint, idempotentHint, non-destructive. The description adds behavioral details: it checks live order book, returns verdicts (clean|degraded|cannot_fill), and warns about partial fills creating unhedged positions. 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 and well-structured with bolded mode names and key terms. It front-loads the requirement for market or event. However, it is slightly verbose with repeated concepts (e.g., basket mode explanation). Could be tightened while preserving completeness.

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, so the description must cover return values. It lists all fields for both modes (top_of_book, vwap_fill_price, slippage_pp, verdict, etc.) and addresses edge cases (thin_legs, forced_directional_risk). Comprehensive for a complex tool with two modes.

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 decent descriptions. The tool description adds context: explains default side auto-logic for basket mode, clarifies size_usd interpretation (spend vs target proceeds vs settlement notional), and provides defaults. It enhances but does not drastically improve upon 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 performs a 'Realizable-vs-theoretical edge check against live CLOB order-book depth,' distinguishing between single-market and basket modes. It differentiates from sibling tools like polymarket_arbitrage and polymarket_edges by specifying its use case as a prerequisite check.

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

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

Explicit guidance: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500.' It explains when not to use it (theoretical overround not capturable, partial baskets lead to directional risk), providing clear context for selection.

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

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

Annotations indicate readOnly, idempotent, non-destructive. The description adds rich behavioral context: safety fields (compatibility_warning, temporal_alignment, skipped counters) and their conditions. It explains when spreads are meaningful vs not, going well beyond annotations. No contradiction.

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

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

The description is dense with useful information and front-loaded with the core purpose. It is well-structured into modes, response, and safety fields. While slightly verbose, every sentence adds value; minor redundancy exists (e.g., 'the two venues sometimes price…') but does not detract significantly.

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

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

Given the complexity of cross-venue spread computation with safety checks, the description covers all crucial aspects: modes, safety field explanations, temporal alignment, and counters. It compensates for the lack of an output schema by detailing the response structure. The description is complete enough for an agent to understand and use the tool correctly.

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

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

Schema coverage is 100% with parameter descriptions, setting a baseline of 3. The description adds value by explaining the interplay between parameters (topic vs overrides) and detailing the response fields (spread calculations, safety fields). This enhances understanding beyond the schema alone.

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

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

The description clearly states the tool computes the cross-venue spread between Kalshi and Polymarket for the same resolving question. It distinguishes two modes (topic shortcuts and explicit tickers), and the title reinforces the purpose. This is specific and differentiates from sibling tools like polymarket_arbitrage.

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

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

The description explicitly lists two modes with usage guidance: topic mode for 10 pre-mapped macros, and explicit mode for custom pairings. It warns that most pre-mapped topics currently return compatibility_warning and are not tradeable, providing clear when-to-use and when-not-to 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 and idempotentHint; description adds 'list all keys' behavior and scoping details. No contradictions. Provides practical usage context beyond annotations.

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

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

Four sentences, no filler. Front-loaded with the core action, then usage, scoping, and related tools. Every sentence adds value.

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

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

Despite no output schema, the description explains what is returned (value or list). Covers scoping, pairing, and use case. Complete for a simple retrieval 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?

Perfectly explains the single optional parameter: omitting it lists all keys, providing it retrieves a specific value. Schema coverage is 100% and description adds clarity on behavior.

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

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

Clearly states the verb 'retrieve' or 'list' and the resource (saved values/keys). Distinguishes from sibling tools 'remember' and 'forget' by specifically naming them as counterparts.

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

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

Provides explicit use case: 'look up context the agent stored earlier'. Mentions scoping and pairing with remember/forget. Lacks explicit exclusions or when-not to use, but context is clear.

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

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

Annotations declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint. The description adds behavioral details beyond those: the mark_read side effect that flags events as read, the polling suitability, and the specific return fields. 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 concise at 4 sentences, front-loading the main purpose in the first sentence. Every sentence adds necessary information without redundancy. Structure follows a logical flow: purpose, return fields, filtering, side effect, and alternative access.

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 5 optional parameters, no output schema, and rich annotations, the description covers essential context: return shape (source, citation_uri, payload), filtering options, mark_read behavior, polling safety, and an alternative endpoint. No gaps remain for typical usage.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by giving an example for the 'type' parameter ('sec_8k'), specifying ISO timestamp format for 'since', and explaining the effect of 'mark_read'. This goes beyond the schema's 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 uses a specific verb ('Pull fired events from your subscription feed') and clearly identifies the resource ('recent alerts' from a persisted feed). It differentiates from sibling tools like list_subscriptions by specifying it returns alert events with source, citation_uri, and raw payload.

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

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

The description gives context for use: filtering by type and time, using mark_read to manage read state, and polling. It also mentions an alternative access method (GET registry.pipeworx.io/alerts.json), but does not explicitly contrast with sibling tools or state when not to use.

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

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

Discloses the parallel fan-out to SEC EDGAR, GDELT/GNews, and USPTO, including fallback and soft-failure. Details output structure (changes[], total_changes, 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?

Dense but well-structured with examples and clear sections. Slightly long but every sentence adds value; front-loaded with query patterns.

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 structure. Covers error handling and source behavior. All parameters documented in both schema and description.

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?

Adds meaning beyond schema: explains 'since' accepts ISO date or relative shorthand, recommends '30d'; notes 'type' only supports 'company'; specifies 'value' can be ticker or CIK.

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 returns a change feed for a company over a time window, with example queries. It distinguishes itself from the sibling tool 'entity_profile' by specifying when to use each.

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 provides when to use (queries like 'what's new with X') and when not to (use 'entity_profile' for static profiles). Also explains data source preference and fallback behavior.

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 idempotentHint=true and destructiveHint=false. The description adds context about scoping by identifier, persistence for authenticated users, and 24-hour retention for anonymous sessions, which provides additional behavioral insight beyond annotations.

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

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

The description is a single, well-structured paragraph that immediately states the purpose. Every sentence adds useful information without redundancy. It is appropriately sized and front-loaded.

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

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

Given no output schema and two simple parameters, the description covers the essential behavioral aspects (scope, persistence) and references sibling tools. It could mention the return value or effect on previous storage, but overall it is complete enough for a straightforward write operation.

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

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

Schema coverage is 100% with descriptions for both key and value. The description adds value by providing naming conventions for keys (e.g., 'subject_property', 'target_ticker') and clarifying the value as any text. This supplements the schema.

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

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

The description uses a specific verb ('save') and resource ('data the agent will need to reuse later'), clearly distinguishing the tool from siblings like recall and forget. It provides concrete examples of use cases (resolved ticker, target address, user preference).

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

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

The description explicitly states when to use the tool ('when you discover something worth carrying forward') and mentions pairing with recall and forget. It also notes the difference between authenticated and anonymous sessions. However, it does not explicitly state when not to use it or provide alternative tools for other scenarios.

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

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

Annotations declare safety (readOnly, idempotent), and description adds that internal cascading replaces multiple lookups and returns citation URIs, enriching transparency beyond annotations.

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

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

Well-structured and efficient, but could be slightly more front-loaded by putting the core purpose before the query examples.

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?

Thoroughly covers purpose, usage, parameter details, and return values without an output schema, making it fully 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 descriptions are complete, and description adds detailed return types for each entity type, acceptable input formats, and the auto-disambiguation behavior for companies.

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 concrete user queries and clearly states the tool resolves names to canonical identifiers, with specific resource types detailed.

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 FIRST whenever you have a name but need an ID,' providing strong usage guidance. Lacks explicit when-not-to-use, but positive guidance 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?

The description discloses behavioral details beyond annotations: it probes each entity with ai_visibility_check, ranks results, and returns a ranked list with score, confidence, and signal density. Annotations (readOnlyHint: true, idempotentHint: true) are consistent with the description, and no contradictions exist.

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

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

The description is three tightly written sentences, each earning its place. The purpose is front-loaded, followed by method explanation and a usage example. No redundant or unnecessary words.

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

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

No output schema exists, but the description mentions the returned fields (ranking, score, confidence, signal density), which is sufficient. For a tool that probes multiple entities and compares results, the description covers key aspects without being overly long.

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

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

Schema coverage is 100%, so parameters are well documented. The description adds context beyond the schema: it explains that the first entity in 'entities' is treated as the 'subject' for narrative and the rest as competitors. It also clarifies optional use of models and _apiKey.

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

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

The description clearly states the tool compares AI visibility across multiple entities side-by-side, probes each with ai_visibility_check, ranks by score, and surfaces which is most/least recognized. It differentiates from sibling tools like ai_visibility_check (single entity) and compare_entities (likely compares other aspects).

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

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

The description provides explicit context: 'Useful for competitive AI-marketing audits' and gives an example question. It implies when to use the tool (comparing multiple entities) and contrasts with ai_visibility_check for single entities. No explicit exclusions are stated, but the purpose is clear.

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

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

Discloses composite nature (fans out to two services), return fields, partial failure handling (degradation graceful, sources_failed list), and timing behavior (bundlephobia's first measurement can take 5-30s). This goes well beyond the readOnlyHint, openWorldHint, idempotentHint 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?

Every sentence adds value. The description is front-loaded with purpose and usage, then details return structure and limitations. No fluff or redundancy.

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

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

No output schema exists, but the description comprehensively lists return fields (summary block, advisories, links, alternative versions) and explains partial failure behavior. This fully covers what an agent needs to 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?

Schema description coverage is 100%. The description adds no information about parameters beyond what is in the schema. Baseline 3 is appropriate; no extra value provided.

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

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

The description clearly states it's a composite check for evaluating npm packages by fanning out to deps.dev and bundlephobia. It uses specific verbs (scan, check) and resources (npm package). It distinguishes from siblings by focusing on dependency analysis, which is unique among the listed tools.

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

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

Explicitly says 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me". Also provides exclusion: 'NPM ecosystem only in v1; PyPI / Maven / Cargo / Go fall under deps.dev:version directly.' This gives clear when-to-use and when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, etc. The description adds valuable behavioral details beyond annotations: embedding model (BGE-base-en), similarity metric (cosine), window size (500-char overlapping), character cap (200K with truncation flag), and that passages include character offsets for verification.

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

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

The description is five sentences but packed with essential information, front-loading the core purpose and use case, then technical details. Every sentence is informative and there is no redundancy.

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

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

Despite lacking an output schema, the description explains return values (top-N passages with character offsets and similarity scores). It covers cap, truncation, and pairing with another tool, making it complete for the 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% and adequately describes each parameter. The description reinforces the use of 'text' as a fetched record and 'query' as natural-language, with example queries, but does not add significant meaning beyond what the schema already provides.

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

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

The description clearly states the tool performs semantic search inside a previously fetched record, using a natural-language query to return relevant passages. It distinguishes itself from siblings by noting it saves context when the record is too large, and it explicitly pairs with ask_pipeworx_grounded.

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 the record is too big to cram into the prompt' and provides a clear pairing with ask_pipeworx_grounded, effectively guiding when to use 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?

Annotations indicate a write operation (readOnlyHint=false) with idempotency (idempotentHint=true) and no destruction (destructiveHint=false). The description adds valuable behavioral details: the always-on feed, optional delivery channels, webhook signing secret returned once, and auto-disabling after 10 consecutive failures. No contradiction with annotations.

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

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

The description is well-structured: purpose first, then prerequisites, type examples, and delivery details. It is appropriately sized for the tool's complexity, though could be slightly more concise by combining the delivery channel descriptions. Every sentence contributes value.

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

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

Given no output schema, the description states the return value (subscription id). It covers prerequisites, type-specific parameters, and delivery channel constraints. The tool has nested objects and enums, and the description adequately explains them with examples and edge cases (phone verification, webhook retry).

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

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

Schema description coverage is 100% with detailed parameter descriptions. The description adds concrete examples and usage notes for type and params (e.g., items for sec_8k, min_spread_bps for polymarket_edge) and elaborates on delivery constraints (phone verification, webhook signing). This adds meaning beyond the raw schema.

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

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

The description opens with a specific verb+resource: 'Create a proactive monitoring subscription to a live-data event stream. Returns the new subscription id.' This clearly distinguishes it from sibling tools like list_subscriptions, unsubscribe, and recent_alerts, which handle other aspects of subscription lifecycle.

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

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

The description provides clear context for use: it requires a Pipeworx OAuth account, lists supported types with examples, and details delivery channels including constraints (phone verification, 10/day SMS cap). While it does not explicitly exclude any use cases, the information is sufficient for an agent to decide when to invoke this tool.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. Description adds that it returns example questions drawn from a live catalog, which is useful behavioral context beyond annotations.

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

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

Description is relatively long but well-structured: starts with alternative phrasings, then purpose, output format, and usage. Every sentence adds value, though slightly 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 simple discovery tool with no required params and no output schema, the description fully explains the output (category-bucketed examples with tool+argument shapes), 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?

The input schema covers the single parameter with description; the description adds concrete examples ('finance', 'pharma') and clarifies that omitting returns full spread, enhancing beyond the schema.

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

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

The description clearly states the tool returns category-bucketed example questions for Pipeworx, with tool+argument shapes. It distinguishes itself from siblings like ask_pipeworx and entity_profile by emphasizing it is the onboarding entry point.

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

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

Explicitly says 'Use this FIRST when you do not yet know what Pipeworx can do for you' and explains optional topic focus. However, does not mention when not to use or provide explicit alternatives beyond the context of the sibling list.

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

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

The description adds value beyond annotations by explaining that the row is 'deactivated (not deleted)' and that historical events remain available. This complements the idempotentHint=true and destructiveHint=false annotations.

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

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

Two sentences, front-loaded with the action, followed by ownership and deactivation details. No unnecessary words.

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

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

For a single-parameter tool with no output schema, the description covers purpose, ownership, and deactivation behavior. Could optionally mention response format, but not essential.

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 mentions 'by id' but does not add meaning beyond the schema's description of 'Subscription id (uuid) returned by subscribe.'

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

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

The description 'Cancel a subscription by id' provides a specific verb and resource. It distinguishes from sibling tools like 'subscribe' and 'list_subscriptions' by clarifying it's for cancellation, and adds ownership and deactivation details.

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

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

The description states ownership enforcement ('you can only cancel your own subscriptions'), which gives context on who can use it. However, it does not explicitly mention when to use this tool versus alternatives like 'subscribe' or 'list_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?

Annotations already provide safety traits (readOnly, idempotent, non-destructive). The description adds behavioral context: returns verdict, extracted form, actual value with citation, percent delta, and data sources (SEC EDGAR + XBRL). 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 concise and front-loaded with purpose and examples. It efficiently conveys the key information without extraneous words. Slightly long but justified by the detail needed for a complex tool.

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

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

Given no output schema, the description compensates by listing return fields (verdict, etc.). It covers the tool's scope, limitations (only company-financial claims), and integration context. A complete description for a complex tool.

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

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

Schema coverage is 100% with a single parameter 'claim' that has a detailed description and examples. The description does not add significant meaning beyond what the schema already provides, so baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: natural-language claim verification against authoritative sources, specifically for company-financial claims. It provides examples like 'Is it true that…' and mentions the output, distinguishing it from siblings by stating it replaces 4-6 sequential calls.

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

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

The description explicitly says 'Use whenever the agent needs to check whether something a user said is factually correct.' It specifies the domain (company-financial claims) and implies when not to use (other types of claims). It could be more explicit about alternatives, but it does mention it replaces multiple sequential calls.

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