Epa Emissions

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. Description adds context about free default model and BYO Anthropic key, which is consistent with annotations. No contradictions.

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

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

Single paragraph, front-loaded with action and key functionality. Every sentence adds value with no fluff. Well-structured with clear flow.

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

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

Despite no output schema, description explicitly mentions return structure: per-model {score, confidence, signals, raw_response} plus combined view. Covers all parameter meanings and use context. Sufficient for agent to understand tool behavior and output.

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

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

Schema has 100% coverage. Description adds value by explaining '_apiKey' is only needed for anthropic model and is passed straight through, and that 'context' helps disambiguate. Gives examples for 'entity'.

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 probes LLMs to score visibility of an entity (brand/product/topic), with a specific verb 'probe' and resource 'LLMs'. It distinguishes from siblings like 'entity_profile' and 'scan_competitor_ai_presence' by focusing on AI model probes and 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?

Provides clear use cases (AI-marketing audits, pre-launch brand checks, competitive monitoring) and explains default vs. BYO model. However, 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?

The description discloses that the tool dynamically selects the best data source and fills arguments, which is important behavioral information. No annotations are provided, so the description carries the full burden. It does not mention limitations, error handling, or scope constraints.

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

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

The description is concise, with three sentences and a list of examples. Every sentence adds value: the first defines the core function, the second explains the automation, the third gives usage guidance. No redundant words.

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

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

Given the tool's simplicity (one parameter, no output schema), the description adequately covers what it does and how to use it. It could mention that results are returned in text form, but not necessary. Sibling tools are specific, so this tool's general nature is clear.

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 required 'question' parameter. The description adds meaning by explaining that the question should be in plain English and that the tool will handle the rest, going beyond the schema's minimal description.

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 answers natural language questions by selecting the best data source and filling arguments. It gives concrete examples like 'What is the US trade deficit with China?', which differentiates it from sibling tools that are more specific (e.g., 'ghg_emissions_by_sector').

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 it: for any question in plain English without needing to browse tools. It implicitly contrasts with using specific tools directly, though it doesn't explicitly say when not to use it or list alternatives.

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

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

Annotations already show readOnlyHint=true and no destructiveness. The description adds rich behavioral details: resolution, classification, fan-out to relevant packs, and return of an evidence packet with market-vs-model comparison. 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 moderately long (7 sentences) but well-structured: purpose first, then inputs, process, then use cases. Every sentence adds value, but some redundancy with schema reduces conciseness.

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

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

Given the tool's complexity and lack of output schema, the description explains the process and mentions the return of an evidence packet and comparison, but lacks specifics on the output structure (e.g., what fields are in the packet). Could be more 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% with detailed descriptions for both parameters. The description reiterates the accepted formats for 'market' and the enum meanings for 'depth', adding no new meaning beyond the schema.

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

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

The description states the tool researches a Polymarket bet by pulling Pipeworx data in one call, specifying inputs (slug, URL, question text) and differentiating it from sibling tools by being a core demo product for bet-relevant context.

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

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

Explicit use cases are given: 'should I bet on X?', 'what does the data say about this market?', 'is there edge?'. Implicitly contrasts with using other tools directly by noting agents that use this convert better.

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 describes data sources and specific metrics returned for each type, but does not mention authorization needs, rate limits, or read-only nature, leaving some gaps.

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

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

The description is four sentences, front-loaded with core function, efficiently covers type-specific outputs, return format, and efficiency claim—no waste.

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

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

For a tool with two required parameters, no output schema, and no annotations, the description explains inputs and outputs adequately, though the exact structure of 'paired data' could be more specified.

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

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

Schema coverage is 100% (baseline 3). The description adds significant meaning by explaining what each type returns (financial metrics for company, regulatory metrics for drug) and the format of values (tickers/CIKs vs. drug names), going 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 'Compare 2–5 entities side by side in one call' with specific details for company and drug types, and mentions replacing 8–15 sequential agent calls, effectively distinguishing it from siblings.

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

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

The description does not explicitly state when to use or avoid this tool, nor does it mention alternatives among siblings. It implies usage for comparing multiple entities but lacks explicit guidance on 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 are provided, so the description carries the full burden. It explains the tool returns 'the most relevant tools with names and descriptions', but doesn't detail any other behavioral aspects like whether it's read-only, side effects, or authorization needs. 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?

The description is concise at two sentences with no wasted words. The first sentence immediately states the core purpose, and the second provides critical usage guidance. Every sentence earns its place.

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

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

Given the tool's simplicity (2 params, no output schema, no nested objects), the description is nearly complete. It covers purpose, usage guidance, and return content. Missing minor behavioral details like pagination or error behavior, but those are low impact for a search 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 description coverage is 100%, so baseline is 3. The description adds minimal extra meaning beyond the schema—it reiterates the query parameter's purpose and notes the default and max for limit. No additional usage hints or examples beyond what's in the schema.

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

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

The description clearly states the verb 'Search' and the resource 'Pipeworx tool catalog', and specifies the purpose: finding relevant tools among 500+ options. It distinguishes itself by telling the agent to call this FIRST, differentiating it from sibling tools that perform specific data queries.

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.' This provides clear guidance on when to use it and implies it's a discovery step before using other tools.

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

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

With no annotations, the description fully discloses behavioral traits: it bundles multiple underlying calls, returns citation URIs, and notes that bundling federal contracts is too slow. It does not mention authorization or rate limits, but the detailed list of included data sources provides adequate transparency.

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

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

The description is two sentences long, front-loaded with the purpose, and contains no redundant information. Every sentence adds value, making it highly efficient.

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

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

Given the simple parameters (enum for type, string for value) and no output schema, the description covers the essential aspects: purpose, data included, return format, and usage guidelines. Minor gaps include lack of output structure description and potential performance notes, but overall 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?

Schema coverage is 100%, and the description adds significant meaning beyond the schema: for 'type', it notes that only 'company' is supported and future types are coming; for 'value', it specifies ticker/CIK formats and advises using resolve_entity for names. This guidance helps the agent correctly populate parameters.

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

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

The description clearly states the tool retrieves a full profile of an entity across all relevant Pipeworx packs in one call, specifying the action (full profile), resource (entity), and scope. It details the included data for type 'company' and distinguishes itself from siblings like resolve_entity and usa_recipient_profile.

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

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

The description explicitly states when not to use the tool ('For federal contracts call usa_recipient_profile directly') and implies its primary use case (replacing 10-15 sequential calls). It provides clear context and an exclusion, though lacks an explicit 'when to use' statement.

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

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

No annotations provided, so description carries full burden. Does not state whether deletion is irreversible, what happens to related data, or any side effects. 'Delete' implies destructiveness but no further 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?

Extremely concise single sentence. No wasted words, but could benefit from additional context 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?

Tool is simple with one parameter and no output schema, so description need not be long. However, it lacks behavioral details (irreversibility, confirmation) and usage context relative to siblings.

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

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

Schema description coverage is 100%, so schema already documents the key parameter. Description adds no extra meaning beyond 'Memory key to delete', which is redundant with schema.

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

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

Description clearly states verb (Delete) and resource (stored memory by key). Distinguishes from 'recall' and 'remember' siblings by implying it is the removal action.

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 any prerequisites or conditions for deletion.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds value by explaining the internal process (fetch page, extract title/description/key links) and the output format, which goes beyond annotation coverage.

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

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

The description is 4 sentences, front-loaded with purpose, and every sentence adds value. 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?

Despite no output schema, the description fully explains the output (single text blob in standard llms.txt markdown format). It also covers use cases, making it complete for agent decision-making.

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 both url and max_links described. The description does not add new meaning to parameters beyond what the schema provides, so the 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 generates an llms.txt file for any URL, specifying the action, output format, and target audience (AI crawlers). It distinguishes from siblings by focusing on file generation rather than visibility checking or other tasks.

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

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

The description lists specific use cases (client indexing, own project drafting, competitor auditing) but does not explicitly mention when not to use or compare to alternatives like ai_visibility_check. However, the context is clear enough 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 are empty, so the description carries full burden. It discloses that it returns GHG emissions by sector and supports optional filtering. However, it does not mention whether the data is historical, current, or has any refresh cadence. It also doesn't specify if the tool is read-only or if any side effects 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 a single sentence that efficiently conveys the core purpose and optional filtering. No extraneous words. It is front-loaded with the key action and resource.

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

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

Given the tool has no output schema and no annotations, the description could be more complete. It does not describe the format of the returned data (e.g., total emissions per sector, units like CO2 equivalents). It also doesn't mention pagination behavior or what happens when no results are found. However, for a straightforward data retrieval tool with three simple parameters, the description is minimally adequate.

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 all three parameters have descriptions. The description adds context by stating the tool can filter by sector type and provides example values like 'Power Plants' and 'Chemicals', which go beyond the schema's description. The 'limit' parameter's default and max are also mentioned.

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

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

The description clearly states it retrieves greenhouse gas emissions by industry sector for a state. The verb 'Get' combined with 'greenhouse gas emissions by industry sector' specifies the resource and action. It also distinguishes from sibling tools like ghg_facility_emissions (which focuses on facilities) and tri_chemical_releases (which is a different program).

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 when needing sector-level GHG data for a state, with optional filtering by sector type. However, it does not explicitly state when to use this tool versus alternatives like ghg_facility_emissions or tri_chemical_releases. 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 carries the full burden. It discloses the search behavior (state required, facility name optional partial match), and the output is specified as facility details and emissions. No contradictory statements. It could mention rate limits or data freshness but is adequate.

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

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

Two sentences, front-loaded with purpose and scope, no wasted words. Efficiently conveys the tool's function and output.

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 3 parameters, the description adequately covers what the tool does and returns. It mentions returns 'facility details and total GHG emissions', which is sufficient for an agent to understand the output structure. Could be improved by noting pagination or sorting, 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 adds meaning by explaining the facility_name is a partial match using CONTAINING, which is not in the schema description. It also clarifies that emissions are in 'metric tons CO2 equivalent', adding 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 it searches GHG emissions by state and optionally facility name, returning facility details and total emissions in metric tons CO2 equivalent. This is specific and distinct from sibling tools like 'ghg_emissions_by_sector' which focuses on sector breakdowns.

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 state-based GHG facility searches with optional facility name filtering. While it doesn't explicitly state when not to use it or provide alternatives, the context from sibling tools helps distinguish it. No explicit exclusions or when-not 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?

No annotations provided, so description carries the full burden. It discloses rate limiting and that it is free. However, it does not describe what happens after sending (e.g., async, no confirmation). Still, for a feedback tool, this is adequate.

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, efficiently front-loaded with purpose. Each sentence adds meaningful information without redundancy. Very concise.

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

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

Given the tool's simplicity (3 params, one nested) and lack of output schema, the description covers necessary behavioral context (rate limiting, usage instructions). Could mention that feedback is sent asynchronously, but not critical.

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

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

Schema has 100% description coverage. Description adds value by elaborating on enum values (bug, feature, data_gap, praise, other) and providing guidelines for the 'message' field (be specific, 1-2 sentences, 2000 chars max). 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?

The description clearly states the tool's purpose: 'Send feedback to the Pipeworx team' and lists specific use cases (bug reports, feature requests, missing data, praise). It distinguishes itself from sibling tools by being the explicit feedback channel.

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

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

Provides clear when-to-use guidance (feedback of various types) and explicit instructions on what not to include (end-user prompt verbatim). Mentions rate limit (5 per day). Could further clarify when not to use (e.g., for questions), but the context is sufficient.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context: data is derived from CF analytics-engine, no PII, self-aggregating signal, and cached 5min-1h. This supplements annotations well without contradiction.

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

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

The description is three sentences long, efficiently structured: first sentence states the output, then use cases, then technical details. 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 the tool has only one optional parameter and no output schema, the description fully covers purpose, usage guidelines, and behavioral aspects. An agent can confidently decide to use this tool based on the provided 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?

The input schema already has a description for the 'window' parameter with enum values. The description adds further meaning by explaining 'Shorter windows surface what's hot right now; longer windows show steady-state demand,' which goes beyond the schema's documentation.

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 'top tools, top packs, and total call volume' over a window, which is a specific verb and resource. It distinguishes itself from siblings by focusing on trending data, not other functionalities like entity profiles or emissions data.

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

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

The description lists three explicit use cases (discovering hot data sources, confirming canonical choice, seeing alignment) and notes caching and data source. It provides clear context for when to use but does not explicitly state when not to use, though the use cases are sufficient for an agent to infer.

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 tool has annotations indicating it is read-only and non-destructive. The description adds value by explaining the internal logic (monotonicity checks) and output format (ranked opportunities with reasoning). It does not contradict annotations. While it provides good context, it could mention potential rate limits or data freshness, keeping it from a 5.

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 (under 120 words) and well-structured. It front-loads the purpose, then explains the two modes with clear bullet-like formatting. Every sentence adds essential information, with no redundancy or 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 complexity (two modes, cross-event searching) and the lack of an output schema, the description provides a high-level overview but omits details about the exact structure of the returned opportunities (e.g., fields, ranking criteria). It is adequate but not fully comprehensive for an agent to anticipate the output format without additional context.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds some context about the parameters (e.g., 'Cross-event mode catches the cases where Polymarket lists each cutoff as its own event'), but the schema descriptions already cover the two modes. The added value is moderate, but not enough to raise the score to 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: 'Find arbitrage opportunities on Polymarket by checking for monotonicity violations across related markets.' It distinguishes two modes (event and topic), providing specificity. However, it does not explicitly differentiate from sibling tools like 'polymarket_edges', which may have overlapping functionality, so it falls short of a 5.

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

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

The description provides clear guidance on when to use each mode: 'event' for a single event, 'topic' for cross-event searches. It explains the rationale for cross-event mode with concrete examples. However, it does not discuss when not to use the tool or mention alternative tools, so it does not achieve 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?

The description adds significant behavioral detail beyond annotations: it explains the V1 scope (crypto-price bets), data sources (FRED + coinpaprika), grouping by asset, one-time fetch, model computation, and ranking by edge magnitude. Annotations already indicate read-only and open-world 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 well-structured with multiple sentences, each adding value: purpose, model details, method, output. It is not overly verbose but could be slightly more concise. However, it earns its sentences.

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 (ranking model, grouping, external data) and absence of output schema, the description adequately explains what the tool does and what is returned (top N with trade direction). It includes model and data source 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?

Input schema covers all parameters with descriptions (100% coverage). The description reinforces the meaning of edge magnitude but does not significantly extend schema info. Baseline 3 is appropriate since schema does the heavy lifting.

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

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

The description clearly states the tool scans high-volume Polymarket markets and returns those with most disagreement between Pipeworx data and market price, using a specific model. It distinguishes from siblings like bet_research and compare_entities by focusing on edge-based opportunity 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 explicitly frames the tool for the 'what should I bet on today' question, implying discovery and opportunity scanning. It does not provide explicit when-not scenarios or direct comparisons to siblings, but the context is clear enough for an agent to infer appropriate 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?

The annotations already indicate read-only, idempotent, non-destructive behavior. The description adds valuable behavioral context: it explains that prices can differ 2-25pp, describes the output structure (leg-by-leg prices and spread), and details the two modes. This goes beyond what annotations provide, earning a high 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 well-structured, starting with the core purpose, then explaining the spread concept, then detailing the two modes, and finally describing returns. It is informative without being overly verbose. Minor redundancy could be trimmed, but overall it is effectively concise.

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

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

Given the tool's complexity (3 parameters, no output schema, annotations present), the description does a good job. It explains the output structure (leg-by-leg prices and spread) and provides examples. However, lacking a precise output schema, the description could specify the exact fields and format of the return. Still, the description is fairly complete.

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

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

The input schema has 100% coverage with descriptions for all three parameters. The description adds meaning beyond the schema by explaining the topic list, the override behavior, and providing format examples. This extra context justifies a score above the baseline of 3.

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

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

The description clearly defines the tool's purpose: calculating cross-venue spread between Kalshi and Polymarket for the same resolving question. It specifies the two modes (topic shortcuts and explicit identifiers) and what the output includes. This is a specific verb+resource description that distinguishes the tool from siblings 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 provides clear usage guidance by explaining the two modes: using pre-mapped topics for common events or custom pairings with explicit tickers. It describes when to use each mode. However, it does not explicitly state when to avoid this tool in favor of alternatives, like polymarket_arbitrage, which would earn a higher score.

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, but description explains key behavior: omit key to list all, provide key to retrieve specific memory. Clear about read-only operation.

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

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

Two sentences, front-loaded with action and alternatives. No wasted words.

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

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

Given no output schema, description could mention return format (e.g., value string or list of keys). However, behavior is straightforward and sibling tools cover related operations.

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 described as 'Memory key to retrieve (omit to list all keys)'. Description adds clarity on omit behavior, but schema already covers meaning.

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

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

Clearly states the tool retrieves a memory by key or lists all memories when key is omitted. Distinguishes from 'remember' (store) and 'forget' (delete) 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?

Explicitly states to use for retrieving context saved earlier. Could be improved by noting when not to use (e.g., prefer 'ask_pipeworx' for general queries).

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 discloses the parallel fan-out to multiple sources, the return structure (structured changes, total_changes count, URIs), and the accepted formats for 'since'. It does not mention potential side effects or performance characteristics, but overall transparency is 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?

The description is concise, with no wasted words. It front-loads the purpose and follows with operational details and usage examples. Every sentence provides necessary information.

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

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

Given no output schema, the description effectively communicates what the tool returns (structured changes, count, URIs). It covers all three parameters, explains the fan-out behavior, and offers typical usage suggestions for the 'since' parameter. For a tool with multiple data sources and return structure, the description is complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by providing examples for 'since' (e.g., '7d', '30d', '3m', '1y') and clarifying 'value' accepts ticker or CIK. It also reiterates that 'type' only supports 'company'. This additional context justifies a slight above-baseline score.

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: presenting new information about an entity since a given time. It specifies the supported type (company), the data sources (SEC, GDELT, USPTO), and the return format. The explicit use case ('brief me on what happened with X' or change-monitoring) distinguishes it from sibling tools like entity_profile.

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

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

The description provides explicit when-to-use guidance: 'Use for 'brief me on what happened with X' or change-monitoring workflows.' It implies when not to use (e.g., for a full profile, use entity_profile) but does not directly name alternatives. It also clarifies the supported entity type (company) and gives examples for the 'since' parameter.

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 description must fully cover behavioral traits. It explains persistence differences ('Authenticated users get persistent memory; anonymous sessions last 24 hours'), which is valuable. However, it does not mention any limits (e.g., max memory size, number of keys) or potential side effects.

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

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

Description is concise with three sentences, each adding value: purpose, usage scenarios, and persistence detail. It is front-loaded with the core action. Could be slightly more compact, but no waste.

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 parameters, no output schema), the description adequately covers purpose, usage, and persistence behavior. The lack of output schema is acceptable since return values are implicit. Minor gap: no mention of overwriting behavior or maximum key length.

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 clear descriptions for both parameters ('key' and 'value'). The description adds context by listing example keys ('subject_property', 'target_ticker') and explaining value can be 'any text', but does not add significant new meaning beyond the schema.

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

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

Description states the tool stores a key-value pair in session memory, specifying the exact resource ('session memory') and action ('store'). It clearly distinguishes from sibling tools like 'recall' and 'forget' which handle retrieval and deletion.

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 explicit use cases ('save intermediate findings, user preferences, or context across tool calls') and notes differences between authenticated and anonymous sessions. However, it does not explicitly state when not to use it or mention alternatives beyond the sibling 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?

Without annotations, the description carries the full burden. It discloses the input types and output fields but lacks details on error handling, authentication needs, rate limits, or behavior for non-existent entities. The basic behavior is clear but minimal.

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, consisting of two brief sentences. It front-loads the main purpose and efficiently packs key details (supported version, input formats, output, and value proposition) 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 no output schema, the description provides a decent overview of inputs and outputs. It could be more complete by describing error cases or performance implications, but for a simple lookup tool, it 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?

The schema covers both parameters with descriptions, achieving 100% coverage. The description adds value by explaining that 'value' can be a ticker, CIK, or name, with specific examples, and that 'type' is limited to 'company' in v1. This 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?

The description clearly states the tool resolves entities to canonical IDs across Pipeworx data sources, with specific input examples (ticker, CIK, name) and output fields (ticker, CIK, name, URIs). It distinguishes itself from potential sibling tools by highlighting its single-call efficiency.

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 this tool (instead of 2-3 lookup calls) and provides clear context. While it does not explicitly state when not to use it, the uniqueness among siblings and the clear purpose make the usage straightforward.

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

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

The description goes well beyond the provided annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint) by detailing that it probes each entity with ai_visibility_check, returns a ranked list with score, confidence, and signal density, and explains the side-by-side comparison behavior. 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 (three sentences plus an example), well-structured, and front-loaded with the core purpose. Every sentence adds unique value without redundancy or fluff.

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

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

Despite no output schema, the description fully explains the return format (ranked list with score, confidence, signal density). All four parameters are meaningfully explained, and the tool's behavior (probing with ai_visibility_check, narrative for first entity) is complete enough for an agent to use correctly.

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

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

With 100% schema description coverage, baseline is 3. The description adds value by explaining the purpose of each parameter: 'models' can be omitted for default, 'context' disambiguates common names, and 'entities' first entry is the subject. This provides context beyond the schema descriptions.

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

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

The description clearly states the tool compares AI visibility across multiple entities side-by-side, using ai_visibility_check, ranks them, and identifies most/least recognized. It gives a concrete example query, making the purpose unmistakable and distinguishing it from siblings like ai_visibility_check which does single entity checks.

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 provides a use case ('competitive AI-marketing audits') and explains that the first entity is treated as the subject. However, it lacks explicit guidance on when NOT to use this tool or mention of alternative tools for similar tasks, which would make the guidance stronger.

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 idempotent and read-only. The description adds critical behavioral insights: bundlephobia's slow first measurement (5-30s) and graceful degradation with partial failures listed in sources_failed. 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 a single dense paragraph but efficiently packs essential information with front-loaded purpose. It could be improved with bullet points but remains clear and concise for an AI agent.

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 thoroughly explains the return structure (summary block, advisories, links, alternatives). It also covers failure modes and ecosystem scope, making it fully functional for an agent.

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

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

Schema coverage is 100% with clear descriptions for both parameters. The description reiterates that version defaults to latest but adds no significant new semantics beyond the schema, meeting the baseline for high coverage.

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

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

The description clearly states the tool's purpose: a composite check for evaluating adding an npm package to a project, covering license, advisories, bundle size, etc. It is specific and distinguishes from siblings by its unique function.

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

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

The description explicitly advises use when an agent asks about package safety, popularity, or size. It also notes ecosystem limitations (npm-only in v1) and mentions alternative access for other ecosystems, providing clear context for when 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?

No annotations provided, so description must carry burden. It correctly indicates filtering and returns quantities by media, which is helpful. However, it does not disclose pagination behavior (limit parameter exists but not mentioned), ordering, or any other behavioral traits beyond basic filtering. No contradiction with annotations as annotations are empty.

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: first states purpose and filtering, second states output. No redundancy. Front-loaded with main action. Every sentence adds value.

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

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

Given tool has 3 parameters (simple), no output schema, and no annotations, the description covers purpose, filtering, and output format. Lacks mention of default limit or pagination behavior, but overall sufficient for this level of complexity.

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

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

Schema coverage is 100%, so baseline is 3. Description adds context for 'chemical' parameter with examples but does not add meaning beyond schema for 'state' or 'limit'. Acceptable given full 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?

Description clearly states the tool searches toxic chemical releases across facilities, with filters by chemical and optionally state, and returns media-specific quantities. This distinguishes it from siblings like tri_facility_releases (facility-focused) and tri_trends (trend-focused).

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 this tool (when searching chemical releases by chemical and optionally state) and what it returns. It does not explicitly mention when not to use it or alternatives among siblings, but the sibling names (e.g., tri_facility_releases, tri_trends) provide implicit differentiation.

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 empty, so description carries full burden. It states that it returns 'facility details and released chemicals', which is helpful but vague. Does not disclose whether results are paginated, how partial matching works, or any rate limits. No contradictions found.

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 one sentence, concise and front-loaded with action. Every word serves a purpose. Could be slightly more structured with explicit sections, but efficient.

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

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

Given no output schema and no annotations, description provides basic understanding but lacks details on pagination, sorting, or error conditions. Schema covers 100% of parameters, so parameters are well-documented. Complete enough for a simple search tool, but could be more robust.

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

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

Schema description coverage is 100%, so baseline is 3. Description adds minimal context by saying 'partial match' for facility_name, which is already in schema. However, it does not elaborate on the format of returned data beyond 'facility details and released chemicals'. Slight improvement over schema.

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

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

Description clearly states verb 'search', resource 'TRI facilities', and scope 'by state'. It distinguishes itself from sibling tools like 'tri_chemical_releases' and 'ghg_facility_emissions' by specifying the TRI program and facility focus. However, it does not explicitly differentiate from 'tri_facility_releases' itself, but the sibling set includes distinct tools.

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

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

The description implies usage for finding facilities in a state, and the schema shows state is required. No explicit guidance on when to use this tool vs. alternatives like 'tri_chemical_releases' or 'tri_trends'. No exclusion criteria or when-not-to-use information 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?

With no annotations provided, description carries full burden. It discloses that the tool queries multiple years and summarizes totals, but does not specify what 'summarizes totals' means (e.g., return format, aggregation method). No contradictions with annotations since none 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?

Two sentences, no filler. First sentence states purpose and scope, second sentence adds key behavioral detail. Every sentence earns its place.

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

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

Given no output schema, description explains that it summarizes totals over years, which is adequate for a trend tool. However, it could mention that it returns a time series or aggregate values. Slightly incomplete but sufficient for the complexity.

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

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

Schema coverage is 100% and descriptions are already clear. The description adds no additional meaning beyond the schema, which is acceptable given high coverage. Baseline of 3 is appropriate.

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

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

Description clearly states verb (Get) and resource (toxic release trends), specifies scope (state or chemical, across reporting years), and distinguishes from sibling tools like tri_chemical_releases and tri_facility_releases which are about specific releases rather than trends.

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 implies use when the user wants trends over time for a state or chemical, but does not explicitly state when not to use it or mention alternative tools for specific queries. Sibling tools are available for specific releases, which is clear from their names, but not directly referenced.

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 returned verdicts, structured form, actual value with citation, and percent delta. However, it does not mention side effects, permissions, or error conditions, leaving some transparency gaps.

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

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

The description is three sentences, each adding value: purpose, scope, and output summary. It is front-loaded with the main action and includes examples and replacement note. No wasted words.

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

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

Given the single parameter and no output schema, the description adequately explains the tool's function, supported claim types, and outputs. Minor omissions like explicit limitations or error handling, but overall sufficient.

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

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

The single parameter 'claim' is fully described in the schema with example. The description provides context about what types of claims are supported but adds no new semantic details beyond the schema, achieving baseline with 100% schema coverage.

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 fact-checks natural-language claims against authoritative sources for company-financial claims, listing data sources and verdict types. It implicitly differentiates from siblings by noting it replaces multiple sequential calls, but does not explicitly name alternatives.

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 specifies the tool supports company-financial claims for public US companies via SEC EDGAR + XBRL, and mentions it replaces 4-6 sequential agent calls. This provides clear context for when to use it, but lacks explicit when-not-to-use guidance or direct sibling comparisons.

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