Carbon Intensity Uk

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

The description adds significant value beyond annotations: it explains the default model (Workers AI Llama-3.3-70b, free), the need for an API key to probe Anthropic, and the return structure (per-model fields plus combined view). Annotations already confirm readOnly, idempotent, and non-destructive behavior, so the description enriches the safety profile with operational details.

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

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

The description is a single, well-structured paragraph with three sentences. It is front-loaded with the main purpose, then covers optional behavior, return format, and use cases. No word is wasted; 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 no output schema, the description adequately explains the return value (per-model score, confidence, signals, raw_response + combined view). It also covers parameter behavior, default model, and Anthropic integration. For a tool with moderate complexity, this 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?

All four parameters have schema descriptions (100% coverage), and the description adds meaningful context: it explains the default model behavior for the 'models' parameter, the direct key passthrough for '_apiKey', and the disambiguation purpose of 'context'. This goes beyond what the schema alone provides.

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

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

The description clearly states the tool 'probes one or more LLMs' about a business/brand/product/topic and returns a visibility score. It includes the specific verb 'probe', the resource (LLMs), and the output format, distinguishing it from sibling tools like ask_pipeworx or entity_profile by focusing on AI 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 provides explicit use cases ('AI-marketing audits, pre-launch brand checks, competitive monitoring') and context about cost (free vs. BYO key for Anthropic). However, it does not explicitly state when not to use this tool or suggest alternative tools, leaving some room for improvement.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive. The description adds valuable behavioral context: it routes questions, fills arguments, returns structured answers with citation URIs, and notes it's a fast single call. These details go beyond annotations without contradicting them, enhancing the agent's understanding of expected 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 long but well-structured and front-loaded with 'PREFER OVER WEB SEARCH'. Each sentence earns its place: it covers purpose, usage, alternatives, examples, and tier compatibility. Some examples could be trimmed, but they serve to illustrate the range of acceptable questions. Overall, it is appropriately sized for a default entry point tool.

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

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

For a general-purpose router tool with no output schema, the description is exceptionally complete. It explains the return format (structured answer with citation URIs), the scope (5,462 tools), the default status, alternatives, and gives a wealth of example queries. This provides the agent with enough context to know when and how to invoke the tool.

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

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

Input schema has 100% coverage with a clear description of the 'question' parameter and its aliases. The description adds example queries and notes that the tool fills arguments and returns structured answers, but does not delve into parameter-level specifics beyond what the schema already provides. Baseline of 3 is appropriate since schema carries the semantic load.

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 (routes questions to the right tool), the resource (5,462 tools across 1419 verified sources), and the output (structured answer with citation URIs). It also distinguishes itself from siblings by naming ask_pipeworx_grounded and deep_research as alternatives for different use cases.

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

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

Explicitly says 'PREFER OVER WEB SEARCH' and provides detailed when-to-use guidance for factual questions, including example queries. It also gives clear when-not-to-use guidance by naming alternatives: ask_pipeworx_grounded for hallucination-resistant single answers and deep_research for broad multi-part questions. This is an explicit set of usage rules with alternatives.

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

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

Beyond the readOnlyHint, openWorldHint, and idempotentHint annotations, the description discloses its experimental nature, the possibility of live candidate routing improvements, the retirement of the last candidate (2026-07-26), and that it currently matches ask_pipeworx exactly. It also clarifies 'falls back to nothing' to prevent misunderstanding that it's a fallback. This is rich contextual information not captured by annotations.

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

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

The description is concise and front-loaded, with four sentences that clearly convey purpose, status, usage, and a critical caveat. While it repeats 'ask_pipeworx' several times, each occurrence serves to anchor the tool's relationship to its stable counterpart. Slightly more trimming could be done, but it remains 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?

For a complex beta router, the description covers essential context: what it routes, current behavioral state, usage guidance, and experimental purpose. It mentions the same response shape, which substitutes for an output schema. The caveat about candidate testing and 'falls back to nothing' closes potential misunderstandings. This is complete for an agent to decide when and how to invoke it.

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

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

Schema coverage is 100%, so the schema already documents the question parameter and its aliases. The description only mentions 'same arguments' without adding detail, so it does not significantly enhance parameter understanding 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 it is a beta version of ask_pipeworx, a universal router with the same 5,462 tools, arguments, and response shape. It distinguishes itself from siblings by positioning as the experimental edge and names ask_pipeworx as the stable counterpart. The verb 'ask' and resource 'pipeworx' are explicit, and the scope is defined with concrete details.

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

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

Explicitly says 'Use it exactly like ask_pipeworx when you want the newest routing' and states results are compared against the stable router to decide what merges. This provides clear when-to-use guidance and implies the alternative (use stable ask_pipeworx for non-experimental routing). It also notes current parity, reducing risk for agents.

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

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

Despite strong annotations (readOnly, idempotent, openWorld), the description adds valuable behavioral context: it discloses the extra LLM call cost, the routing mechanism (picks from 5,462 tools), and the explicit refusal structure when data doesn't answer. This goes well beyond the annotations, covering success and failure 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 dense yet efficient; every sentence serves a distinct purpose: purpose, mechanism, return format, refusal behavior, usage guidance, and cost comparison. It is front-loaded with the core value proposition and contains no filler.

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

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

Given the tool's complexity and lack of an output schema, the description fully compensates by detailing the success response structure and all possible refusal reasons. It also covers prerequisites (high-stakes context), tradeoffs versus the sibling, and behavioral guarantees, making it complete for an agent to invoke correctly.

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

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

Schema coverage is 100% with all six parameters as aliases for the question, and the schema already provides a description. The description adds meaning by explaining that the question is used for routing and argument filling, which goes beyond simple 'natural language question' semantics. It doesn't add new syntax or constraints, so a 4 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 is a hallucination-resistant answer mode that extracts answers using only the tool result content. It specifies the return format, refusal reasons, and explicitly compares to ask_pipeworx, distinguishing the grounded behavior. This gives a precise verb+resource+scope with sibling differentiation.

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

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

The description explicitly says when to use: 'Use whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts' followed by concrete examples. It also notes the cost tradeoff and directs 'prefer ask_pipeworx for casual lookups', making the alternative and exclusion criteria clear.

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

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

The description extensively discloses behavioral traits beyond annotations: resolver contract, fan-out examples, response shapes, safety short-circuits, tradeability notes, resolution-rule risk. No contradiction with annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint).

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 very long but well-structured with sections like CLASSIFIERS, FAN-OUT EXAMPLES, RESPONSE SHAPES. Each sentence adds value, but length may hinder quick parsing. Could be slightly more concise while maintaining completeness.

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

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

Given no output schema, description covers input, output fields, edge cases, safety, resolution rules, and examples exhaustively. Very complete for a complex research 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%, baseline 3. Description adds meaning by clarifying market accepts slug, URL, or question text; depth enum explained; include_raw recommendation given. Adds value beyond 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 it researches a Polymarket bet by pulling Pipeworx data, with specific verb 'Research' and resource 'bet'. It distinguishes from sibling tools like ask_pipeworx by focusing on a single bet and providing an evidence packet, and lists explicit use cases.

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 when to use: 'should I bet on X', 'what does the data say about Y', 'is there edge in Z'. It also explains resolver contract inspection and mentions blocking routes like low_confidence_match and market_closed_or_inactive, providing comprehensive guidance on when to trust results.

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

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

Annotations declare read-only, open-world, idempotent, non-destructive. The description adds details about data sources (SEC EDGAR/XBRL, FAERS), handling of off-calendar fiscal years, and citation URIs, enriching understanding beyond annotations.

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

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

The description is concise at 5-6 sentences, front-loaded with common trigger phrases, and each sentence adds meaningful information. Slightly long 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, the description explains returned data types, sorting by primary metric, and citation URIs. It adequately covers what the agent needs to understand the tool's 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 coverage is 100% with both parameters described. The description adds meaning by explaining what each type returns (financials vs. adverse events) and how to specify values (tickers 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 explicitly states it performs side-by-side comparison of 2–5 companies or drugs, and provides numerous trigger phrases. It clearly distinguishes from sibling tools like entity_profile by stating it replaces sequential lookups.

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

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

The description includes explicit guidance to prefer this tool over sequential single-pack lookups when comparing entities. It does not list exclusions but the directive is strong and clear.

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

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

Beyond the annotations (read-only, idempotent, not destructive), the description discloses extensive behavioral traits: requires sign-in, paid plan for 'thorough', returns meaningful gaps[] instead of inventing answers, citations are always fetchable, semantic excerpting, contradictions scan, and timing expectations. 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?

Though long, every sentence conveys unique, decision-relevant information. Critical info (account requirement, key differences from siblings) is front-loaded. The length is justified by the tool's complexity, and there is no redundancy.

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

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

With no output schema, the description fully explains the return packet: verbatim evidence, confidence, source, fetched_at, pipeworx:// citation, gaps[], contradictions[], hop field. It also covers the three depth levels, timing, and potential failure modes, making the tool's behavior fully predictable.

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

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

Schema coverage is 100% for both parameters (question and depth), yet the description adds substantial meaning: explains how 'depth' values affect hops and gap recovery, and that the question is decomposed into facets. This elevates the description beyond simple schema reuse.

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

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

The description states a specific verb+resource: 'Grounded multi-source research across Pipeworx's 1419 STRUCTURED data sources' with a clear output ('findings packet'). It explicitly distinguishes itself from siblings by noting 'this is NOT open-web search' and contrasting with ask_pipeworx, making its unique role unmistakable.

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

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

Provides explicit when-to-use guidance: 'Best for broad/multi-part questions over structured data'. Gives clear exclusions and alternatives: 'For a single lookup use ask_pipeworx', 'For BREAKING or colloquial CURRENT-NEWS... prefer ask_pipeworx'. Also notes account prerequisites and tier differences for depth options.

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 and idempotentHint=true. Description adds context: returns top-N relevant tools with full schemas, ready to call directly. No contradictions.

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

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

Description is detailed but efficient, with front-loaded purpose and use case. Every sentence adds value. Could be slightly more concise but still good.

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

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

Given 6 parameters (1 required), no output schema, description explains return value well (top-N tools with schemas, ready to call). Could mention default limit or pagination, 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 coverage is 100%, so baseline 3. Description doesn't add meaning beyond listing aliases, which schema already documents. The examples in schema are helpful but not in 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 it finds tools by describing data or task, listing many domains. It distinguishes itself from sibling tools as the discovery 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?

Explicitly says 'Call this FIRST when you have many tools available and want to see the option set (not just one answer),' providing clear when-to-use and implying when not to.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false. The description adds substantial behavioral context: it fans out across multiple sources, returns specific fields (cik, filings, fundamentals, etc.), notes that patent data soft-fails, and explains that only ticker/CIK are supported. 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 examples and is well-organized, but it is somewhat verbose, spanning many lines. Every sentence adds value, so it earns a 4 rather than 5 for 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?

Despite no output schema, the description fully explains the return structure (cik, company_name, recent_filings with URIs, fundamentals sorted, patents, news, LEI) and limitations (patent sunset, name unsupported). It leaves no critical gaps for an agent invoking 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?

Schema coverage is 100% (both parameters described), but the description adds valuable context: examples of valid values ('AAPL' or '0000320193'), clarification that names are not supported, and that CIK must be zero-padded. This exceeds baseline expectations.

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

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

The description starts with concrete user queries and explicitly states 'full cross-source profile of a US public company in ONE parallel call,' clearly distinguishing it from sibling tools like resolve_entity and compare_entities. The verb 'profile' and resource 'entity' are specific, and the scope is well-defined.

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 advises 'ALWAYS PREFER over chaining single-pack queries when the user asks for a holistic view,' and explicitly states that names are not supported—directing to use resolve_entity first. This provides clear when-to-use and when-not-to-use guidance.

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

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

Annotations already declare destructiveHint=true, and the description confirms the delete action. No additional behavioral traits beyond what annotations provide are disclosed, but consistency is maintained.

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

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

The description is concise with two sentences, delivering all necessary information without redundancy.

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

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

Given the simple interface (one parameter, no output schema) and adequate annotations, the description fully covers the tool's usage and context, leaving no gaps.

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

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

The input schema covers 100% of the parameter (key) with its description. The tool description adds no further semantic information beyond what is already in the schema, so baseline score of 3 applies.

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

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

The description clearly states the tool deletes a previously stored memory by key. It distinguishes from sibling tools like remember and recall, making the 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 advises when to use the tool: when context is stale, the task is done, or to clear sensitive data. It also suggests pairing with remember and recall, providing clear guidance.

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

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

Annotations (readOnlyHint, idempotentHint, etc.) already indicate safe, non-destructive behavior. The description adds valuable behavioral details: fetches the page, extracts title/description/key links, and emits standard llms.txt markdown as a text blob. 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 paragraph of four sentences, front-loaded with the main purpose. It is concise and avoids unnecessary details, though it could be slightly more structured. Still effective.

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

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

For a simple tool with 2 parameters and no output schema, the description covers output format ('single text blob', 'standard llms.txt markdown'), use cases, and expected behavior. It lacks error handling discussion but is adequate 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?

Input schema covers both parameters with descriptions (100% coverage). The description does not add extra meaning beyond the schema; it mentions the output format but does not elaborate on parameter behavior. Baseline of 3 is appropriate.

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

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

The description clearly states the tool generates a production-ready llms.txt file for any URL, specifying the verb 'generate', the resource 'llms.txt file', and the context for AI crawlers. It distinguishes from sibling tools like ai_visibility_check by focusing on file generation.

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 explicit use cases (getting a client's site indexed, drafting your own, auditing competitors), providing clear context. However, it does not explicitly state when not to use this tool or mention alternative siblings, so it misses full guidance.

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

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

Annotations already indicate readOnlyHint, idempotentHint, and destructiveHint. The description adds value by specifying the exact return fields (id, type, params, etc.) and implies that only active subscriptions are listed unless include_inactive is true. 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 two sentences, front-loading the main action and return fields, then providing usage guidance. No unnecessary words; 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?

For a simple list tool with one optional boolean parameter and no output schema, the description covers purpose, return fields, and usage context completely. It tells the agent what the tool returns and when to use it.

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

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

Schema coverage is 100% (the single parameter include_inactive is fully described in the schema). The description does not add significant meaning beyond the schema; it only implies that active subscriptions are listed by default. 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 'List the caller's active subscriptions,' specifying the verb and resource. It lists returned fields and, given siblings include subscribe and unsubscribe, it effectively distinguishes itself as the listing 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 provides explicit usage context: 'Use this to review what you're monitoring before adding more or to find an id to cancel.' This is clear on when to use, though it does not explicitly state when not to use or mention 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?

Discloses rate limiting ('5 per identifier per day'), no quota impact ('Free; doesn't count against your tool-call quota'), and downstream impact ('team reads digests daily and signal directly affects roadmap'). Also clarifies the boundary of what feedback is actionable (only for this Pipeworx connection). This goes well beyond the minimal 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 purpose and then efficiently covers usage, exclusions, content rules, and rate limits in a compact flow. Every sentence adds useful information; no fluff or repetition. The length is justified by the need to prevent misuse (e.g., reporting non-Pipeworx tools).

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 enough context about what happens after submission (digest, roadmap). The schema covers all parameters, including nested context. The combination fully equips an agent to decide when and how to invoke this tool correctly.

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

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

The input schema already provides 100% parameter descriptions with clear examples and constraints. The description adds extra guidance on message content ('Describe the issue in terms of Pipeworx tools/packs — don't paste the end-user's prompt') and reinforces context usage via the 'different MCP server' exclusion. This is a meaningful complement to the schema, though not necessary for basic use.

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

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

The description opens with a clear, specific purpose: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It distinguishes this tool from siblings by explicitly limiting scope to Pipeworx-served tools and listing feedback categories (bug, feature/data_gap, praise). No ambiguity about what the tool does.

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

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

Provides explicit when-to-use examples ('returns wrong/stale data', 'tool you wish existed isn't in the catalog', 'worked surprisingly well') and a clear when-not-to-use with alternative action ('if the tool came from a different MCP server... file it with that server instead'). Also adds content guidance (describe in terms of Pipeworx tools/packs, don't paste user prompt).

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds valuable context: data source (CF analytics-engine), no PII, and caching intervals (5min-1h depending on window). This enhances transparency beyond the annotations.

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

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

The description is concise and well-structured. The first sentence clearly states the output, followed by a bulleted list of use cases, then implementation details. Every sentence adds value, and there is 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 simplicity (1 optional parameter, no output schema), the description is complete: it covers purpose, use cases, data source, privacy (no PII), and caching behavior. Annotations further enrich context. No gaps remain for an agent to understand what the tool does and when to use it.

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

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

Schema description coverage is 100% with the 'window' parameter fully documented (enum, description). The description adds a practical explanation: 'Shorter windows surface what's hot right now; longer windows show steady-state demand.' This adds value beyond the schema, justifying a score above baseline 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 states what the tool does: 'Returns the top tools, top packs, and total call volume over a recent window.' It specifies the verb (returns) and the resource (usage trends on Pipeworx), and distinguishes from siblings like ask_pipeworx and discover_tools by focusing on trending/call volume.

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 three explicit use cases: discovering hot data sources, confirming popular tool is canonical, and seeing if use case aligns with most agents. It also mentions caching behavior. It lacks an explicit 'when not to use' or alternative tool mention, but the use cases are clear and helpful.

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

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

Annotations indicate readOnlyHint=true, openWorldHint=true, and idempotentHint=true, which are consistent. The description goes beyond these, detailing internal checks (Jaccard similarity, placeholder filter, fill check against CLOB depth) and response structure. No contradictions.

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

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

The description is dense but well-structured: first sentence summarizes, then details modes, internal logic, and edge cases. While slightly long, every sentence adds essential context for correct tool use.

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 (multiple modes, monotonicity checks, partition checks, fill risk), the description thoroughly covers inputs, behavior, output structure, and caveats. Without an output schema, it compensates 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% with descriptions for both parameters. The description adds value by explaining that 'event' accepts slugs or URLs, 'topic' is a seed question, and no args triggers trending scan. This enriches the schema without redundancy.

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

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

The description clearly states the tool finds arbitrage opportunities via monotonicity violations and partition-sum checks, distinguishes three modes (no args, event, topic), and provides specific examples. It effectively differentiates from sibling tools like polymarket_edges and polymarket_fill_risk.

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

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

The description explicitly advises when to use each mode: 'no args for trending_scan', 'event for a specific market', and 'topic for cross-event scanning'. It also warns about cross-event patterns missed by single-event mode and provides fill check criteria to avoid trading unrealizable edges. This is comprehensive guidance.

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

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

Annotations already indicate read-only and idempotent behavior, but the description adds extensive behavioral context: caching (1h at KV level), how edge is calculated (net of slippage), Kelly fraction caps, 24h-move warnings, and details on each model family. This far exceeds the annotation baseline.

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 verbose, containing extensive details about model formulas and internal logic that may not be necessary for tool selection or invocation. While well-organized front-to-back, it does not earn its length; many sentences could be omitted without harming usability.

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

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

The description covers all relevant aspects: purpose, usage scenarios, response structure (by_segment, fed_candidates, diagnostics), explanation of empty segments, tradeable-edge knobs, and note on excluded Fed bets. Given the tool's complexity and the lack of an output schema, this is very 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 the baseline is 3. The description adds value beyond schema by explaining parameter interactions (e.g., min_kelly vs min_partition_leg_kelly, how slippage_pp affects Kelly sizing). This helps the agent understand nuanced behavior, justifying a score above baseline.

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

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

The description clearly states the tool's purpose: scanning top Polymarket markets to return opportunities where Pipeworx data disagrees with market price. It specifies the use case 'what should I bet on today' and names the verb 'scan top markets and return opportunities'. This differentiates it from siblings like 'polymarket_arbitrage' which likely focuses on pure 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 context on when to use this tool: for discovering opportunities without paging hundreds of markets. It explains the three response segments and the tradeable-edge knobs, giving guidance on how to configure filters. However, it does not explicitly contrast with sibling tools, relying on the distinct purpose to differentiate.

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 and idempotentHint=true, but the description adds valuable behavioral context: snapshot-based, time-series fields (first_seen, trend, decay_pp_per_day), expired opportunities with lifespan, and snapshot_gaps. This exceeds annotation coverage.

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

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

The description is detailed and well-structured with clear sections (RESPONSE, LIMITS). It could be slightly more concise, but every sentence adds value and the front-loading of purpose is effective.

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

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

Given the tool's complexity (multiple arrays, time-series, decay computation) and lack of output schema, the description is remarkably complete. It explains all response fields, limitations (60-day TTL), and computation basis (daily closes). No gaps for effective use.

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

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

Schema coverage is 100%, but the description adds meaning beyond schema by explaining defaults (14 days, '1wk'), clamping (2-30), and the purpose of each parameter (lookback, snapshot family). This 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?

The description clearly states it provides edge persistence and decay telemetry from daily polymarket_edges snapshots, answering how long an edge has existed and its trend. It distinguishes itself from siblings like polymarket_edges (raw edges) and polymarket_arbitrage by focusing on time-series behavior.

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

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

The description gives clear context on when to use this tool (when edge age and decay matter) and contrasts fresh vs. old wide edges. However, it does not explicitly list alternatives or when not to use, so it lacks explicit exclusion 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?

Description aligns with annotations (readOnlyHint, idempotentHint, etc.) and adds valuable context about return values, the risk of partial basket fills, and forced directional risk beyond what annotations provide.

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

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

The description is lengthy but well-structured with bolding for key sections and clear separation of single-market vs basket mode. It is front-loaded with the core 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 no output schema, the description fully explains return values (top_of_book, vwap_fill_price, verdict, etc.), risks, and usage conditions. It is exceptionally complete for a complex tool.

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

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

Schema coverage is 100%, but the description still adds significant meaning by explaining default behaviors (e.g., default side auto-detection for baskets) and the interpretation of size_usd for both modes.

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

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

The description clearly states it performs a realizable-vs-theoretical edge check against live CLOB order-book depth, and distinguishes itself from sibling tools like polymarket_arbitrage and polymarket_edges by specifying when to use it.

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

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

Explicitly says 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500', and warns about the danger of partial fills converting an arb into an unhedged directional position.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds significant behavioral context: explains output format (leg-by-leg prices, matched spreads), safety fields (compatibility_warning, temporal_alignment, skipped counters), and the limitation that most macro shortcuts trigger warnings. No contradictions.

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

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

The description is relatively long but well-structured with clear sections for modes, response, and safety fields. Every sentence adds necessary information; no redundancy. Could be slightly more compact, but it earns its length.

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

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

Given the tool's complexity (dual modes, safety checks, cross-venue comparison) and absence of an output schema, the description thoroughly covers all aspects: parameters, return values, edge cases, and limitations. It provides comprehensive guidance for correct invocation and interpretation.

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

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

Schema coverage is 100%, so the schema already documents all three parameters. The description adds valuable context: explains how the 'topic' parameter maps to specific shortcuts and clarifies that explicit tickers override topic-mapped values. This enhances understanding beyond the schema alone.

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

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

The description clearly states the tool computes cross-venue spreads between Kalshi and Polymarket for identical resolving questions. It specifies two distinct modes (pre-mapped topic shortcuts and explicit event tickers) and what the output includes, making it easily distinguishable from sibling tools like polymarket_arbitrage.

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

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

The description provides clear guidance on when to use the tool, including explicit mode selection and caution that most pre-mapped topics may return warnings. It lacks explicit when-not-to-use instructions compared to siblings, but the safety fields effectively communicate scenarios where spreads are not meaningful.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds value by explaining the scoping behavior ('Scoped to your identifier') and the listing behavior when the key is omitted. 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 three sentences, front-loaded with the primary action, and contains no extraneous information. Every sentence contributes meaning.

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

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

Without an output schema, the description explains what is returned ('retrieve a value' or 'list all saved keys'). It covers the essential behavior for a simple key-value retrieval tool, though it omits details like return format or limits. This is sufficient for the tool's complexity.

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

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

Schema coverage is 100% with one parameter fully described. The description adds the nuance that omitting the key lists all saved keys, which is a behavioral detail not in the schema. While helpful, this is a minor addition, so a score of 3 is appropriate (baseline for full 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 identifies the tool's purpose: 'Retrieve a value previously saved via remember, or list all saved keys'. It uses a specific verb ('retrieve', 'list') and resource ('saved keys/values'), and distinguishes itself from sibling tools 'remember' and 'forget' by mentioning them.

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

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

The description provides explicit guidance on when to use the tool: 'Use to look up context the agent stored earlier... without re-deriving it from scratch'. It explains scoping and suggests pairing with 'remember' and 'forget', though it does not explicitly state when not to use it or list alternatives beyond those 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?

The description discloses that mark_read:true flag returned events as read, modifying state. This contradicts the annotation readOnlyHint=true, but the description is transparent about the side effect. It also confirms idempotent behavior ('Polls work fine') and non-destructiveness, aligning with other 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 four sentences long, with the purpose stated in the first sentence. It efficiently covers return data, filters, side effect, and alternative access without unnecessary repetition. Every sentence adds value.

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

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

Given the absence of an output schema, the description explains the return fields (source, citation_uri, payload). It covers filtering, mark_read behavior, and polling. Missing details like error handling or authentication are not critical for this simple read tool, but the alternative access note adds completeness.

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 cover all parameters (100% coverage). The tool description adds minimal extra meaning: an example for 'type' ('sec_8k') and clarifying 'since' as ISO timestamp. Most parameter semantics are already 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 starts with 'Pull fired events from your subscription feed', which is a specific verb-resource pair. It further details the data returned (source, citation_uri, raw payload) and filter options. The purpose is distinct from sibling tools like list_subscriptions or search_within, though no explicit comparison is made.

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 guidance on parameter usage (filter by type/since, mark_read) and notes that polls work fine. It mentions an alternative access method (direct API) but does not specify when to use this tool versus sibling tools. No explicit when-not-to-use advice.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint as true, and destructiveHint as false. The description adds details about the fan-out to multiple sources (SEC EDGAR, GDELT/GNews, USPTO), fallback logic, soft-fail for patents, and the return structure including citations. 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 informative but somewhat lengthy. However, it is well-structured, starting with user-facing queries, then describing the fan-out, parameter details, and ending with the alternative tool. Each sentence serves a purpose, but there is room for slight trimming 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 tool's complexity (three required parameters, no output schema), the description thoroughly covers the sources, fallback behavior, date format, return structure (changes grouped by source, total_changes, citation URIs), and provides an alternative. It is complete for an agent to understand and invoke correctly.

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

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

Schema coverage is 100% with descriptions for all three parameters. The description adds value by providing concrete examples for the 'since' parameter (ISO date and relative shorthand like '7d', '30d') and suggesting '30d' or '1m' for typical monitoring. It also clarifies that 'value' can be a ticker or CIK. This goes beyond the schema alone.

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

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

The description clearly states the tool returns a change feed for a company in a specified time window, with specific verbs like 'what's new' and 'latest on Y.' It distinguishes the tool from the sibling 'entity_profile' by noting that entity_profile is for static profiles regardless of time window.

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

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

Explicit usage patterns are provided (e.g., 'What's new with X'), along with when to use the alternative 'entity_profile' instead. Parameter guidance, such as recommending '30d' or '1m' for typical monitoring, and explanation of fallback behavior (GDELT→GNews) are included.

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

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

Description adds behavioral context beyond annotations: scoping by identifier, 24-hour retention for anonymous, and persistent storage for authenticated users. 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?

Three clear sentences: purpose, usage, and details. Front-loaded with core function, 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?

Complete for a memory store tool: explains what it stores, how it persists, and how to retrieve (recall) or delete (forget). No output schema needed.

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

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

Schema coverage is 100%, but description adds valuable context: key naming patterns (e.g., 'subject_property') and value types (findings, addresses). Exceeds 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 states the tool saves data for later reuse, provides concrete examples (e.g., resolved ticker, target address), and distinguishes it from sibling tools recall and forget.

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

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

Explicitly says use when discovering something worth carrying forward, and notes pairing with recall/forget. Also explains persistence differences for authenticated vs anonymous sessions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds valuable behavioral context: cascades through multiple endpoints, returns specific fields (ticker, CIK, RxCUI, company_name, ingredient, brand), and includes citation URIs. No contradiction with annotations.

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

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

The description is info-dense and well-structured with a purpose statement, usage guidance, and type details. However, the opening string of example phrases is somewhat repetitive and could be tightened without losing meaning, so it is not maximally concise.

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

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

For a two-parameter lookup tool with strong annotations and no output schema, the description covers purpose, usage, return values, accepted input forms, and even internal behavior. It is complete enough for an agent to select and invoke the tool correctly.

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

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

Although the schema already covers both parameters, the description enriches meaning by defining type-specific accepted inputs (e.g., ticker/CIK/name for company, brand/generic for drug), mentioning auto-disambiguation, and specifying exact output fields per type. This significantly exceeds schema-level 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's purpose: resolving user-spoken names to canonical/official identifiers. It uses a specific verb ('resolve') and resource ('name to identifier'), and differentiates from siblings by noting that other tools require these IDs and recommending this tool be used 'FIRST' when a name needs an ID.

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

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

This description explicitly provides when-to-use guidance: 'Use FIRST whenever you have a name but need an ID.' It also gives example queries and notes that it replaces 2-3 manual lookups, clearly indicating this tool over alternatives for ID resolution.

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 it probes each entity with 'ai_visibility_check', ranks by score, and returns a ranked list with score, confidence, and signal density. This adds significant context beyond the annotations (readOnly, openWorld, idempotent) and does not contradict them.

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

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

The description is three sentences, each earning its place: first sentence states core action, second explains mechanism and output, third gives use case. No fluff, front-loaded with 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?

The tool has 4 parameters, no output schema, but the description covers the return format (ranked list with score/confidence/signal density). It lacks mention of error handling or limits (e.g., entity count bounds) but is complete enough 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% so baseline is 3. The description adds value by explaining the 'entities' array semantics (first is subject, rest competitors), 'context' for disambiguation, and the 'models' parameter requirement for Anthropic API keys. This goes beyond the schema's native 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 'scan' and 'compare' as verbs. It distinguishes itself from sibling tools like 'ai_visibility_check' (single entity) and 'compare_entities' (not AI-specific) by specifying the domain and the multi-entity ranking.

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 it's useful for competitive AI-marketing audits and gives an example question. It implies when to use (multi-entity comparison) vs alternatives, though it does not explicitly state 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 provide readOnlyHint, idempotentHint, destructiveHint. Description adds critical behavioral context: partial failures degrade gracefully, bundlephobia first measurement can take 5-30s, sources_failed listed on timeout. No auth or rate limit info, but adequate 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?

Four sentences, front-loaded with purpose, then usage, ecosystem scope, and failure behavior. Every sentence adds distinct value; no wasted words.

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

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

Despite no output schema, description lists all return fields. Covers composite nature, ecosystem scope, partial failure behavior, and timing. Complete for a tool without output schema.

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

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

Schema description coverage is 100% (both parameters described). Description adds limited additional meaning beyond schema, mainly context about default version behavior, which is already in 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?

Description clearly states the tool is a composite check for npm packages, specifying the verb 'scan', resource 'dependency', and scope 'npm ecosystem'. It differentiates from siblings by being a one-call composite across deps.dev and bundlephobia.

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

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

Explicitly states when to use ('is X safe / popular / small') and when not to use ('PyPI / Maven / Cargo / Go fall under deps.dev:version directly'), providing clear context against alternatives.

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

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

Annotations already declare readOnly, idempotent, and non-destructive. Description adds technical details: BGE-base-en embeddings, cosine similarity, 500-char windows, 200K char cap with truncation and flagging, and return of offsets for verification. No contradictions; description enriches beyond annotations.

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

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

Four concise sentences, front-loaded with core purpose and usage, followed by technical details, examples, and pairing suggestion. Every sentence adds value with no fluff.

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

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

Despite no output schema, description adequately hints at return structure (passages, offsets, scores). Combined with full parameter docs, strong annotations, and usage guidance, the description is complete for an agent to correctly invoke the tool.

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

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

Schema coverage is 100% with descriptions for all three parameters. Description adds helpful natural-language query examples but does not significantly expand on schema for text or limit. The example queries provide extra semantic clarity, raising baseline from 3 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?

Clearly states the verb ('search inside'), resource ('a fetched record'), and what it returns ('top-N passages with character offsets and similarity scores'). Distinguishes from siblings by mentioning pairing with ask_pipeworx_grounded and use case of large documents.

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

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

Explicitly says 'Use when the record is too big to cram into the prompt' and suggests an alternative workflow with ask_pipeworx_grounded, providing clear when-to-use and how-to-pair 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?

The description adds significant behavioral details beyond the annotations, such as the requirement for an OAuth account, rate limits on SMS (10/day), webhook HMAC signing, and auto-disable after 10 failures. It also explains the persistent feed 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 packed with information but well-structured, starting with the main purpose and then detailing types and delivery options. It is slightly dense but every sentence adds value. A more structured format with bullets or sections could improve readability.

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

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

Given the tool's complexity (3 params, nested objects, no output schema), the description is comprehensive. It covers all subscription types, delivery channels, behavioral notes, prerequisites, and even hints at output (subscription ID). No gaps remain for an agent to misinterpret usage.

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

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

With 100% schema coverage, the baseline is 3, but the description greatly enriches parameter understanding. It provides concrete examples for each subscription type (e.g., 'items:["5.02"] = officer change'), explains the delivery object options in detail, and clarifies required fields like 'sponsor or condition' in clinical_trial. This goes well 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 creates a proactive monitoring subscription to a live-data event stream and returns the new subscription ID. It uses specific verbs and resources, and distinguishes itself from sibling tools like 'unsubscribe' and 'list_subscriptions' by focusing on creation.

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

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

The description provides clear context on when to use the tool, including prerequisites (Pipeworx OAuth account), supported types, and delivery channels. However, it does not explicitly contrast with alternatives or state when not to use it, so it misses the highest 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?

Annotations already provide readOnly, openWorld, idempotent, and non-destructive hints. The description adds value by detailing the return format (category-bucketed examples with tool+argument shapes) and the optional topic parameter behavior, without contradicting annotations.

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

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

The description is somewhat lengthy but well-structured, starting with alternative phrasings, then core purpose, output details, usage instructions, and when to use. Every sentence adds value, though minor trimming could improve 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 simplicity (one optional parameter, no required fields, no output schema), the description thoroughly covers its purpose, usage, output, and context. It provides all necessary information for an agent to decide when and how to invoke it.

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

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

The input schema covers the single 'topic' parameter with 100% coverage. The description enriches this by listing specific topic values (finance, pharma, real-estate, etc.) and explaining that omitting the parameter returns a cross-category spread, which is not in the schema 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 the tool is an onboarding entry point that suggests example questions about what Pipeworx can do. It uses specific verbs and resources, and distinguishes from sibling tools like ask_pipeworx and discover_tools by focusing on exploration rather than direct querying.

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

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

The description explicitly instructs to 'Use this FIRST when you do not yet know what Pipeworx can do for you, or to learn how to call the meta-tools'. It also implies alternative use cases by highlighting that the tool is for discovering capabilities, contrasting with direct question-asking tools among siblings.

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

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

Disclosures beyond annotations: row is deactivated not deleted, historical events stay available. Annotations already indicate non-destructive and not read-only. Adds useful context on 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?

Two sentences: first states core action, second adds ownership and deactivation detail. No wasted words, front-loaded with 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?

For a simple cancel operation with no output schema, description covers purpose, ownership constraint, and outcome (deactivation). Complete enough for agent to understand behavior.

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 3. The description adds no new info about the id parameter beyond what the schema already provides.

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

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

Clearly states 'Cancel a subscription by id.' Specific verb and resource. Distinguishes from siblings like subscribe and list_subscriptions by emphasizing ownership enforcement and deactivation behavior.

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

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

Explicitly says 'Ownership is enforced — you can only cancel your own subscriptions.' Provides clear condition for use. Does not explicitly mention when not to use or alternatives, but the condition is 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds significant behavioral context: internal pipeline details (SEC EDGAR fast path vs grounded pipeline), exact percent-delta math, and return values (verdict, actual value with citation, reasoning). 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 well-structured and front-loaded with key phrases like 'Is it true that…'. Every sentence adds value, but the description is somewhat lengthy. It could be slightly trimmed without losing clarity, but overall it is 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 parameter set (2 parameters, 1 required) and comprehensive annotations, the description covers all essential aspects: purpose, usage, internal behavior, and return values. No output schema exists, but the description explains what is returned (verdict, value, citation, reasoning). Complete 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?

Schema coverage is 100% with descriptions for both parameters. The description adds value beyond the schema: explains tolerance override logic, default behavior, and how tolerance_pct relates to claim wording. This extra context helps select appropriate parameter values.

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

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

The description clearly states the tool verifies natural-language factual claims against authoritative sources, with specific examples like "Is it true that…" and "fact check". It distinguishes itself from sibling tools by explicitly covering company-financial claims (via SEC EDGAR) and other claims (via grounded pipeline), which is a unique capability among the listed siblings.

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

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

The description explicitly says 'Use whenever the agent needs to check whether something a user said is factually correct.' It provides context on internal routing but does not explicitly exclude use cases or name alternative tools for other types of questions. However, the given context is sufficient for typical use.

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