Arcgis Cumberland

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

The description adds significant behavioral context beyond annotations: it details the return format (per-model score, confidence, signals, raw_response + combined view) and explains cost implications (BYO API key). Annotations already indicate readOnly, openWorld, idempotent, non-destructive, so description complements them well without contradiction.

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

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

The description is concise and well-structured: first sentence states the core action, second covers model details and API key, third describes output, fourth lists use cases. No redundant information.

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

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

Given no output schema, the description thoroughly explains the return structure. It covers all parameters, the optional nature of models and _apiKey, and provides concrete use cases. It is complete for the tool's complexity.

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

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

Schema coverage is 100%, so baseline is 3. Description adds meaning by explaining the entity parameter (what it can be), the models parameter (supported models and default), the _apiKey parameter (only needed for Anthropic), and the context parameter (disambiguation). This adds value beyond the schema.

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

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

The description clearly states the tool's purpose: probing LLMs for knowledge about an entity and scoring visibility (0-100) per model. It identifies the specific resource (LLMs) and the action (probe and score), and distinguishes from siblings like 'scan_competitor_ai_presence' by focusing on LLM knowledge rather than general AI presence.

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

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

The description provides clear usage context: it is useful for AI-marketing audits, pre-launch brand checks, and competitive monitoring. It specifies the default model and when to provide an API key. However, it does not explicitly mention when not to use it or suggest alternative tools.

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

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

Annotations already indicate read-only, open-world, idempotent, non-destructive behavior. The description adds context: routes to 4,552 tools, returns structured answer with stable citation URIs, works on every tier, one fast call. 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 lengthy but well-structured with bullet points and separation of guidance. It is front-loaded with the most important directive. Every sentence adds value, though could be trimmed slightly without loss.

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 (4552 sources) and no output schema, the description adequately covers return format (structured answer with citations) and use cases. Examples further aid completeness. Lacks explicit error handling or expected response structure, but sufficient for a read-only tool.

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

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

Input schema has 100% coverage with descriptions for all parameters (question and aliases). The description provides examples but adds marginal value beyond schema. However, it reinforces that the question parameter accepts natural language and aliases, earning a 4.

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

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

The description clearly states the tool routes factual questions to a vast array of sources and returns structured answers with citations. It distinguishes itself from siblings like ask_pipeworx_grounded and deep_research, and provides specific examples, 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?

Explicit guidance: 'PREFER OVER WEB SEARCH', 'START HERE for most questions', and 'Step up only when needed' for alternatives. Includes query types and examples, leaving no doubt about when to use this tool versus others.

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

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

Adds beyond annotations by describing return format (answer, evidence, confidence, refusal_reason) and specific refusal reasons (not_in_source, no_tool_match, etc.), plus the extra LLM call cost. No contradiction with readOnlyHint.

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

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

Well-structured with front-loaded purpose, but slightly verbose with full response format in description. Only minor redundancy; every sentence earns its place.

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

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

Given complexity (routing among 4552 tools, answer extraction, refusal logic), the description covers all key aspects: mechanism, return structure, tradeoff, and usage recommendations.

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 identifying aliases. The description adds 'Your question in natural language' but doesn't provide additional semantic detail beyond the schema.

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

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

The description clearly states it is a 'Hallucination-resistant answer mode for high-stakes reads' and explains it extracts answers using only tool results, contrasting with sibling ask_pipeworx.

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 (when answer will be quoted, cited, acted on, must not invent facts) and when not (prefer ask_pipeworx for casual lookups), with examples of high-stakes domains.

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

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

The description goes far beyond the annotations, detailing the resolution process, fan-out logic, response shapes, resolver contract with confidence levels, parent event extraction, news fields with fallback behavior, safety short-circuits for low-confidence and closed markets, liquidity warnings, and resolution-rule risk parsing. This level of detail is exemplary.

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

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

The description is very long (approximately 800 words) and covers many details. While well-structured with labeled sections (CLASSIFIERS, FAN-OUT EXAMPLES, etc.), it is not concise. Every sentence adds value, but the length may overwhelm an AI agent scanning for quick understanding.

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 classifiers, fan-out examples, response shapes, safety checks) and the absence of an output schema, the description comprehensively covers what to expect, including edge cases (low-confidence matches, closed markets, wide spreads, cancellation rules). It is fully complete for effective invocation.

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

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

Schema coverage is 100%, and the description adds value by explaining each parameter: market accepts slug, URL, or question text; depth has quick/thorough options with default thorough; include_raw default false and its effect on response size. Examples are provided in the schema and description, making parameter usage clear.

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 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies the verb (research), resource (Polymarket bet via Pipeworx), and provides usage examples like 'should I bet on X'. It distinguishes from sibling tools (e.g., deep_research, ask_pipeworx) by being specifically about Polymarket betting.

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 for "should I bet on X", "what does the data say about Y", or "is there edge in Z".' It provides context on when to use but does not explicitly state when not to use or list alternative tools. However, it covers many edge cases and safety mechanisms, which implicitly guide appropriate usage.

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

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

Beyond annotations (readOnlyHint, openWorldHint, etc.), the description reveals that it pulls latest 10-K data from SEC EDGAR, handles off-calendar fiscal years correctly, and sorts results by primary metric, adding significant behavioral context.

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

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

The description is efficiently written with trigger phrases upfront, followed by purpose, data sources, and behavior, all in a concise block without superfluous 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?

Though there is no output schema, the description explains the return format ('paired data + citation URIs') and sorting behavior, providing complete context for a 2-parameter 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 adds meaningful detail: for type, it explains what data is pulled; for values, it provides examples, formats (tickers/CIKs vs. names), and constraints (2-5 items), going beyond the schema's minimal descriptions.

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

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

The description uses clear trigger phrases like 'Compare X and Y' and explicitly states the tool provides side-by-side comparison of 2-5 companies or drugs in one parallel call, distinguishing it from 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 explicitly prefers this tool over sequential single-pack lookups and outlines the data sources for each type, providing clear context for when to use it, 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?

Beyond annotations (readOnlyHint, openWorldHint), the description details the tool's behavior: account requirement, parallel facet decomposition, return format (findings packet with evidence, confidence, source, gaps[]), and limitations (not open-web search). No annotation contradiction.

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

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

The description is comprehensive but somewhat lengthy. However, it is well-structured with front-loaded caveats and clear sections. Every sentence adds value, but a slightly more compact version might improve efficiency.

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 (2 parameters, no output schema), the description fully covers all necessary context: behavior, return format, limitations, prerequisites, and alternatives. It leaves no ambiguity for an AI agent trying to select or 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?

The description adds significant meaning to the schema parameters: for 'depth', it explains the numeric values (quick=3, standard=5, thorough=8) and the paid plan requirement, which goes beyond the schema's generic description. For 'question', it clarifies that broad/multi-part questions are acceptable, reinforcing the tool's purpose.

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 verb ('research'), resource ('Pipeworx's 1160 STRUCTURED data sources'), and scope ('in ONE call'). It distinguishes from siblings like ask_pipeworx by contrasting use cases and data sources, and provides concrete examples of research questions.

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

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

The description explicitly states when to use (broad/multi-part questions over structured data), when not to (single lookup -> ask_pipeworx, breaking news -> ask_pipeworx), and prerequisites (account required, depth thorough needs paid plan). It names alternatives and provides conditions for their use.

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

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

Annotations already indicate readOnly, idempotent, non-destructive. Description adds: returns top-N most relevant tools with names, descriptions, full input schemas with curated examples, ready to call directly. No contradictions, and adds helpful behavioral context.

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

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

First sentence states purpose, then usage, then details. No unnecessary words. Well-organized and front-loaded.

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

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

Given it's a meta-tool with multiple parameters and no output schema, the description sufficiently explains what is returned (names, descriptions, schemas). Covers all needed context for a discovery tool.

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

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

Schema coverage is 100%, so baseline is 3. Description adds value by explaining aliases for query ('accepts task, q, description, search as aliases') and limit default/max. Provides examples. Slightly 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?

Description clearly states the tool finds tools by describing the data or task, listing many domains. It distinguishes from siblings by being a meta-tool for discovery, not a specific research or alert 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 'Use when you need to browse, search, look up, or discover what tools exist' and 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' Provides clear when-to-use and context.

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

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

Beyond annotations (readOnly, idempotent), the description details what is returned (cik, filings, fundamentals, patents, news, LEI), notes the patents soft-fail, and emphasizes a single parallel call. No contradiction with annotations, but lacks explicit error behavior for missing tickers.

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

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

The description is well-structured with examples first, then purpose, then detailed output, and limitations. Every sentence provides value, though slightly verbose. Front-loading 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 and no output schema, the description covers data sources, return fields, and limitations (patents soft-fail, names not supported). It mentions counts (up to 5 filings) and fallback mechanisms. Could add more on pagination or null fields, but overall complete.

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

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

Schema coverage is 100% with descriptions, so baseline is 3. The description adds examples ('AAPL', '0000320193') and reiterates that names are not supported, but does not significantly enhance the semantic meaning beyond the schema.

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

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

The description clearly states the tool provides a 'full cross-source profile of a US public company' with specific examples, and distinguishes itself from sibling tools like resolve_entity by noting when to use this tool versus alternatives.

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

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

Explicitly says 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view' and advises to use resolve_entity first if only a name is available, providing 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 idempotentHint=true. Description reinforces destructive behavior and adds context about clearing sensitive data, but doesn't provide significant new behavioral details 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?

Two sentences that are front-loaded and efficient, with no wasted words. Every sentence adds value (purpose, usage context, related 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?

For a simple tool with one parameter and no output schema, the description covers purpose, usage guidelines, and safety considerations. Annotations complement well. Complete for the tool's complexity.

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

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

Schema covers 100% of parameters with a clear description for 'key'. Description doesn't add extra meaning beyond what schema provides, so baseline 3 is appropriate.

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

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

Description clearly states 'Delete a previously stored memory by key' with specific verb and resource, and distinguishes from siblings like 'remember' and 'recall'.

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 (stale context, task done, clear sensitive data) and mentions companion tools 'remember' and 'recall', giving clear context and 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 readOnlyHint, idempotentHint, and non-destructive. Description adds behavioral details: fetches page, extracts title/description/key links, and emits standard markdown format. This enriches understanding beyond annotations. It does not contradict annotations.

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

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

Description is three sentences: first states purpose, second explains process, third lists use cases. No fluff, front-loaded, every sentence adds value. Excellent 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?

For a simple tool with 2 parameters, no output schema, and rich annotations, the description is complete. It explains input (URL), process (fetch, extract), output (text blob), and use cases. 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?

Schema description coverage is 100% with both parameters well-described. Description does not add new semantic meaning beyond what is already in the schema for 'url' and 'max_links'. Baseline 3 is appropriate as the description merely restates schema info.

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

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

Description clearly states the tool generates a production-ready llms.txt file for any URL, specifying the verb 'generate' and resource 'llms.txt file'. It also mentions the purpose for AI crawlers. However, it does not explicitly differentiate from sibling tools like scan_competitor_ai_presence or ai_visibility_check, so it loses a point for lack of 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?

Description provides clear use cases: getting a client's site indexed, drafting for own project, or auditing competitor. It gives context but does not explicitly state when not to use or recommend alternatives among siblings, so it scores a 4 for clear context without exclusions.

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, ensuring safety. The description adds value by specifying what schema elements are returned (fields, geometry type, count, capabilities), which is consistent and useful.

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, front-loaded sentence that efficiently communicates the tool's core purpose without unnecessary words.

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

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

Given the low complexity (1 required parameter, no output schema, rich annotations), the description is complete. It fully conveys what the tool does and what it returns.

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

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

The schema already describes the single 'url' parameter with 100% coverage. The description does not add extra meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool retrieves an ArcGIS layer's schema by URL, listing specific details (fields, geometry type, record count, capabilities). It uses a specific verb ('Get') and resource ('layer's schema'), distinguishing it from siblings like 'query_layer'.

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

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

The description implies when to use (when layer schema is needed) but does not explicitly state when not to use or mention alternatives. However, the purpose is clear enough for an agent to decide.

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

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

Annotations already declare readOnlyHint true and destructiveHint false, so the agent knows this is a safe idempotent operation. The description adds specific return fields and the optional include_inactive parameter, but no additional behavioral traits beyond what annotations provide. A score of 3 reflects that description complements annotations without adding major transparency beyond schema.

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, with the first stating the purpose and output, and the second providing usage guidance. It is concise, front-loaded, and every sentence adds value. Perfect for an agent's quick understanding.

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

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

The tool is simple with one optional parameter and no output schema. The description covers purpose, return fields, and usage guidance. It does not mention pagination or limits, but for a simple list tool this is acceptable. The description, combined with schema and annotations, provides sufficient context for correct usage. Score 4 reflects slight gap in mentioning potential list size or ordering.

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 include_inactive property described. The description implies that by default only active subscriptions are returned, which is consistent with the parameter. However, it doesn't elaborate on parameter behavior beyond what the schema provides. A score of 3 is appropriate when schema fully covers parameters.

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

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

The description specifies the verb 'list', resource 'subscriptions', and scope 'caller's active subscriptions'. It lists returned fields, and distinguishes from siblings like subscribe and unsubscribe by stating usage for review before adding or canceling.

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

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

The description provides explicit usage scenarios: review before adding more subscriptions or to find an id for cancellation. While it doesn't explicitly state when not to use, it effectively guides the agent toward appropriate use cases, differentiating from sibling tools like subscribe and unsubscribe.

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

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

Adds behavioral context beyond annotations: rate-limited, free, no quota impact, daily digest by team, affects roadmap. Annotations already indicate non-readOnly and non-destructive, but description enriches with practical 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?

Description is concise yet comprehensive. Front-loaded with purpose, then usage guidelines, then constraints. Every sentence adds value without repetition.

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 feedback submission use case and no output schema, the description covers purpose, when to use, constraints, and parameter guidance completely. No gaps remain.

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

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

Schema coverage is 100%. Description adds usage guidance for 'message' (be specific, 1-2 sentences, 2000 chars max) and reiterates enum meanings for 'type'. This adds value beyond schema, but not all parameters receive extra details; hence 4.

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

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

The description clearly states the tool's purpose: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It further specifies categories (bug, feature, data_gap, praise) and distinguishes from siblings like ask_pipeworx which are for questions.

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

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

Explicitly states when to use (bug, feature/data_gap, praise) and when not to (don't paste end-user prompt). Also provides constraints: rate-limited to 5 per identifier per day, free, doesn't count against quota.

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

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

Annotations already indicate readOnly, openWorld, idempotent, non-destructive. The description adds value by specifying data source (CF analytics-engine), privacy (no PII), caching duration (5min-1h), and the aggregated nature.

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

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

The description is concise, front-loaded with the main purpose, and every sentence adds value. Use of bullet points (1, 2, 3) aids readability without being verbose.

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

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

Given the single parameter with full schema coverage, no output schema, and comprehensive annotations, the description is complete. It explains output structure, data source, caching, and privacy.

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

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

Schema coverage is 100% with a clear description. The tool description adds meaning by advising that shorter windows surface what's hot right now vs longer windows show steady-state demand.

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

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

The description clearly states it returns top tools, top packs, and total call volume over a recent window. It distinguishes itself from siblings like ask_pipeworx or discover_tools by specifying the aggregated trending nature.

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

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

The description lists three specific use cases and explains when to use shorter vs longer windows. It lacks explicit when-not-to-use but the context is clear enough.

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

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

Annotations declare safe read-only, open-world, idempotent behavior. The description adds extensive behavioral context: internal checks (monotonicity violations, partition_sum), semantic anchor (Jaccard similarity ≥0.30), partition filter (placeholder slugs), fill check against CLOB depth, and response structure. No contradiction with annotations.

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

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

Description is lengthy but well-structured with keywords (FILL CHECK, PARTITION FILTER, SEMANTIC ANCHOR) and front-loaded with core purpose. Every sentence contributes to understanding, though some could be tightened. Still, for the complexity, it is appropriately sized.

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 details all response fields (opportunities[], partition_check, fill check metrics) and covers edge cases (skipped low similarity, placeholder filtering, thin legs). It also directs to a sibling tool for custom sizing, ensuring no gaps 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?

Input schema descriptions cover both parameters (100% coverage), but the tool description substantially enriches understanding: for `event`, explains child market walking and partition_check; for `topic`, describes cross-event scanning and the Jaccard similarity constraint. Adds significant value beyond schema.

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

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

The description clearly states the core purpose ('Find arbitrage opportunities on Polymarket via monotonicity violations + partition-sum checks'), specifies three distinct modes (trending_scan, event, topic) with examples, and differentiates from sibling tools by detailing the unique algorithmic approach and cross-event scanning capability.

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

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

Explicit guidance on parameter usage: 'Call with NO args for a trending_scan...', 'pass `event`...', 'or `topic`...'. It explains when to prefer each mode, mentions cross-event catching patterns missed by single-event, and directs users to polymarket_fill_risk for custom sizing. Also includes a fill check warning ('do not trade it' if realizable edge ≤ 0).

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

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

The description goes far beyond annotations by detailing the three response segments with model specifics, caching behavior (1h KV-level), edge calculations, Kelly fractions, and tradeable-edge knobs. It provides extensive behavioral context without contradicting 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 long but front-loads the main purpose. It is densely packed with technical details that are valuable but could be more structured for quicker parsing. Every sentence earns its place, but length may hinder quick comprehension.

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

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

Given the tool's complexity (9 params, no output schema), the description exhaustively covers the response structure, edge calculations, caching, and filter knobs. It leaves virtually no ambiguity about what the tool returns and how it behaves.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaningful usage examples and context (e.g., 'Set to 2 to require tight books') that help an agent understand when and how to set parameters, exceeding 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 verb 'scan' and resource 'top Polymarket markets', and explicitly says it returns opportunities where Pipeworx data disagrees with market price. It is built for 'what should I bet on today', distinguishing its unique value without needing to compare to sibling tools.

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

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

The description provides clear context on when to use the tool: for discovering betting opportunities without paging through hundreds of markets. It explains tradeable-edge knobs and interpretation. However, it does not explicitly mention when not to use it or provide alternatives among sibling tools.

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

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

Annotations declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds details: reads snapshots, provides time-series, trend classification, includes expired opportunities, and notes data gaps on cache-miss days. 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 well-structured with a clear opening question, response format, and limitations. It is somewhat verbose but every sentence adds value. Front-loaded with 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?

Despite no output schema, the description details the return structure (tracked[], expired[], snapshot_dates[]) with field explanations and limitations. This provides complete context for the agent.

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

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

Both parameters are fully described in the input schema with defaults and ranges. Description adds minor context like 'snapshot family' and example values, but schema already covers the necessary semantics. 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 provides 'edge persistence and decay telemetry' from daily snapshots, answering 'how long has this edge existed and is it shrinking?'. It distinguishes from siblings by focusing on time-series analysis rather than current edges, unlike polymarket_edges.

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

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

Description explains when to use (to differentiate fresh vs old wide edges) and includes limitations (60-day TTL, decay from daily closes, not intraday). It does not explicitly list alternatives or when-not-to-use, but context implies it is for historical analysis vs current snapshots.

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 a safe, deterministic check. The description adds significant behavioral context: it describes the ladder-walking logic, return fields (top_of_book, vwap_fill_price, slippage, shares_filled, verdict), and crucially warns about the risk of directional exposure from partial basket fills—the dominant loss mode. 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 with clear sections for single-market and basket modes, but it is relatively long. While every sentence serves a purpose, it could be slightly tightened. However, the front-loading of the main purpose and the use of bold for requirements and warnings make it scannable. Minor deductions for verbosity.

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

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

Despite having no output schema, the description provides a thorough enumeration of return fields (top_of_book, vwap_fill_price, slippage_pp, shares_filled, max_fillable_usd, verdict, theoretical_sum, realizable_sum, capture_ratio, profit_usd, per-leg fill, thin_legs, max_clean_notional_usd, forced_directional_risk). It covers edge cases (thin books, partial fills, directional risk) and explains the 'clean|degraded|cannot_fill' verdict. For a complex tool, 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?

Schema coverage is 100% but the description adds substantial meaning beyond schema: it explains the dual-mode interpretation of parameters (market vs event), the auto-default for side in basket mode based on partition sum, and the different semantics of size_usd for singles (spend/proceeds) vs baskets (settlement notional). This enriches the schema's basic descriptions.

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

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

The description uses specific verbs like 'check', 'walks', and 'returns' to clearly state the tool's purpose: realizable-vs-theoretical edge check against live order book depth. It distinguishes between single-market and basket modes with explicit examples. It also explicitly contrasts with sibling tools 'polymarket_arbitrage' and 'polymarket_edges' by stating when to use this tool before 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 explicitly states when to use: before acting on polymarket_arbitrage signals or polymarket_edges trades above ~$500. It clarifies mode selection via 'REQUIRES one of market or event', explains defaults for side and size_usd, and warns about partial basket fills converting arb into directional risk. This provides clear when-to and when-not-to guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false. The description goes beyond by detailing response fields, safety fields (compatibility_warning, temporal_alignment, skipped counters), and clearly states that real spreads are rarer than the macro list suggests. No contradiction with annotations.

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

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

The description is well-structured, starting with the core purpose, then modes, response, and safety fields. While comprehensive, it is somewhat verbose and could be slightly more concise. However, every sentence adds necessary information for understanding complex behavior.

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 thoroughly explains the response format including leg-by-leg prices, matched spreads, compatibility_warning, temporal_alignment, and skipped counters. It covers edge cases and limitations, providing sufficient context for an agent to use the tool correctly.

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

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

Schema coverage is 100% with clear descriptions for each parameter. The description adds value by explaining the relationship between parameters (e.g., explicit tickers override topic-mapped sides) and listing exact topic values. It also clarifies the two operational modes, which is not evident from the schema alone.

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

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

The description clearly states the tool's purpose: computing cross-venue spreads between Kalshi and Polymarket for the same resolving question. It distinguishes two modes (pre-mapped topic shortcuts and explicit ticker/slug) and explains the response structure, making it distinct 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 explicit guidance on when to use each mode: use `topic` for common macros like 'fed' or 'btc', or use explicit `kalshi_event_ticker` and `polymarket_event_slug` for custom pairings. It also warns that many pre-mapped topics return compatibility_warnings, advising the agent that pre-mapped does not guarantee tradeable spreads.

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

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

Annotations declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds that it returns attribute rows and geometry, which is useful behavioral context. No contradictions.

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

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

Two sentences: first lists key parameters and return type, second provides a concrete usage example. No unnecessary words or redundancy.

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

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

For a tool with 6 parameters and no output schema, the description adequately covers purpose, key parameters, and usage. It does not detail return values but provides enough context for an agent to invoke it correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining SQL-like semantics for 'where', showing an example, and clarifying default values for 'out_fields' and 'where'. This exceeds 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 states the tool queries an ArcGIS Feature/Map Service layer by URL with SQL-like parameters. The verb 'Query' and resource 'ArcGIS Feature Service / Map Service layer' are specific and distinguishable from sibling tools like search_datasets and layer_info.

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 usage context: it queries a layer by URL (from search_datasets) and provides an example for sampling. It implies when to use it but does not explicitly state when not to 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds value by explaining scoping (anonymous IP, BYO key hash, or account ID) and the dual behavior (single key retrieval vs listing all). 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?

Three well-structured sentences, front-loaded with the main purpose. Each sentence adds essential context without verbosity.

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, annotations, and full schema coverage, the description covers all necessary aspects: purpose, usage, scoping, and relationship to siblings. 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% with a clear description for the optional 'key' parameter. The description adds the important nuance that omitting the key lists all saved keys, which enriches the schema information.

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 uses specific verb 'retrieve' and resource 'value saved via remember', clearly distinguishing from sibling tools 'remember' and 'forget'. It also covers the alternative behavior of listing all keys without arguments.

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: to look up context stored earlier, and mentions scoping. Recommends pairing with 'remember' to save and 'forget' to delete, providing clear context of 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 readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds context about mark_read affecting future calls and the feed being persisted. This adds value beyond annotations but 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 concise at about three sentences. Each sentence adds key information: purpose, return fields, filter/mark_read usage, and polling alternative. 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?

For a read-only tool with no output schema and 5 optional parameters, the description covers the tool's purpose, key return fields, parameter usage, and even an alternative access method. It lacks details on pagination or error handling, but overall is fairly complete.

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

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

Schema coverage is 100% with descriptions for all 5 parameters. The description adds extra meaning by providing examples (e.g., 'sec_8k' for type, ISO timestamp for since) and clarifying the purpose of mark_read. This adds value 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 it pulls events from a subscription feed and returns recent alerts with specific fields. It gives a clear verb+resource. However, it does not explicitly differentiate from sibling tools like list_subscriptions, though it mentions an external alternative.

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 some usage context by stating 'Polls work fine' and mentions an alternative access URL for scripts. However, it does not explicitly say when to use this tool over siblings or when not to use it.

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

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

Description expands significantly on annotations by detailing multi-source fan-out (SEC EDGAR, GDELT→GNews fallback, USPTO), specific API limitations (PatentsView sunset), and the return structure including citation URIs. No contradiction with annotations; adds valuable context beyond readOnlyHint, openWorldHint, idempotentHint.

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 information-dense but still well-structured: front-loaded with core purpose, then details on data sources, parameter behavior, and return format. A slight reduction in length could improve conciseness, but every sentence serves a 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 tool of this complexity (multiple data sources, fallback logic, time parsing, citation URIs, and a sibling to distinguish), the description covers all essential aspects. Despite no output schema, it describes the return structure adequately. The mention of a known API sunset shows proactive 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?

With 100% schema coverage, the description still adds meaning: explains that 'since' accepts ISO or relative shorthand ('7d', '30d', '3m', '1y'), recommends typical monitoring windows, and clarifies that 'value' can be a ticker or CIK. This provides actionable usage hints beyond schema definitions.

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

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

The description explicitly states the tool's purpose: providing a change feed for a company within a time window. It uses multiple natural language queries (e.g., "What's new with X") and distinguishes it from the sibling tool 'entity_profile', making the purpose unmistakably clear.

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

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

Provides explicit guidance on when to use this tool (e.g., 'latest on Y', 'updates on Acme') and when to use an alternative ('Use entity_profile instead when you want the static profile'). Also describes fallback behavior between data sources, giving agents clear decision criteria.

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 idempotentHint=true and destructiveHint=false; description adds key behavioral traits: scoping by identifier, persistence differences for authenticated vs anonymous users. No contradiction.

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

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

Three sentences, front-loaded with purpose, no wasted words. Structured to prioritize key info.

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

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

Given no output schema, description explains persistence scope, usage pairing, and session behavior. Complete for a simple write 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 covers both parameters fully (100%), but description adds value by suggesting naming conventions (e.g., 'subject_property', 'target_ticker'). Baseline 3 plus extra guidance.

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?

Explicit verb 'save' and resource 'data' clearly state what the tool does. Distinguishes from siblings 'recall' and 'forget' by mentioning them as pairs.

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 advises 'Use when you discover something worth carrying forward' and provides examples. Tells to pair with recall and forget, giving context for when to use 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 provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds meaningful behavioral context: 'Each call cascades through several lookup endpoints internally — using resolve_entity replaces 2-3 manual lookups' and mentions auto-disambiguation, which goes beyond annotations without contradicting 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 front-loaded with examples and covers all necessary details in a single paragraph. It is efficient but could be slightly more structured (e.g., breaking into separate lines for clarity). Still, every sentence adds value.

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

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

Despite no output schema, the description completely explains return values for both types, including citation URIs, and mentions auto-disambiguation. This fully prepares the agent for tool invocation given the tool's complexity (2 params, clear types).

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 schema coverage is 100%, the description significantly enriches parameter meaning by detailing what is returned for each type (e.g., 'ticker + 10-digit CIK + company_name from SEC EDGAR + citation URI' for company) and clarifying acceptable input forms (ticker, CIK, name; brand or generic). This goes far beyond the schema's brief 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 resolves a user-spoken name to a canonical/official identifier, with specific examples (ticker, CIK, RxCUI). It uses a specific verb ('resolve') and resource ('entity'), and the examples cover distinct use cases, making the purpose 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?

The description explicitly advises 'Use FIRST whenever you have a name but need an ID' and lists supported entity types. However, it does not provide when-not-to-use or compare against sibling tools like 'entity_profile' or 'compare_entities', leaving room for ambiguity in alternative selection.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint (false), covering safety. The description adds value by revealing the internal process: probes each entity with ai_visibility_check and ranks results. It also explains the optional _apiKey requirement for the 'anthropic' model. 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 two sentences with zero wasted words. The first sentence explains the core action, the second provides the use case and expected output. It is front-loaded and efficiently communicates the tool's value.

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

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

For a tool with 4 parameters and no output schema, the description fully covers the return format (ranked list with score, confidence, signal density) and the purpose of each parameter. The schema already handles entity bounds (2-8). No gaps are evident.

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

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

Schema description coverage is 100%, but the tool description adds significant extra meaning: it explains that the first entity is treated as the 'subject' for narrative, how the context parameter disambiguates common names, and which models are supported (workers-ai default, anthropic requires _apiKey). This goes well 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 compares AI visibility across multiple entities, probes each with ai_visibility_check, ranks by score, and identifies most/least recognized. The example use case 'does Claude know about us as well as our competitors?' makes the purpose immediately understandable and distinguishes it from sibling tools like ai_visibility_check (single entity) and compare_entities (general comparison).

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

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

The description says it's 'useful for competitive AI-marketing audits' and implies the context. However, it does not explicitly state when not to use (e.g., for a single entity, use ai_visibility_check instead) or mention alternatives. The guidance is present but not exhaustive.

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

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

Beyond annotations (readOnly, idempotent, etc.), description discloses partial failure behavior, including bundlephobia's first-measurement delay of 5-30s and the sources_failed field. This adds value. No contradictions with annotations.

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

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

Description is a single dense paragraph but well-structured: purpose, then what it does, usage, limitations. Every sentence adds value; no fluff. Slight density prevents a 5.

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

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

No output schema exists, but description explicitly lists all return fields (summary block, advisory details, links, alternatives) and error handling (sources_failed). Covers limitations (NPM only) and timing issues. Very complete for an agent to invoke and interpret results.

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

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

Schema coverage is 100%, so parameters are already well-documented in the schema. Description adds minor extra context (accepts scoped packages) but largely reiterates schema info. 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, combining deps.dev and bundlephobia data. It distinguishes from siblings by explicitly noting NPM-only in v1 and directing other ecosystems to deps.dev:version directly.

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

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

Provides explicit guidance: 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me"' and clarifies when not to use it (PyPI/Maven/Cargo/Go). This helps the agent select the tool correctly over 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 readOnlyHint, openWorldHint, idempotentHint, destructiveHint. Description adds value by specifying return fields (name, summary, record_count, owner/org, url) and the public nature of the data. No contradictions.

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

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

Two sentences with no unnecessary words. Front-loaded with action and context. Every sentence adds value: first defines purpose, second explains return and usage.

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

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

Given 3 optional parameters, no output schema, and robust annotations, the description fully explains the tool's behavior and output. It covers what the tool returns and how to use the results (pass url to query_layer/layer_info). Complete for a search tool.

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

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

Schema coverage is 100%, so the schema already describes each parameter. The tool description does not add extra meaning beyond the schema. It mentions searching by keyword but that aligns with the query parameter. Baseline score of 3 is appropriate.

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

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

Clearly states the verb (search), resource (Cumberland County GIS open geospatial datasets), and scope (by keyword). Includes specific examples like parcels, addresses, zoning & public works. Differentiates from siblings by explicitly mentioning related tools (query_layer, layer_info) for subsequent use.

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

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

Provides clear context on when to use this tool: for searching geospatial datasets by keyword. Implicitly guides the agent on next steps by indicating the return value's url can be passed to query_layer/layer_info. Lacks explicit when-not-to-use or alternative tools but still effective.

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

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

Beyond annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint false), the description adds rich behavioral context: embedding model (BGE-base-en), window size (500-char overlapping), character cap (200K chars with truncation flag), and output details (character offsets, similarity scores). This fully informs the agent of expectations.

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

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

Three sentences, each serving a distinct purpose: core function, use case and benefit, then technical details. No fluff. Front-loaded with the action verb.

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

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

Despite lacking an output schema, the description explains what the tool returns (top passages, offsets, scores, truncation flag) and even the underlying mechanism. This is comprehensive for a tool with only 3 parameters.

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

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

Schema coverage is 100%, so the schema describes all parameters adequately. However, the description adds valuable examples for 'text' and 'query', enhancing practical understanding. The limit parameter default is already in the schema, so the description doesn't add much there.

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

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

The description uses specific verbs ('search inside', 'pass the text', 'get back top-N passages') and clearly identifies the resource ('a fetched record'). It distinguishes from siblings by mentioning pairing with ask_pipeworx_grounded and the concept of 'search inside' vs fetching records.

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

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

The description explicitly states when to use: 'when the record is too big to cram into the prompt' and suggests a pairing pattern. It does not list alternative tools for similar tasks, but the context is 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 mutation (readOnlyHint=false), idempotent (idempotentHint=true), and non-destructive (destructiveHint=false). The description adds context: requires OAuth, returns subscription ID, specifies delivery constraints (e.g., SMS cap, verification). No contradictions with annotations.

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

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

The description is front-loaded with the main purpose and is well structured, but it is fairly long. Every sentence contributes useful information, though some details (e.g., webhook signing) could be slightly more concise. Still, it avoids verbosity.

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 subscription types, nested params, three delivery channels with constraints), the description is exceptionally thorough. It covers all key aspects, including return value, prerequisites, and type-specific parameters, without relying on an output schema.

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

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

Schema coverage is 100%, but the description adds significant value by providing concrete examples for each type's params, explaining required fields, and detailing delivery channel constraints (verified phone, 10/day cap, webhook HMAC). This greatly aids correct parameter selection.

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, returns a subscription ID, and lists supported types and delivery channels. This is specific and distinguishes it from siblings like list_subscriptions (listing) and unsubscribe (removing).

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

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

The description explains when to use (for live-data event streams), prerequisites (Pipeworx OAuth account), and provides examples for each type. It does not explicitly state when not to use or name alternatives, but the guidance is clear enough for most use cases.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds that the tool returns example questions and tool argument shapes, and that it can be called with no arguments or with a topic. This provides useful behavioral context beyond the annotations. No mention of rate limits or auth, but not necessary given the annotations.

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

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

The description is somewhat long but well-structured with front-loaded purpose and examples. Each sentence adds value, explaining what the tool does, when to use it, and how to use the parameter. It is not overly verbose, and the structure is clear.

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

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

Given the tool has only one optional parameter, no output schema, and many siblings, the description completely covers what the agent needs to know: what it returns (category-bucketed example questions with tool+argument shape), when to use it (first time onboarding), and how to use parameters. It is self-contained and sufficient for correct invocation.

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

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

Schema coverage is 100% and the schema describes the topic parameter with its possible values. The description reinforces this by providing examples ('finance', 'pharma') and explains the effect of omitting it (returns full spread). This adds contextual usage information beyond what the schema provides, so it scores 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 the tool as the onboarding entry point that returns category-bucketed example questions and tool recommendations. It uses specific verbs like 'suggest' and 'returns' and distinguishes from sibling tools by positioning itself as the first tool to use when the agent doesn't know what Pipeworx can do.

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 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 explains how to use the topic parameter. While it doesn't explicitly list when NOT to use, the context is clear enough. It could be improved by mentioning alternatives like ask_pipeworx for specific queries.

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

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

The description adds useful behavioral context beyond annotations: ownership enforcement, row deactivation (not deletion), and persistence of historical events. 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?

Two sentences, no unnecessary words, front-loaded with the main action.

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

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

For a simple tool with one parameter and no output schema, the description covers ownership, side effects, and references to related tool (recent_alerts). Missing error conditions, but overall complete.

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

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

Schema coverage is 100% and the parameter description in the schema is adequate. The tool description does not add further meaning beyond what the schema 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 action (cancel) and resource (subscription), but does not explicitly differentiate from sibling tools like 'subscribe' or 'list_subscriptions'.

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

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

The description mentions ownership enforcement, implying you should only cancel your own subscriptions, but lacks explicit guidance on when not to use this tool or alternatives.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint. Description adds valuable behavioral context: return values (verdict types, structured form, citation, delta), scope limitations (US public companies, SEC EDGAR + XBRL), and that it replaces multiple calls. No contradiction.

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

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

Front-loaded with trigger phrases in quotes, followed by purpose, usage scope, domain, and output summary. Slightly verbose but every sentence adds distinct value. Well-organized.

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

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

No output schema exists, yet description sufficiently explains return types (verdicts, structured form, citation, delta). Single parameter fully described. Covers domain, data sources, and replacement of multiple calls. Complete for an agent to understand invocation and 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 coverage is 100% with a single 'claim' parameter already well-described. Description adds example strings which provide useful format context but doesn't add deep semantics beyond what schema provides. Baseline 3 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 defines tool as natural-language claim verification against authoritative sources, with specific examples like 'fact check' and 'verify the claim that...'. It distinguishes from siblings by noting it replaces multiple sequential calls and specifies domain (company-financial).

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 'Use whenever the agent needs to check whether something a user said is factually correct.' Provides domain scope (company-financial) but lacks explicit when-not-to-use or alternatives. Clear enough for typical use.

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