Paperswithcode

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

Annotations already indicate readOnly, idempotent, openWorld, and non-destructive behavior. The description adds context: it is a probe (no mutations), uses external APIs (Workers AI free, Anthropic BYO key), and returns structured results. This extends beyond annotations by explaining cost implications for Anthropic calls.

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

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

The description is three sentences with no redundancy. The first sentence defines the core action and output. The second explains model options and key usage. The third lists practical use cases. Every sentence is necessary and front-loaded with the primary purpose.

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

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

Given the tool's moderate complexity, no output schema, and full annotation coverage, the description provides sufficient context. It explains return structure (per-model fields + combined view) and use cases. It could mention pagination or error handling, but not essential for this probe tool.

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

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

Schema coverage is 100%, so the schema already describes each parameter. The description adds value beyond schema: explains default model, that _apiKey is only needed for Anthropic, and that context disambiguates common names. This enriches understanding of parameter usage.

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

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

The description clearly states the tool's purpose: probing LLMs for knowledge about an entity and scoring visibility. It specifies the output (score 0-100 per model) and use cases (marketing audits, brand checks). This distinguishes it from siblings like scan_competitor_ai_presence by focusing on multi-model visibility scoring.

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

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

The description implies usage for AI-marketing audits and brand checks, and notes default model and optional Anthropic probing. However, it does not explicitly state when not to use this tool or contrast with sibling tools (e.g., scan_competitor_ai_presence). The guidance is clear but lacks exclusions or 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?

No annotations provided, so description carries full burden. Describes that it picks the right tool and fills arguments, but doesn't disclose limits like data recency, source accuracy, or rate limits. Adequate but could add more behavioral context.

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

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

Description is three sentences plus examples, front-loaded with key purpose. Efficient but could be slightly more concise by integrating examples more tightly. Overall well-structured and no fluff.

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

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

Given the tool's simplicity (single parameter, no output schema), the description is complete enough to guide an agent. It explains what the tool does and how to use it. Missing details on response format or error handling, but these are minor given the 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% with a single parameter described as 'Your question or request in natural language.' Description reinforces this with examples but doesn't add new parameter semantics beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool accepts a natural language question and returns an answer from the best data source. It distinguishes itself from sibling tools by abstracting away tool selection and argument filling, making its purpose unique and specific.

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

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

Explicitly tells when to use: when you have a question in plain English and want the system to handle tool and schema selection. Implicitly says not to use sibling tools for direct queries. Provides example questions to guide usage.

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

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

Annotations indicate readOnly, openWorld, non-destructive. The description adds significant behavioral context: it resolves markets, classifies bets, fans out to appropriate packs (crypto+fred+gdelt example), and returns a market-vs-model comparison. 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 front-loaded with the core action in the first sentence. It is slightly verbose with examples and justification ('core demo product'), but all information is relevant and well-organized. A minor trim is possible without losing value.

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

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

Given the complexity of the tool (multi-step research, classification, fan-out), the description covers all necessary aspects: input formats, processing logic, output, and use cases. No output schema exists, but the description outlines the return structure clearly.

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 the 'market' parameter can be slug, URL, or question text, adding slight value. It does not elaborate on the 'depth' parameter beyond what the enum provides. No additional semantic depth beyond schema.

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

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

The description clearly states the tool's purpose: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies the actions (resolve market, classify bet, fan out to packs) and the output (evidence packet plus comparison). This distinguishes it from siblings like 'ask_pipeworx' or 'validate_claim' by focusing on Polymarket betting 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?

The description provides explicit use cases: 'Use for "should I bet on X?", "what does the data say about this Polymarket market?", or "is there edge in this bet?".' It also explains that this tool is better than having agents discover packs themselves. However, it lacks explicit when-not-to-use guidance or 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?

No annotations provided, so description carries full burden. It discloses returned data for each entity type and mentions returning URIs, but does not cover potential errors, authentication needs, 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?

Four concise sentences with no extraneous words. The main purpose is front-loaded, and the description efficiently communicates key details.

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 adequately covers return values. It covers both entity types well but could be more complete on error handling or non-existent entities.

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 already cover both parameters. The description adds value by detailing the metrics returned and the URI output, enhancing understanding beyond the schema.

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

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

The description clearly states it compares 2–5 entities side by side, with specific metrics for company and drug types. It distinguishes itself from sibling tools by being the only comparison tool.

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

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

The description notes it replaces 8–15 sequential calls, indicating efficiency. It provides clear usage context but lacks explicit when-not-to-use scenarios or 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?

No annotations are provided, so the description carries the full burden. It discloses the search behavior (returns relevant tools based on natural language query), the limit parameter, and that it returns names and descriptions. However, it does not mention any limitations like query language support, result sorting, or whether it performs fuzzy matching. A score of 4 is justified because the description gives a clear mental model of operation without deep technical detail.

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

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

The description is two sentences long, each sentence adding essential information. The first sentence states what the tool does and its return value. The second sentence gives usage context. No filler or redundant content. The imperative 'Call this FIRST' is front-loaded and impactful.

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 that there is no output schema and no annotations, the description must explain return format and behavioral expectations. It mentions 'returns the most relevant tools with names and descriptions' which covers the output. However, it does not specify if the output includes a relevance score or ordering, nor does it discuss error handling or query syntax. With sibling tools focused on specific tasks, the description is sufficient for an agent to use this tool effectively, but lacks edge-case detail.

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

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

Schema description coverage is 100%, meaning both parameters (query and limit) are already described in the schema. The description adds that the query should be a 'natural language description' and that the limit defaults to 20 (max 50). This adds some value beyond the schema's type and description fields, but the schema already provides adequate semantic meaning. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Search') and resource ('Pipeworx tool catalog'), clearly states the return type ('most relevant tools with names and descriptions'), and distinguishes from sibling tools by suggesting calling this FIRST. It also explains the scenario (500+ tools) and goal (find right tools), making purpose unambiguous.

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

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

The description explicitly says 'Call this FIRST when you have 500+ tools available and need to find the right ones for your task,' providing clear when-to-use guidance and implying it's a preliminary step before other tools. The sibling tools include specific functions like get_paper, search_papers, etc., and this tool is positioned as a discovery layer, differentiating it from them.

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?

No annotations provided, so description must bear all burden. It states the tool bundles multiple data sources in one call and returns pipeworx:// URIs, implying read-only behavior. However, it doesn't explicitly mention side effects, rate limits, or error conditions. The high-level description is fairly transparent but could detail performance guarantees or failure modes.

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

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

Concise, front-loaded with purpose, then details. Each sentence provides necessary information: what it does, what data it returns, how it compares to alternatives, and prerequisites. No superfluous text.

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

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

Given complexity (multiple data sources) and no output schema, description is quite complete: it lists data categories and mentions citation URIs. However, without an output schema, the agent lacks precise structure of the response. The description partially compensates by enumerating content, but could be more explicit about the return format.

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

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

Both parameters have schema descriptions that are clear. The description adds value beyond schema: for 'value', it advises using resolve_entity if only a name; for 'type', it notes future plans. Schema coverage is 100%, and description enhances understanding.

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

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

Description explicitly states the tool returns a full profile of an entity across multiple Pipeworx packs, listing specific data types (SEC filings, XBRL financials, patents, news, LEI) and mentions it replaces 10-15 sequential calls. It clearly distinguishes from siblings like resolve_entity (needed for name resolution) and usa_recipient_profile (for federal contracts).

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

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

Provides explicit guidance on when to use (comprehensive entity profile), when not to use (federal contracts, use usa_recipient_profile), and prerequisites (use resolve_entity if only a name). Includes context for the type parameter limitation.

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?

No annotations provided, so description carries full burden. It states deletion but does not disclose whether the operation is irreversible, if confirmation is needed, or any side effects (e.g., cascading deletions).

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 a single, concise sentence that is front-loaded with the verb 'Delete'. Every word is necessary, but could be slightly more specific about the resource type.

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 a simple parameter, the description is minimal. It does not explain return value (e.g., success/failure) or error conditions (e.g., key not found).

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% (parameter 'key' documented in schema). Description adds no extra meaning beyond 'delete by key', 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 action (delete) and the resource (stored memory), with the specific parameter 'key'. It is distinguishable from siblings like 'remember' (create) and 'recall' (read).

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

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

No guidance on when to use this tool vs alternatives like 'recall' or 'remember'. Does not mention prerequisites (e.g., memory must exist) or when not to use it.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds behavioral details: fetches the page, extracts title/description/key links, outputs markdown. This goes beyond the annotations by explaining the step-by-step process.

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

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

Three sentences with no waste: first defines purpose, second explains process, third lists use cases. Information is front-loaded and to the point.

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

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

The tool is simple with 2 parameters and good annotations. The description covers purpose, process, and use cases. It does not discuss error handling or edge cases, but for a read-only tool of this complexity, the provided information is sufficient.

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

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

Input schema has 100% coverage with descriptions for both parameters. The description does not add meaningful semantic information beyond that (e.g., no further constraints or formatting hints), 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?

Description clearly states the tool generates a production-ready llms.txt file for AI crawlers. The verb 'generate' and resource 'llms.txt file' are specific, and the tool's purpose is distinct from sibling tools like 'scan_competitor_ai_presence' or 'get_repositories', which cover different domains.

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: indexing a client's site, drafting for own project, auditing competitors. No exclusions or alternative tool pointers are given, but the context is clear and actionable.

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

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

No annotations provided, so description carries full burden. It states the tool returns 'full metadata including title, abstract, authors, and links', which is useful. However, it does not disclose any potential side effects (unlikely for a read tool), rate limits, or whether the ID must be exact. Since the tool is a simple getter, the description is adequate but not comprehensive.

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 short sentences with no redundancy. Front-loaded with the core action and identifier method. Every word 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?

Tool is simple (1 param, no output schema, no nested objects). Description covers what it does and what it returns. Could mention that output structure matches typical paper metadata, but schema already describes the ID. For a simple lookup, this is nearly complete.

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

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

Schema description coverage is 100% (one parameter 'id' with description). The description adds that the ID is a 'Papers With Code paper ID' and gives an example, which aligns with schema. No additional semantic enrichment beyond the schema, so baseline 3 is appropriate.

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

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

Description states 'Get a single paper by its Papers With Code ID', which is a specific verb ('Get') and resource ('single paper') with an explicit identifier. This clearly distinguishes from siblings like 'search_papers' (which returns multiple results) and 'trending_papers' (which is a curated list).

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

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

The description implies usage when you have a specific Papers With Code ID and need full metadata for a single paper. It does not explicitly state when not to use it, but the context of sibling tools (search_papers for queries, trending_papers for discovery) provides implicit guidance. Lacks explicit alternatives for different 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?

No annotations are present, so the description must convey behavioral traits. It correctly indicates a read operation (get) and lists the output fields. However, it does not disclose potential issues like rate limits, authentication needs, or behavior for invalid/missing IDs.

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 extremely concise: two sentences that front-load the purpose and then list key return fields. Every word adds value with no redundancy.

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

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

Given the simplicity of the tool (single required parameter, no output schema, no annotations), the description is nearly complete. It could mention what happens when the paper ID is not found, but otherwise covers the essential details for correct invocation.

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

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

Schema description coverage is 100% (the id parameter is described as 'Papers With Code paper ID'). The description adds no additional detail about the parameter beyond that, but since the schema already covers it, the baseline is 3. No extra value is 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?

Clearly states it retrieves code repositories for a paper, specifying the exact resource (repositories linked to a paper) and action (get by paper ID). The description also lists the returned fields (repo URL, stars, framework, official status), making the tool's purpose unambiguous.

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

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

The description clearly says the tool requires a paper ID, which is explicit in the input schema. It does not, however, provide guidance on when to use this tool versus alternatives like get_paper or search_papers, or note any limitations (e.g., what if no repositories exist).

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?

No annotations are provided, so the description carries the full burden. It discloses the rate limit and the instruction to avoid verbatim prompts, but does not mention authentication requirements, side effects (e.g., whether feedback is stored or sent asynchronously), or what happens upon submission. Adequate but could be more detailed.

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

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

Four sentences front-load the purpose, list use cases, give a key usage rule, and mention rate limiting. Every sentence adds necessary information with 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?

For a tool with three parameters (one nested) and no output schema, the description covers what the tool does, acceptable input types, a usage caveat, and a limitation. It doesn't specify return values or behavior on error, but given the simplicity of the tool, it is sufficiently complete for an agent to use it correctly.

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

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

The schema covers 100% of parameters with descriptions. The tool description adds value by explicitly mapping enum values to meanings (e.g., 'bug = something broke or returned wrong data') and advising specificity in the message. This goes beyond the schema's basic descriptions, aiding the agent in proper 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 verb ('Send feedback') and the target ('Pipeworx team'), and lists specific use cases (bug reports, feature requests, missing data, praise). It is distinct from sibling tools, which are focused on data retrieval or user state.

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

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

The description explains when to use the tool (for various types of feedback) and provides specific guidelines: describe what was tried in terms of Pipeworx tools/data, do not include the end-user's prompt verbatim, and mentions a rate limit of 5 messages per day. It does not explicitly state when not to use it, but the context is clear enough.

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

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

Annotations already declare readOnlyHint and idempotentHint. Description adds that data is self-aggregating, derived from CF analytics, no PII, and cached 5min-1h. No contradiction; adds 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 well-structured: main action first, then use cases, then technical details. Every sentence adds value, though could be slightly more concise. Front-loaded with key information.

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

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

Given no output schema, description does not detail the return structure (e.g., format of 'top tools, top packs, total call volume'). For a read-only trending tool with one simple parameter, it is mostly complete but lacks output format 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 parameter 'window' with enum values and schema description. Description adds context: '24h (default) surfaces what's hot; longer windows show steady-state demand,' which enriches understanding beyond schema.

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

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

Description clearly states it returns top tools, top packs, and total call volume over a recent window. Distinguishes from sibling 'trending_papers' and explicitly mentions it's self-aggregating from CF analytics, providing a specific verb+resource.

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?

Description lists three concrete use cases (discovering hot data sources, confirming canonical tool, checking alignment). Implicitly gives when-to-use via examples, but does not explicitly state when not to use. Mentions caching and window trade-offs.

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

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

Annotations already mark the tool as read-only and non-destructive. The description adds behavioral detail: it walks child markets, extracts dates/thresholds, sorts them, and reports violations. It does not disclose potential limitations (e.g., only works for certain event types), which prevents a perfect score.

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

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

The description is front-loaded with the purpose and is fairly concise, though slightly lengthy. Every sentence contributes meaningful information, but minor trimming could improve succinctness.

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 domain-specific complexity, the description covers purpose, input, algorithm, and output structure (list of {market_a, market_b, gap_pp, suggested_trade}). It could briefly mention expected limitations or error handling, but it is substantially complete.

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

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

With 100% schema coverage, baseline is 3, but the description significantly expands on the single parameter 'event' by providing an example slug, explaining how it is used to walk child markets, and detailing the extraction and sorting process.

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 a verb and resource ('Find arbitrage opportunities within a Polymarket event by checking for monotonicity violations'), details the underlying principle, and distinguishes it from sibling tools (e.g., polymarket_edges, bet_research) by focusing on intra-event 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 explains exactly when to use the tool (when an event has multiple 'by [date]' or 'by [threshold]' markets), provides the method (checking price monotonicity), and gives input format (slug or URL). Though no explicit 'when not to use' is stated, the context is sufficient for an agent to 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?

Annotations already indicate readOnlyHint, openWorldHint, and destructiveHint. The description adds valuable details: it scans top markets, groups by asset, fetches price history once, computes model probability, ranks by edge, and returns top N with suggested direction. No contradictions with annotations.

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

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

The description is a single paragraph that efficiently conveys purpose, process, and domain. It is front-loaded with the key action. Slightly long but every sentence adds value; could be broken into shorter sentences for readability.

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

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

Given no output schema, the description explains the output (top N by edge magnitude with suggested trade direction). It covers model, workflow, and purpose thoroughly, enabling an agent to decide when to use this 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?

Input schema has 100% coverage with clear descriptions for limit, window, and min_edge_pp. The description does not add much beyond the schema for individual parameters, but it provides overall context (e.g., V1 covers crypto-price bets). 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 it scans high-volume Polymarket markets, computes edge from Pipeworx data vs market price, and returns ranked opportunities. It specifies the model (lognormal from FRED + coinpaprika) and distinguishes from siblings like polymarket_arbitrage, which focuses on arbitrage rather than edge detection.

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 'what should I bet on today' question, indicating when to use it. It explains that it automates discovery without manual paging. However, it does not explicitly mention alternatives or when not to use it, though the context is strong.

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

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

Annotations already declare readOnly, idempotent, and openWorld hints. The description adds valuable context about typical spread range (2-25pp) and details the return structure, aiding expectations.

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

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

The description is mostly concise and front-loads the core purpose, though a slightly more structured format (e.g., bullet points for modes) could improve readability without adding length.

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

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

Despite lacking an output schema, the description adequately explains the return format (prices and spread in clear units). It covers the two modes and override behavior sufficiently for most use cases.

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

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

Schema coverage is 100% but description enriches by explaining topic as pre-mapped shortcuts and how explicit parameters override the topic side, with concrete examples for each 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 computes cross-venue spread between Kalshi and Polymarket, distinguishing it from single-venue siblings like polymarket_arbitrage by emphasizing the arbitrage signal from price differences.

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?

Two modes (topic and explicit) are clearly explained with examples, providing good context for when to use each, though no explicit when-not or alternative tool comparisons are given.

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

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

No annotations provided, so description carries full burden. It states that the tool retrieves data (non-destructive) and can list all keys. However, it doesn't disclose behavior like whether the memory persists across sessions, or if there are limits on key length or memory size. This is adequate but not thorough.

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, concise and front-loaded with the main action. The second sentence adds useful context. No wasted words, though it could be slightly more compact.

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

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

Given no output schema, the description explains the two modes (retrieve by key, list all). It covers the main use cases. However, it could mention if keys are case-sensitive or what happens if key doesn't exist.

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 one parameter. Description adds value by explaining that omitting key lists all stored memories, which is a key usage pattern not obvious from 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?

Description clearly states the tool retrieves a memory by key or lists all memories when key is omitted, using specific verbs 'retrieve' and 'list' and the resource 'memory'. It distinguishes itself from sibling tools like 'remember' (which stores) and 'forget' (which deletes).

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?

Description explains when to use this tool ('retrieve context you saved earlier') and implicitly differentiates from 'remember' (store) and 'forget' (delete). However, it doesn't explicitly say when not to use it or mention alternatives beyond implicit context.

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

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

No annotations provided, so description carries burden. Describes parallel fan-out to multiple sources, acceptable date formats, and return structure (structured changes, count, URIs). Lacks details on rate limits or error handling, but sufficient for behavioral transparency.

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

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

Three informative sentences, front-loaded with purpose. Each sentence adds essential detail without redundancy.

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

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

For a complex tool with parallel sources, the description covers key behaviors and outputs. Missing details on pagination or rate limits, but overall complete for initial 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 coverage is 100%, and description adds significant value: explains 'since' formats with examples ('7d', '1y'), type constraint to 'company', and value as ticker or CIK. Enhances schema descriptions.

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

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

Clearly states 'What's new about an entity since a given point in time' and lists specific data sources (SEC EDGAR, GDELT, USPTO). Distinguishes from sibling tools like entity_profile by focusing on dynamic changes.

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

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

Explicitly recommends use for 'brief me on what happened with X' or change-monitoring workflows. Does not mention when not to use or alternatives, but the context is clear.

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

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

Annotations are absent, so the description carries the full burden. It discloses memory persistence details (authenticated vs anonymous) but does not mention any limits on key length, value size, or total number of entries, nor what happens on overwriting an existing key. This leaves gaps in behavioral understanding.

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

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

Three sentences, all essential: the first states the core function, the second lists typical use cases, the third clarifies persistence behavior. No fluff, information 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 the tool's simplicity (2 required string params, no output schema, no nested objects), the description is largely complete. However, it omits any mention of overwrite behavior or limits, which would improve completeness for an agent.

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

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

Schema description coverage is 100%, so the description adds limited value beyond schema. It reinforces the purpose of storing 'intermediate findings, user preferences, or context' but does not elaborate on parameter constraints or examples beyond the schema's own hints (e.g., example keys). 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 it stores a key-value pair in session memory. It specifies the resource ('session memory') and the action ('store'), distinguishing it from siblings like 'forget' and 'recall' which handle removal and retrieval respectively.

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: to save intermediate findings, user preferences, or context across tool calls. It also notes persistence differences based on authentication status, which helps the agent decide usage context.

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

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

Describes accepted inputs (ticker, CIK, name) and outputs (ticker, CIK, name, URIs). No annotations provided, so description carries full burden; lacks disclosure on permissions, rate limits, or error cases.

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

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

Two sentences, no wasted words. First sentence defines core purpose, second adds version details and examples. Front-loaded and efficient.

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

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

No output schema, but description enumerates return values. Covers versioning and input variants. Missing details on error handling or performance, but adequate for a simple 2-param read 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?

Input schema has 100% coverage with descriptions for both params. Description adds value by specifying enum versioning (v1 supports 'company') and providing concrete examples for value param.

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 'resolve an entity to canonical IDs' with specific verb and resource. Example for type=company provides concrete scope. Distinct from sibling tools like ask_pipeworx or search_papers.

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?

Mentions 'replaces 2–3 lookup calls', implying efficiency benefit. Does not explicitly state when not to use or alternative tools, but context is clear given unique purpose.

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

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

Annotations already indicate readOnly, openWorld, idempotent, not destructive. The description adds value by explaining the internal process: probing each entity with ai_visibility_check, ranking by score, and surfacing most/least recognized. It also mentions return fields (score, confidence, signal density), which annotations alone do not provide.

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

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

The description is four sentences, front-loaded with the primary purpose. Every sentence is informative: purpose, behavioral detail, usage context, and return value. No redundancy or filler.

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

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

Given no output schema and 4 parameters, the description covers purpose, internal behavior, usage scenario, and return format. It could mention constraints like minimum 2 entities or error handling, but overall it is complete enough for an agent to use 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 meaning beyond schema by explaining that the first entity in the array is treated as the 'subject' for narrative purposes, and clarifies the context parameter with examples ('B2B SaaS', 'Boston restaurant'). This extra context justifies a score of 4.

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

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

The description clearly states it compares AI visibility across multiple entities side-by-side, distinct from sibling tools like ai_visibility_check (single entity) and compare_entities (generic comparison). It specifies the verb 'compare' and resource 'AI visibility' with context of competitive audits.

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

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

The description provides clear context: 'Useful for competitive AI-marketing audits' and an illustrative example ('does Claude know about us as well as our competitors?'). It implies usage for multi-entity comparisons but does not explicitly mention when not to use it or contrast with alternatives like ai_visibility_check.

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?

No annotations are provided, so the description carries full burden. It does not disclose behavioral traits such as rate limits, data source freshness, whether results are paginated, or any side effects. The description is minimal and lacks important context for safe invocation.

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

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

The description is two sentences, concise and front-loaded with purpose and output. However, it could be more efficient by avoiding the output list if obvious, but it is not wasteful.

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 is simple (2 params, no output schema), the description covers the basic purpose and output. However, it lacks context on search behavior (e.g., exact vs fuzzy matching, sorting) and does not leverage the opportunity to compensate for missing annotations.

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

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

Schema description coverage is 100%: both 'query' and 'limit' have descriptions in the schema. The description adds no new semantics beyond listing output fields, 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 searches ML research papers by keyword and specifies the output fields (title, authors, abstract, conference, links). It distinguishes from siblings like 'get_paper' (likely retrieves a specific paper) and 'trending_papers' (trending rather than 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 implies use for keyword-based search but does not explicitly state when to use this vs alternatives like 'get_paper' or 'trending_papers'. No exclusions or prerequisites are mentioned.

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?

With no annotations, the description indicates it returns a list of papers with specific fields. However, it does not disclose any behavioral traits like rate limits, data freshness, or potential errors. The tool is read-only in nature, which is clear from the description, but additional behavioral context would help.

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 sentence of 13 words that conveys the essential purpose and return structure. No unnecessary words, and the key information is front-loaded.

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

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

Given the tool is simple (one optional parameter, no output schema, no annotations), the description is adequate but lacks details on sorting order beyond 'conference proceedings' and does not mention any defaults or limitations besides what's in the schema. Completeness is acceptable for a low-complexity tool.

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

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

The input schema has 100% coverage with one parameter 'limit' described in the schema. The description does not add any additional meaning beyond what the schema provides. According to the rules, baseline is 3 when schema coverage is high.

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

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

The description clearly states the verb 'Get' and the resource 'trending ML research papers', and specifies ordering by conference proceedings. It distinguishes itself from sibling tools like 'search_papers' by focusing on trending papers ordered by conference.

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 this tool is for retrieving trending papers, but does not explicitly state when to use it over alternatives like 'search_papers' or 'get_paper'. No exclusions or context about typical use cases are provided.

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

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

No annotations provided, so description carries full burden. It describes return values (verdict, extracted form, actual value with citation, percent delta) and mentions pipeline replacements, but lacks details on auth needs 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?

Two sentences, front-loaded with main function, then scope and output details. No wasted words.

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

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

Adequate for a single-parameter tool with no output schema; covers supported claim types, tools, and output format.

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 with 100% schema coverage, but description adds domain-specific constraints and examples, enhancing understanding beyond schema.

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

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

Description clearly states it fact-checks natural-language claims against authoritative sources, specifies domain (company-financial), and lists return values. Differentiates from siblings by being a specialized fact-checking tool.

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

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

Description provides clear context on when to use (for company-financial claims) and mentions it replaces multiple agent calls, but does not explicitly state when not to use or list alternatives.

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