Arcgis Monocounty

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds valuable behavioral context beyond these: the default model (Workers AI, free), the BYO key requirement for Anthropic with direct payment implications, and the return structure (per-model score, confidence, signals, raw_response + combined view). This is rich, non-redundant disclosure.

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 the primary action, and every sentence earns its place: what it does, how to use the optional key, what it returns, and when to use it. No filler 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?

Given the moderate complexity (4 parameters, no output schema), the description fully compensates for the missing output schema by describing the response shape. It covers input, output, default behavior, cost model, and use cases, leaving no significant gaps for an agent to invoke the tool correctly.

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

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

Schema description coverage is 100%, so the parameters are already well-documented in the schema. The description adds extra meaning by explaining the default behavior of `models` (workers-ai), the conditional need for `_apiKey` (only when 'anthropic' is in models), and the cost implication. This goes beyond what the schema states, justifying a 4.

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

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

The description uses a specific verb ('Probe') with a clear resource (one or more LLMs about a business/brand/product/topic) and distinct output (visibility score 0-100 per model). This clearly distinguishes the tool from siblings like scan_competitor_ai_presence or deep_research by focusing on multi-LLM knowledge scoring.

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

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

Clear use cases are provided ('AI-marketing audits, pre-launch brand checks, competitive monitoring') and the default vs. paid model path is explained. However, there are no explicit exclusions or direct comparisons to sibling tools that might also be relevant, so it earns 4 rather than 5.

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

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

Annotations already declare readOnlyHint and non-destructive behavior, so the description adds value by disclosing that it fills arguments, returns citation URIs, and works on every tier with a single fast call. This operational context goes beyond the safety profile without contradicting annotations.

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

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

The description is lengthy but packed with essential information, opening with a clear directive ('PREFER OVER WEB SEARCH'), providing examples, and structuring alternatives with 'START HERE' and 'Step up only when needed'. It is not wasteful, though slightly dense.

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

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

With no output schema, the description compensates by explaining the return format (structured answer with stable citation URIs) and covering trigger scenarios, alternatives, and breaking-news behavior. It fully equips an agent to use this complex routing tool effectively.

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

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

The input schema has six aliases for the same question parameter, and the description clarifies that the agent only needs to provide a natural-language question; the tool handles routing and argument filling. This adds meaning beyond the schema's field descriptions, which simply label each as an alias.

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 ask_pipeworx as a router that answers factual questions by selecting from 5,462 tools and returning structured answers with citation URIs. It distinguishes itself from siblings like ask_pipeworx_grounded and deep_research by explicitly marking itself as the default entry point.

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

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

The description gives exhaustive usage guidance: prefer over web search for specific data domains, use for trigger phrases like 'what is' and 'look up', and step up to ask_pipeworx_grounded for grounded answers or deep_research for broad multi-part questions. It also addresses breaking-news 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?

Beyond the annotations (readOnlyHint, idempotentHint), the description discloses the beta nature, candidate testing status (none active, last retired on a specific date), and that it currently matches ask_pipeworx exactly. It also clarifies it is a full working router, not a fallback, adding valuable 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 front-loaded with the core purpose, then provides precise current state, usage guidance, and a clarifying note. Every sentence adds unique information without redundancy, making it concise yet informative.

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 single-required-parameter schema, strong safety annotations, and the tool's beta nature, the description fully covers its purpose, current behavior, and relationship to the stable variant. No important aspects are missing.

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

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

Schema coverage is 100%, with all six parameters documented as aliases for 'question'. The description adds no additional parameter semantics, but the schema already fully covers parameter meaning, so a 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 defines the tool as a beta version of ask_pipeworx with identical routing functionality, citing the same 5,462 tools, arguments, and response shape. It distinguishes itself from the stable sibling by noting candidate routing improvements, making its 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?

It explicitly instructs to use it exactly like ask_pipeworx when wanting the newest routing, and notes that results are compared against the stable router. This provides clear when-to-use guidance and implies the alternative (stable router) for non-experimental needs.

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 beyond the annotations by disclosing the refusal mechanism with specific refusal reasons, the return shape including verbatim evidence, and the extra LLM call cost. It also clarifies that it only uses tool result content, which adds context about the tool's behavior that annotations do not cover.

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

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

The description is densely informative yet efficient. It front-loads the core purpose, then explains mechanism, return format, usage context, and cost. Every sentence adds value and the structure is logical, making it easy for an agent to parse.

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 (routing through 5,462 tools) and the absence of an output schema, the description fully describes the return shape, success and refusal cases, and provides usage context. It covers purpose, behavior, guidelines, and cost, leaving no critical gap.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add new meaning about the 'question' parameter beyond saying 'your question in natural language', which is already in the schema. The aliases are also already documented in the schema. No additional parameter semantics are provided.

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

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

The description clearly identifies the tool as a 'hallucination-resistant answer mode for high-stakes reads' and distinguishes it from the sibling 'ask_pipeworx' by describing the same routing but with an additional extraction step that uses only tool results. The verb+resource+scope is specific and differentiates it from 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?

Explicit usage guidance is provided: 'Use whenever an answer will be quoted, cited, or acted on' and 'prefer ask_pipeworx for casual lookups' names the alternative and the cost tradeoff. This clearly states when to use this tool versus an alternative.

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

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

The description extensively discloses behavioral traits far beyond the readOnly/idempotent/destructive annotations: resolver confidence thresholds, closed-market handling, wide-spread illiquidity tags, news fallback mechanics, cancellation-rule risk with quantified EV impact, and a warning about edge being already priced in. It also explains blocking vs. non-blocking responses for low-confidence matches. No contradictions with annotations (readOnlyHint=true aligns with safe research).

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

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

The description is long but well-structured, with labeled sections (CLASSIFIERS, FAN-OUT EXAMPLES, RESPONSE SHAPES, SAFETY, RESOLUTION-RULE RISK) and front-loaded purpose in the first sentence. Each section contributes necessary operational details for a complex tool. Minor redundancy exists around low-confidence resolution routes ('both routes are BLOCKING'), which slightly inflates length without adding much new 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 the tool's complexity and lack of an output schema, the description is exceptionally complete. It covers response shapes for result.market and result.analysis, resolver contract fields (market_match_confidence, alternatives, suggestions), parent_event extraction, news fallback fields, status codes for low-confidence/closed markets, and cancellation-rule handling. This allows an agent to use the tool correctly and interpret results safely without external documentation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's examples of market slugs, URLs, and question text mirror the schema's own descriptions. It adds no additional semantics for 'depth' or 'include_raw' beyond what the schema already states, and its fan-out examples are about behavior rather than parameter syntax.

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 'Research[es] a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It provides concrete use cases ('should I bet on X', 'what does the data say about Y', 'is there edge in Z') which distinguishes it from sibling tools focused on arbitrage, edge tracking, or general data queries. The verb+resource is specific and unambiguous.

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

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

The description gives explicit 'Use for' scenarios and rich fan-out examples for different bet types, giving clear context for when to invoke this tool. However, it does not explicitly name alternative tools or describe when NOT to use it (e.g., for cross-market arbitrage, use polymorphic_arbitrage instead). Thus it has clear usage context but lacks 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, openWorldHint, idempotentHint, and destructiveHint=false. The description adds substantial behavioral context beyond this: it details data sources (SEC EDGAR/XBRL for companies, FAERS for drugs), handles off-calendar fiscal years, sorts results by primary metric, and returns paired data with citation URIs. It also communicates that it replaces 8–15 sequential lookups, giving the agent a clear sense of cost/benefit.

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

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

The description is dense but every sentence earns its place. It front-loads common trigger phrases, then states the operational rule, then details data sources, then explains output sorting and return format. No filler words or redundant restatements of the title. It packs substantial information into a compact, readable structure.

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 there is no output schema, the description adequately covers return behavior: paired data, citation URIs, and sorting by primary metric. It also covers edge cases like off-calendar fiscal years and specifies entity limits (2–5). The tool is simple enough that the description fully covers all relevant aspects for correct invocation and expectation-setting.

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

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

Schema coverage is 100% (both parameters have descriptions), so the baseline is 3. The description adds meaningful domain semantics: for type='company' it pulls 10-K revenue, net income, cash, and long-term debt, while for type='drug' it pulls FAERS adverse-event counts, FDA approvals, and trial counts. This goes beyond the schema's simple 'company or drug' definition, enriching the agent's understanding of what values mean.

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

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

The description clearly states the tool performs side-by-side comparison of 2–5 companies or drugs in one parallel call. It distinguishes itself from single-entity lookups by explicitly positioning it as the preferred tool for comparison queries, and the trigger phrases ('X vs Y', 'rank these companies') leave no ambiguity.

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

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

The description provides explicit usage context: whenever the user compares entities, asks which is bigger/better, or ranks companies. It also states 'ALWAYS PREFER over sequential single-pack lookups when comparing entities,' which clearly tells the agent when to use this tool instead of alternatives like entity_profile. No exclusions are needed because the trigger phrases already define the boundary.

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

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

The annotations already declare read-only, open-world, idempotent, and non-destructive. The description adds substantial behavioral context: account requirements, auth URL, paid plan for thorough, the fact that it is NOT open-web search, parallel routing, return packet composition (verbatim evidence, confidence, source, fetched_at, citations, gaps[]), contradicting finding scan, hop field, citation_uri fetchability condition, semantic excerpting, and expected latency. It does not contradict any annotation.

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 every sentence carries useful information—account requirements, core behavior, use-case guidance, alternative tools, depth semantics, return format, and timing. It is front-loaded with the critical account warning. However, it is a single dense paragraph; breaking it down with sections or bullets would improve scannability, but the density is justified for a complex tool.

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

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

With no output schema, the description takes on the burden of explaining return values, and it does so thoroughly: findings packet, verbatim evidence, confidence, source, fetched_at, stable citations, gaps[], contradictions[], hop field, citation_uri conditions. It also covers auth, account tiers, latency, and alternatives, making the tool fully understandable in context.

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

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

Both parameters have 100% schema coverage with detailed descriptions. The tool description repeats depth semantics (e.g., 'depth:"thorough" needs a paid plan') but these are already in the schema, which states 'thorough=8 (paid)'. The description adds no meaningful new parameter-level meaning beyond what the schema provides, so the baseline of 3 applies.

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

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

The description clearly states it performs grounded multi-source research across 1,419 STRUCTURED data sources, decomposes questions into facets, routes them to 5,462 tools in parallel, and returns a findings packet. It explicitly distinguishes itself from open-web search and from sibling ask_pipeworx, making its purpose unambiguous.

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

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

The description explicitly says it's best for broad/multi-part questions over structured data, and gives precise alternatives: 'For a single lookup use ask_pipeworx', 'For BREAKING or colloquial CURRENT-NEWS... prefer ask_pipeworx', and 'If you are not signed in, use ask_pipeworx instead'. This provides clear when-to-use and when-not-to-use guidance.

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

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

Annotations already declare the tool safe and idempotent. The description adds valuable behavioral context: it returns top-N tools with full schemas and curated examples, ready to call directly without another lookup. This goes beyond the annotations and clarifies the result format, though it does not address potential edge cases like no-match behavior.

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

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

The description is well-structured and front-loaded with the core purpose. The list of covered domains is long but directly relevant for a discovery tool, and every sentence contributes to usage, behavior, or return format. Slightly overstuffed but not wasteful.

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

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

There is no output schema, so the description rightly explains the return format (tool names, descriptions, full schemas, examples, ready-to-call). With annotations covering safety and the schema covering parameters, the description provides enough context for an agent to decide when to use it and what to expect. It lacks only minor details like pagination or error handling, which are not critical 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% with every parameter (including aliases) having a description. The description only mentions 'top-N' and the domains for query formulation, but does not add syntax or format details beyond what the schema already provides. Baseline 3 is appropriate when the schema carries the parameter documentation burden.

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 'Find tools by describing the data or task' with a specific verb and resource, and enumerates the domains covered. It clearly differentiates this from sibling tools like search_datasets by focusing on discovering tools (with schemas) rather than datasets or data layers.

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?

It provides explicit 'Use when' guidance and instructs 'Call this FIRST when you have many tools available', which is strong direction. However, it does not explicitly state when not to use it (e.g., if you already know the exact tool), so it falls short of a full when/when-not pair.

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 a safe, read-only, idempotent operation. The description adds substantial behavioral context beyond that: fans out across multiple sources, returns specific fields with sorting, includes a soft-fail for USPTO PatentsView sunset, and a GDELT→GNews fallback. 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 dense but well-organized: user intent examples first, then core scope and preference, then return fields, then input format caveat. Each sentence adds value, but it is longer than necessary and could be broken into a cleaner list. Still, it remains efficient for the complexity covered.

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

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

The description covers the main inputs, outputs, and caveats (patents sunset, name restriction, fallback chains). It lacks an explicit error case (e.g., unknown ticker) and the exact JSON structure of the response, but given the absence of an output schema, it provides enough context for an agent to invoke the tool and interpret typical results.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds concrete examples ("AAPL", "0000320193") and reinforces the zero-padding requirement, which goes slightly beyond the schema. However, most parameter meaning is already in the schema, so a 4 is appropriate.

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

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

The description clearly states the tool's purpose with specific verbs ('profile', 'brief', 'research') and resource ('US public company'). It distinguishes from siblings by describing a holistic cross-source profile in one parallel call, contrasting with chaining single lookups. The expected output fields are enumerated explicitly.

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: 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view.' It also gives a clear exclusion ('names not supported') and a direct alternative ('use resolve_entity first'). Soft-fail and fallback behaviors are disclosed for edge 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 destructive and idempotent hints. The description adds context about the memory lifecycle ('previously stored memory') and the intended use cases (stale context, task done, sensitive data), which goes beyond the basic annotations. It does not contradict any annotation and supplements the safety profile.

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

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

The description is two sentences, direct and front-loaded with the action. Every word earns its place, covering purpose, usage, and companions without fluff.

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

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

With only one parameter, comprehensive annotations, and no output schema, the description fully covers the tool's utility, usage context, and relationships to sibling tools. No additional behavioral or return details are necessary.

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 'key' described as 'Memory key to delete.' The description mentions 'by key' but adds no additional meaning beyond the schema. Baseline of 3 is appropriate since the schema fully documents the parameter.

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

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

The description clearly states the action: 'Delete a previously stored memory by key,' specifying the verb (delete), resource (memory), and method (by key). It distinguishes from sibling tools by explicitly mentioning remember and recall, clarifying that it is the removal counterpart.

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

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

The description provides explicit usage scenarios: 'when context is stale, the task is done, or you want to clear sensitive data.' It also advises pairing with remember and recall, offering practical guidance on how to use the tool within a workflow.

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 valuable behavior detail beyond the annotations: it fetches the page, extracts title/description/key links, and emits a text blob. This aligns with the readOnlyHint and idempotentHint annotations, and clarifies the output format. No contradictions. It could mention potential limitations like rate limiting, but not necessary given annotations.

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

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

The description is concise with three sentences covering purpose, process/output, and use cases. Every sentence adds value and there is no redundancy. The main function is front-loaded.

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

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

The description is complete for a simple read-only tool. It explains the output format as a single text blob, the process of fetching and extracting, and provides use cases. With rich annotations covering safety and schema covering parameters, there are no significant gaps.

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

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

The input schema has 100% coverage with clear descriptions for both 'url' and 'max_links'. The description only mentions 'any URL' and does not elaborate on parameter usage or defaults, which is acceptable since the schema already provides this 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?

The description clearly states the tool's function with a specific verb and resource: 'Generate a production-ready llms.txt file for any URL'. It distinguishes itself from sibling tools like ai_visibility_check and scan_competitor_ai_presence by focusing on creating the llms.txt file, not just checking visibility.

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

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

The description provides explicit use cases such as getting a client's site indexed by AI, drafting llms.txt for your own project, or auditing how an AI crawler would see a competitor. This gives clear context for when to use the tool. However, it does not mention when not to use it or name specific 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 declare read-only, idempotent, and non-destructive behavior. The description adds value by disclosing the exact return payload (fields, geometry type, count, capabilities), going beyond the annotations. No contradictions detected.

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 with no filler. Every word adds meaning, efficiently covering the action, input, and output specifics.

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 one-parameter metadata tool with strong annotations and no output schema, the description thoroughly explains what the tool returns. The explicit enumeration of fields, geometry type, record count, and capabilities compensates well for the lack of 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 for the single 'url' parameter is 100%, including an example and description. The tool description adds only the phrase 'by url', which repeats what the schema already conveys. No additional parameter-specific semantics are provided, so baseline 3 is appropriate.

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

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

The description states a specific verb+resource: 'Get an ArcGIS Feature/Map Service layer's schema by url', and enumerates the exact schema contents (fields, geometry type, record count, capabilities). This clearly distinguishes it from sibling tools like query_layer or search_within, which handle data queries.

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

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

The description clearly implies this tool is for schema/metadata retrieval, and sibling tool names like query_layer suggest data access alternatives. However, it does not explicitly state when not to use it or mention alternative tools by name.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds value beyond these by listing the returned fields (id, type, params, etc.) and noting the scope ('caller's'). It does not mention pagination or sorting, but given the strong annotation coverage, the added context is sufficient for a 4.

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

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

Two sentences, front-loaded with the primary action, followed by return fields and usage guidance. No redundant information, every sentence adds value.

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

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

Given the simple schema (1 optional param) and no output schema, the description covers the return format and usage context well. It could mention include_inactive explicitly, but the schema covers that. Slight gap: no mention of ordering or edge cases, but overall it is sufficiently complete for this tool's complexity.

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

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

Schema coverage is 100% with include_inactive fully described. The tool description does not add extra parameter semantics beyond the schema, though the phrase 'active subscriptions' implicitly aligns with the default false. Baseline 3 is appropriate as the schema carries the parameter burden.

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

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

The description clearly states the tool's action ('List the caller's active subscriptions') with a specific verb and resource. It distinguishes itself from sibling tools like subscribe and unsubscribe by focusing on listing, and further differentiates via return fields and use context.

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

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

Provides explicit guidance: 'Use this to review what you're monitoring before adding more or to find an id to cancel.' This directly tells the agent when to use this tool versus alternatives (subscribe/unsubscribe), satisfying the dimension fully.

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

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

The description discloses non-obvious behaviors not present in annotations: rate-limited to 5 per identifier per day, free/no quota, claim_token flow for follow-up, and digest reading frequency. It also warns against pasting end-user prompts. Annotations (readOnlyHint=false, destructiveHint=false) don't conflict with these statements.

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 paragraph is dense but front-loaded with the primary purpose and usage triggers. It packs many operational details into a single block; while every sentence adds value, it could be broken into scannable bullets. It remains appropriately sized for the tool's complexity.

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

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

Given no output schema, the description covers return behavior via claim_token, status follow-up, rate limits, and exclusions. No critical operational fact is missing, making it self-sufficient for an agent to select and invoke the tool safely.

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

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

Schema already covers 100% of parameters with detailed descriptions. The description adds modest extra guidance—'Describe the issue in terms of Pipeworx tools/packs' and 'don't paste the end-user's prompt'—which supersedes bare schema semantics. Since the schema descriptions are already rich, the added value is incremental, not fundamental.

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

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

The description opens with a specific verb+resource ('Tell the Pipeworx team something is broken, missing, or needs to exist') and enumerates four explicit categories (bug, feature/data_gap, praise), clearly distinguishing this from sibling research/query tools like ask_pipeworx or discover_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?

It explicitly states when to use each category and, critically, when NOT to use it: 'if the tool came from a different MCP server... file it with that server instead.' It also names the alternative action and provides a test for ownership ('Pipeworx tool names are the ones this connection lists').

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

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

The annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive. The description adds meaningful context beyond this: it is self-aggregating, derived from CF analytics-engine, contains no PII, and is cached 5min-1h. This helps set expectations about freshness and privacy.

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

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

The description is front-loaded with the core purpose, followed by a bullet-style 'useful for' list and then technical details. It is three sentences, each earning its place. Slightly verbose due to the list, but still efficient and well-structured.

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 read-only tool with one optional parameter and no output schema, the description covers the return value (top tools, packs, call volume), the aggregation source, caching, and privacy. It's sufficiently complete for an agent to invoke it without confusion, though it could mention whether results are sorted or roughly what the response structure looks like.

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

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

The input schema has 100% coverage for the single 'window' parameter, including its enum values and semantics ('Shorter windows surface what's hot right now; longer windows show steady-state demand'). The description repeats this information but does not add new meaning beyond the schema, so the baseline of 3 applies.

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

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

The description clearly states the tool's function: it reports what other AI agents are calling on Pipeworx, returning top tools, top packs, and total call volume. This is a specific verb+resource combination that distinguishes it from sibling tools like discover_tools or search_datasets, which focus on discovery/search rather than aggregate usage trends.

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

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

It provides concrete use cases (discovering hot data sources, confirming canonical tool choices, assessing alignment with agent needs) and explains the trade-off between windows (shorter = hot right now, longer = steady-state). It doesn't explicitly name alternative tools or state when not to use it, but the context is clear enough to guide 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 declare readOnly, openWorld, idempotent, and non-destructive, and the description adds extensive behavioral detail: monotonicity/partition-sum logic, 3pp threshold, 0.30 Jaccard similarity anchor, placeholder filtering, and fill-check against live CLOB depth. 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?

Although long, the description is well-structured with uppercase section labels and front-loaded purpose. Every section adds non-redundant behavioral information needed because there is no output schema, making the length justified rather than padded.

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

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

For a complex, multi-mode tool with no output schema, the description covers all necessary context: input modes, scan scope, internal filters, response shape, when signals are unreliable, and companion tools. This is a complete and actionable specification.

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

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

Schema coverage is 100% with detailed parameter descriptions and examples, so the baseline is 3. The description adds extra semantic guidance by explaining when to prefer event vs topic, showing seed questions, and describing cross-event union behavior, which enriches but does not dramatically expand on 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 opens with a precise verb+resource+method statement: 'Find arbitrage opportunities on Polymarket via monotonicity violations + partition-sum checks.' It clearly differentiates three modes (no-arg trending scan, event, topic) and distinguishes itself from sibling tools like polymarket_edges and polymarket_fill_risk.

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

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

Usage guidance is explicit: call with NO args for a trending scan, pass event for a specific market, or pass topic for cross-event scanning. It even tells the agent when NOT to act ('do not trade it' when realizable_edge_pp ≤ 0) and points to polymarket_fill_risk for custom sizing.

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 readOnly/idempotent/non-destructive, and the description adds substantial behavioral context beyond that: 'Cached 1h at the KV level keyed on all knobs,' 'edge_pp_net (after slippage),' a 24h-move warning, detailed model family rules (e.g., 'placeholder-slug filter,' 'partitions with >20% placeholder fraction skipped entirely'), and diagnostic funnel counters. 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 dense and structured (FIVE MODEL FAMILIES, TRADEABLE-EDGE KNOBS, RESPONSE TOP-LEVEL), and every sentence carries value. However, it is a very long wall of text with heavy parentheses and ALL-CAPS section markers, making it harder to scan than it could be. Still, it is not fluff.

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

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

Despite no output schema, the description fully enumerates the response structure: by_segment, fed_candidates/fed_note, _diagnostics with funnel counters, and the fields carried by every opportunity (edge_pp_net, kelly_fraction, market.liquidity, etc.). It also explains why segments may be empty and how knobs affect results, making it highly complete for a complex tool.

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

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

Schema coverage is 100% and descriptions are already good, but the tool description adds significant meaning: slippage_pp gets extra context ('Polymarket has zero trading fees as of 2024 but bid/ask + thin depth typically eats 20-50bp per trade'), min_partition_leg_kelly gets parent-level Kelly behavior explained, and max_spread_pp includes a concrete 'Set to 2' recommendation. This goes well beyond the schema.

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

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

The description opens with 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price' — a specific verb, resource, and scope. It clearly distinguishes itself from siblings by focusing on Pipeworx data disagreement and the 'what should I bet on today' use case.

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 its purpose: 'Built for "what should I bet on today" — agents discover opportunities without paging hundreds of markets.' It also describes when to use knobs (e.g., 'Set to 2 to require tight books'), explains why fed_candidates are excluded from ranking, and notes that concentrated_longshot is 'rare-by-design.' While it doesn't name sibling tools directly, the context is unambiguous.

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

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

Beyond the readOnlyHint and idempotentHint annotations, the description details response structure (tracked/expired/snapshot_dates), computation method (daily closes of edge_pp_net), data gaps (cache-miss snapshots), and limitations (60-day TTL). This is exhaustive behavioral disclosure with no contradiction to 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?

Although lengthy, the description is dense and well-structured: purpose, args, response breakdown, then limits. Every sentence adds meaningful information, and the front-loaded question makes it immediately scannable.

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

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

With no output schema, the description fully explains return fields (tracked, expired, snapshot_dates), their meanings, and edge cases like lifespans and gaps. It also covers historical depth and computation nuances, making it complete for a complex telemetry 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 baseline is 3. The description adds the concept of 'snapshot family' and confirms the window options, but largely restates the defaults and clamps already present in the schema. Minor added value but not enough to raise above baseline.

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

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

The description starts with a specific verb-resource pair ('Edge persistence and decay telemetry') and immediately answers the core question: 'how long has this edge existed and is it shrinking?' It clearly distinguishes itself from siblings like polymarket_edges by focusing on historical persistence, not current edge scanning.

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?

It provides clear context: use when you need to assess whether an edge is new or decaying. However, it does not explicitly state when to avoid it or mention alternative tools, so it stops short of full exclusionary guidance.

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

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

The description goes far beyond the annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint) by detailing mode-specific behavior: walking the ladder, returning top_of_book/vwap_fill_price/slippage_pp, interpreting size_usd differently per mode, clamping size_usd to 10–1,000,000, and warning about stranded legs via forced_directional_risk. This rich behavioral detail is not present in the structured 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 (roughly 200 words) but densely packed with necessary information. It front-loads the core purpose, then systematically covers single-market, basket, and usage guidance. Every sentence contributes value, though the length could be seen as slightly high for a tool with a 100%-covered schema. Overall it is well-organized and appropriately sized for the tool's complexity.

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

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

Given that there is no output schema, the description compensates by listing all return fields for both modes (e.g., theoretical_sum, realizable_sum, capture_ratio, thin_legs, max_clean_notional_usd). It also covers edge cases like partial fills and forced directional risk, and includes parameter defaults and constraints. The description is fully complete for an AI agent to invoke this tool correctly without further documentation.

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

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

Schema coverage is 100%, but the description adds crucial semantics: it introduces the constraint that exactly one of `market` or `event` is required (not visible in schema), explains `size_usd` as max spend vs target proceeds in single-market mode but settlement notional in basket mode, and clarifies the default for `side` (auto-selected in basket mode based on partition sum). This meaningfully supplements the schema.

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

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

The description opens with a specific verb+resource statement: 'Realizable-vs-theoretical edge check against live CLOB order-book depth.' It clearly distinguishes two modes (single-market and basket) and explicitly differentiates from sibling tools by stating it should be used before acting on polymarket_arbitrage or polymarket_edges signals. The purpose is unmistakable and not a tautology.

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 when-to-use guidance is provided: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500.' It also explains why—theoretical overround on thin books is not capturable and partial basket fills create unhedged directional risk. This clearly positions the tool against alternatives and gives actionable 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?

Even with readOnlyHint/openWorldHint annotations, the description adds substantial behavioral context: it explains compatibility_warning's two distinct trigger cases, temporal_alignment meaning, skipped_cross_type/subtype semantics, and why matched_pairs=0 can still indicate non-equivalent bet shapes. This far exceeds the annotation baseline and gives the agent a clear model of edge-case behavior.

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

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

The description is organized with clear section markers (TWO MODES, RESPONSE, SAFETY FIELDS) and every section contributes meaningful guidance. However, it is quite long and dense, with several enumerated edge cases and warnings packed into a single block, making it slightly less scannable than it could be.

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

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

With no output schema, the description fully compensates by explaining the response structure (leg-by-leg prices, spread[].top_spreads_pp), safety fields, temporal alignment, and counters. It also prepares the agent for realistic failure modes and common mismatches, making it remarkably complete for a complex cross-venue comparison 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 schema already provides 100% coverage with descriptions and examples for all three parameters. The description adds useful semantics about mode interaction (topic as shortcut, explicit overrides), auto-fetch behavior, and the meaning of response fields, but much of the parameter-specific meaning is already present in the schema, so the added value is solid but not exceptional.

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

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

The description opens with a specific, unambiguous statement: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' It clearly distinguishes this from sibling tools by emphasizing cross-venue comparison and the caveat about bet-shape equivalence, making the tool's scope and value immediately clear.

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

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

The description provides explicit when-to-use guidance via TWO MODES (topic shortcuts vs explicit event pairing) and detailed when-not-to-use conditions (compatibility_warning, temporal_alignment false, pre-mapped ≠ tradeable). However, it does not name alternative sibling tools (e.g., polymarket_arbitrage) for comparison, so it stops short of a full alternatives-based usage guide.

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 read-only, idempotent, and open-world hints, and the description adds useful context: it returns attribute rows and geometry, and gives a quick sampling strategy. It doesn't discuss rate limits or performance implications of requesting geometry, but given annotation coverage, this is a solid score.

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

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

The entire description is two sentences: the first clearly states purpose and key parameters, the second provides a practical tip. No wasted words, and the most important information is front-loaded.

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

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

For a query tool with six parameters and no output schema, the description effectively explains the return format, the source of the URL, and a quick-start approach. It doesn't mention pagination limits beyond what the schema already documents, and the absence of an output schema is partially compensated by the 'Returns attribute rows (and geometry)' statement. Overall, it's quite complete but misses minor behavioral details like error handling.

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

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

Schema description coverage is 100%, so parameters are fully documented. The description reinforces the 'SQL-like where' and 'comma-separated out_fields' but adds little beyond the schema. The sampling tip is helpful for parameter usage but doesn't significantly elevate semantics beyond the baseline for high coverage.

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

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

The description clearly states the tool queries an ArcGIS Feature/Map Service layer by URL, with a specific verb and resource. It also implies the output (attribute rows and geometry) and references search_datasets as the source, distinguishing it from siblings like layer_info and search_within.

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 indicates the intended workflow by specifying the URL comes from search_datasets, and it provides a concrete sampling tip (where='1=1' + out_fields='*'). However, it doesn't explicitly name alternative tools or state when not to use this tool, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds meaningful behavioral context beyond annotations: scoping to the caller's identifier (anonymous IP, BYO key hash, or account ID) and the omitting-key lists-all behavior. This gives the agent awareness that results may vary by caller and that the tool doubles as a key listing function.

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

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

The description is four sentences, each serving a distinct purpose: primary action, use case with examples, scoping detail, and related tools. It is front-loaded with the main verb ('Retrieve') and resource, and contains zero filler. The information density is high 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?

For a low-complexity tool (one optional parameter, no output schema), the description covers the essential behavioral aspects: retrieval, listing, scope, and relationship to remember/forget. While it doesn't explicitly describe the return format, that is arguably implied for a memory recall tool. The lack of an output schema is mitigated by the clear, complete functional description, though a slight gap remains regarding the shape or type of the retrieved value.

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

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

The input schema has 100% coverage for the single 'key' parameter, with a description that already states 'Memory key to retrieve (omit to list all keys)'. The tool description adds example use cases and scope context, but doesn't fundamentally expand the parameter's semantics beyond what the schema provides. Baseline 3 is appropriate since the schema does the heavy lifting, and the description offers only marginal extra insight.

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

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

The description clearly states the tool's function with a specific verb ('Retrieve') and resource ('a value previously saved via remember'), and also covers the alternate behavior of listing all keys when the key argument is omitted. It distinguishes itself from sibling tools by explicitly referencing 'remember' and 'forget' as related memory operations, making it unmistakable as the read counterpart in a memory triad.

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

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

The description provides explicit usage context: 'Use to look up context the agent stored earlier' with concrete examples (user's target ticker, address, prior research notes). It also names the complementary tools 'remember' and 'forget', effectively telling the agent when to use this tool versus those alternatives. Though it doesn't state 'do not use for general search', the scope and examples make the intended use clear.

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

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

The description transparently explains the mark_read side effect (flags events read, affecting subsequent calls), which goes beyond the annotations' readOnlyHint. It also clarifies the feed is persisted and polls work fine, adding useful behavioral context not present in the structured fields.

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

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

The description is three sentences, front-loaded with the core action, and every clause adds meaningful detail. It is efficient and well-structured, avoiding redundancy with the schema.

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

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

With no output schema, the description compensates by specifying return fields (source, citation_uri, payload). It covers filtering, mark_read behavior, and polling context. It doesn't explicitly address limit semantics or unread_only, but the schema covers those, making the description sufficiently complete for a tool of this 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 the baseline is 3. The description adds value by giving a concrete example for type ('sec_8k'), explaining since as an ISO timestamp, and elaborating on mark_read's purpose in the polling flow. It doesn't mention limit or unread_only, but those are well-covered by schema descriptions.

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

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

The description clearly states the tool's function: 'Pull fired events from your subscription feed.' It identifies the specific resource (subscription feed alerts) and provides details about return contents (source, citation_uri, raw payload), distinguishing it from siblings like list_subscriptions or recent_changes.

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

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

The description gives clear context: it's for retrieving recent alerts from the evaluator's persisted feed, with filtering options and polling. It also mentions an alternative access method (GET registry.pipeworx.io/alerts.json) for scripts/dashboards. It doesn't explicitly exclude sibling tools, but the use case is well-implied.

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 say readOnlyHint=true and destructiveHint=false, but the description adds substantial behavioral context: it fans out to SEC EDGAR, GDELT→GNews (with fallback logic for rate-limiting/5xx), and USPTO (noting the PatentsView API sunset and soft-fail behavior). It also explains the `since` parameter format and return structure. This goes well beyond what annotations provide.

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

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

The description is a dense paragraph but logically structured: example queries, core purpose, source fan-out details, parameter explanation, return value, and alternative. Every sentence carries unique information. It's slightly long but earns its length; front-loading with query examples makes the purpose immediately 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?

For a multi-source tool with no output schema, the description is remarkably complete. It covers the one-call parallel fan-out, each data source, failure/fallback behavior, both `since` formats, return structure (changes[] grouped by source, total_changes, citation URIs), and the key sibling alternative. Given the complexity, this is fully adequate 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 elaborating on the `since` parameter with concrete examples ('7d', '30d', '3m', '1y') and recommending '30d' or '1m' for typical monitoring. It also clarifies that `value` accepts a ticker or zero-padded CIK, which reinforces the schema. Description supplements rather than merely repeats 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 opens with concrete example queries ('What's new with X'), then states it provides a 'change feed for a company in the last N days/weeks/months in ONE parallel call.' It clearly identifies the resource (company change feed) and the verb (getting updates). It also distinguishes itself from sibling entity_profile by explicitly naming the alternative for static profiles.

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 directly tells the user when to use this tool vs. an alternative: 'Use entity_profile instead when you want the static profile (filings + fundamentals + LEI + patents) regardless of window.' The examples ('updates on Acme', 'news on Tesla recently') further illustrate the intended query pattern. This meets the 'explicit when/when-not/alternatives' criterion.

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 cover idempotency and non-read-only behavior, but the description adds valuable context: persistence differences between authenticated users (persistent) and anonymous sessions (24 hours), and scoping by identifier. 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 four sentences covering purpose, usage, storage semantics, and related tools with no redundancy. Information is front-loaded and every sentence earns its place.

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

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

For a simple key-value store tool, the description covers the essential aspects: purpose, when to use, persistence, and companion tools. It does not describe return values, but that's not critical for a store operation, and the annotations/schema fill most remaining 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%, so baseline is 3. The description adds meaning with examples of what to store (resolved ticker, target address, etc.) and clarifies the key-value pair structure, going beyond the schema's generic property descriptions.

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

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

The description uses a specific verb ('Save') and identifies the resource ('data the agent will need to reuse later'), clearly stating the tool's purpose. It also distinguishes from siblings by mentioning companion tools 'recall' and 'forget' and specifying cross-session/cross-conversation scope.

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?

It explicitly states when to use ('Use when you discover something worth carrying forward') and provides concrete examples. It also references related tools (recall, forget) for retrieval and deletion, but does not explicitly state when not to use it.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds valuable behavioral context beyond these, such as internal cascading through lookup endpoints and the exact return payloads (ticker + CIK + company_name; RxCUI + ingredient + brand). 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 longer than a one-liner but well-structured with a SUPPORTED TYPES section and example phrasings. Each part adds information—examples, return values, citation URIs, and the cascade note. It's organized enough that no sentence is wasted, though it could be slightly tighter.

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

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

The tool has two entity types with distinct behaviors, and the description covers output details for both, including citation URIs. There's no output schema, so the description correctly explains return values. It lacks explicit error handling or edge-case info, but the provided details are sufficient for a read-only, idempotent lookup tool.

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

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

Schema coverage is 100% with both parameters documented. The description further enriches semantics by providing real examples ('AAPL', '0000320193', 'ozempic') and clarifying input formats per entity type, which goes beyond the schema descriptions. This added detail justifies a score above the baseline.

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

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

The description clearly states the tool's function: resolving user-spoken names to canonical/official identifiers. It provides specific example queries ('What's the ticker for...', 'find the CIK for...') and lists supported types (company, drug) with return values. This distinguishes it from siblings by emphasizing it's a prerequisite for other tools that need IDs.

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

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

The description explicitly instructs 'Use FIRST whenever you have a name but need an ID,' which is strong when-to-use guidance. It also notes that the tool 'replaces 2-3 manual lookups,' but does not explicitly mention alternative tools or when not to use it. Thus, clear context but no 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, openWorldHint, idempotentHint, and non-destructive, so safety is known. The description adds behavioral detail by stating it calls ai_visibility_check for each entity, ranks results, and returns a structured list with score, confidence, and signal density. It does not mention potential costs/latency of multiple probes, but this is a reasonable addition beyond annotations.

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

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

The description is four sentences, front-loaded with the main purpose, followed by mechanism, use case, and output format. Every sentence adds distinct value with no redundancy or filler.

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

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

With no output schema, the description provides return structure (ranked list with score, confidence, signal density). It covers the workflow and use case. However, it does not mention that the 'models' parameter can probe multiple models, which is a key behavioral aspect, though the schema documents it. Overall, the description is adequate for a tool of this 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 the baseline is 3. The description echoes the schema's note about entities being brand + competitors, but does not add new semantic meaning beyond what the parameter descriptions already convey. It does clarify the 'subject' role, but that is already present in the schema.

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

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

The description clearly states the tool compares AI visibility across multiple entities side-by-side, probes each with ai_visibility_check, ranks by score, and reports most/least recognized. This specific verb+resource+scope distinguishes it from single-entity tools like ai_visibility_check and general comparison tools like compare_entities.

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 a clear use case (competitive AI-marketing audits) and an example query, implying when to use it. It implicitly differentiates from ai_visibility_check by emphasizing multiple entities, but does not explicitly mention alternatives or exclusions, such as when to prefer compare_entities.

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, and idempotentHint. The description adds real behavioral context: partial failure degradation, bundlephobia's first measurement taking 5-30s, sources_failed timeout listing, and rest still returning. This goes beyond the annotation safety profile.

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

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

Despite being moderately long, every sentence adds value: purpose, fan-out details, use cases, ecosystem limits, and failure behavior. It is logically structured and information-dense with no filler.

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

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

With no output schema, the description compensates by naming the exact return fields (is_latest, license, bundle_kb_min, etc.), covering per-advisory details and links, and explaining timeout behavior. Given the tool's composite nature, it is remarkably complete.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (package and version, with default behavior). The description doesn't add additional parameter-level meaning beyond what the schema provides, warranting the baseline score.

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

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

The description clearly states a specific verb+resource: a composite 'should I add this npm package' check that fans out to deps.dev and bundlephobia. It distinctively positions the tool as a one-call package evaluation, distinguishing it from sibling tools like deep_research or validate_claim.

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

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

Explicitly says 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me"' and gives an alternative path (deps.dev:version directly) for non-npm ecosystems, 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 readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds meaningful context about the return structure (name, summary, record_count, owner/org, url) and the integration with query_layer/layer_info, which goes beyond the annotation coverage. 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 redundancy. The first states the action and scope, the second details return fields and downstream usage. Both sentences earn their place and the description is front-loaded with the verb 'Search'.

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 search tool with no output schema, the description is complete: it explains purpose, return fields, and how to use the result with sibling tools. Parameters are documented in the schema, and annotations cover safety. No critical information is missing.

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

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

Schema descriptions cover 100% of the three parameters (query, limit, org_id), so the baseline is 3. The description only mentions keyword search, which is already captured in the schema, and adds no additional parameter-specific meaning.

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

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

The description clearly identifies the tool as a keyword search for Mono County GIS open geospatial datasets, specifies the resource scope, and lists the return fields. It distinguishes itself from sibling tools by focusing on geospatial dataset discovery and providing a URL for downstream 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?

The description gives clear downstream context by instructing users to pass the returned Feature Service URL to query_layer or layer_info. It does not explicitly state when to prefer this tool over alternatives or mention exclusions, but the intended workflow is evident.

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

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

Beyond the annotations (readOnly, openWorld, idempotent, non-destructive), the description discloses rich behavioral details: it returns 'top-N passages with character offsets and similarity scores,' uses 'BGE-base-en embeddings + cosine over 500-char overlapping windows,' and has a 'cap is 200K chars (longer inputs are truncated and flagged).' These details help the agent anticipate output format and constraints. 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 compact yet information-dense. Each sentence earns its place: purpose, input guidance, usage scenario, sibling relationship, and technical mechanics. The key phrase 'saves context' is front-loaded, and no words are wasted. Structure is logical and easy to scan.

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 explains the return format ('passages with character offsets and similarity scores'). It also covers an edge case (input truncation with a flag). The description fully covers what an agent needs to know to invoke the tool correctly, including the usage context and pairing with a sibling 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 baseline is 3. The description adds meaningful context beyond the schema: for 'text' it says 'Pass the text you already pulled (e.g. a SEC 10-K body, an article, a long tool result),' which clarifies what kind of content to pass. For 'query' it gives concrete examples. This added guidance slightly elevates the value to 4.

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

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

The description clearly states the specific function: 'Semantic search INSIDE a fetched record.' It uses a specific verb ('search') and resource ('fetched record'), and explicitly distinguishes itself from siblings by emphasizing it works on already-fetched text rather than fetching. It also names its companion tool (ask_pipeworx_grounded), reinforcing its unique role.

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

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

The description explicitly states when to use: 'Use when the record is too big to cram into the prompt.' It also provides a clear alternative workflow: 'Pairs with ask_pipeworx_grounded: fetch with the gateway, ground over the relevant passages instead of the whole document.' This gives both a usage condition and a comparison to a sibling tool.

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

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

Annotations already indicate mutation and idempotency, but the description adds rich behavioral context: OAuth requirement, always-on feed, per-channel delivery specifics, phone verification, 10/day SMS cap, webhook signing secret returned once, and auto-disabling after failures. No annotation contradictions found.

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

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

The description is dense but well-structured: primary action and return value first, then requirements, types, and delivery channels. It is longer than the ideal two-sentence example but every sentence conveys necessary operational detail without fluff.

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

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

Given the tool's complexity (3 parameters, nested objects, multiple subscription types, delivery channels, no output schema), the description covers all critical aspects: what it returns, authentication, type-specific params, delivery behavior, verification requirements, and failure handling. It is complete for an agent to invoke correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds significant value beyond the schema by providing concrete examples for each subscription type and explaining nested delivery parameters (phone verification, cap, webhook signing). This goes well beyond the schema's terse 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 opens with a specific verb and resource: 'Create a proactive monitoring subscription to a live-data event stream' and clearly states the return value (subscription id). It distinguishes itself from sibling tools like list_subscriptions and unsubscribe by focusing on creation.

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

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

The description provides clear prerequisites ('Requires a Pipeworx OAuth account') and explains the three supported subscription types with examples, plus delivery channel constraints. It does not explicitly name alternative tools or when-not-to-use scenarios, but the context is strong 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 the tool as read-only, open-world, and idempotent. The description goes beyond these to clarify the output structure (category-bucketed example questions with tool+argument shape) and that results are drawn from the 'live catalog of thousands of tools,' which implies dynamic content. This is useful context not captured in annotations.

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

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

The description is informative but somewhat verbose, starting with a long list of example user queries. While every sentence adds useful context, the length could be trimmed without losing meaning. It is structured and front-loaded with the purpose, but it is not a model of 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 tool with one optional parameter, no output schema, and clear annotations, the description is complete. It explains the output format, usage, and context, giving the agent enough to know when and how to use it. There is no additional output schema to worry about, and the description covers the essential 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?

The input schema already provides 100% coverage, describing the topic parameter with valid values and the behavior when omitted. The description adds only a few examples (e.g., 'finance', 'pharma', 'betting') that are already enumerated in the schema, so it adds marginal 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 what the tool does: it is the onboarding entry point that returns category-bucketed example questions with the exact tool and argument shape to answer them. It is distinct from siblings like ask_pipeworx (which likely answers questions) and discover_tools (which lists tools), making it specific and non-tautological.

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 is provided: '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 the optional topic parameter and that omitting it gives a cross-category spread, which gives the agent clear direction on when to invoke this tool.

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

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

Beyond the annotations (which already indicate a non-destructive write operation), the description reveals that the row is deactivated rather than deleted and that historical events remain accessible via recent_alerts. It also discloses the ownership enforcement rule, adding meaningful behavioral context the agent would not otherwise know.

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 exceptionally concise, consisting of two sentences that immediately state the action and then provide critical caveats. Every sentence adds value, with no fluff or repetition of schema data.

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

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

For a single-parameter tool with no output schema, the description covers all essential aspects: what action is performed, ownership constraints, and the post-condition (deactivation while preserving history). The agent has enough information to use the tool correctly and set expectations.

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 provides a complete description of the only parameter (id), explaining it is a UUID returned by subscribe. The description simply references 'by id' without adding additional semantic details, so it does not elevate beyond the baseline expected when schema coverage is 100%.

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

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

The description opens with a clear action verb 'Cancel' and a specific resource 'subscription', making the tool's purpose immediately obvious. It further clarifies the scope by specifying ownership enforcement and the deactivation behavior, which distinguishes it from subscription-related siblings 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 usage context is clear: use this to cancel a subscription by its ID. It also conveys an important constraint—ownership is enforced, meaning you can only cancel your own subscriptions—which helps the agent decide when to invoke it. It does not explicitly mention alternatives or exclusions, but no direct alternative exists among siblings, so the guidance is adequate.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and idempotentHint=true, covering safety and idempotency. The description adds valuable behavioral context: it explains the two processing paths (structured vs grounded), the return verdict categories, citation format, and the default tolerance cap of 5%. It does not cover rate limits or edge-case failures, but the addition is substantive beyond the annotations.

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

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

The description is longer than typical but is information-dense and well-structured: starts with trigger phrases, moves to use case, then routing, then return values, ending with the replacement benefit. Every sentence contributes meaningful guidance, though it could be tightened slightly without losing critical routing details.

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

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

Given no output schema, the description fully explains the return values (verdict types, actual value with citation, reasoning) and behavior for both claim types. It also covers the tolerance default and the replacement of sequential calls, addressing complexity thoroughly. This is a nearly complete spec for a tool of this 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 description coverage is 100%, so both parameters are already documented in the schema. The description adds extra semantic value by explaining how tolerance_pct overrides claim wording, recommending 1–2 for hallucination detection, and noting the default cap of 5%. This goes beyond the base schema and helps the agent choose parameter values correctly.

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

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

The description clearly states the tool's purpose: natural-language claim verification against authoritative sources, with specific trigger phrases like 'fact check' and 'verify the claim that…'. It distinguishes itself from siblings by detailing the structured SEC/XBRL fast path versus the grounded pipeline, and explicitly notes it replaces 4–6 sequential calls.

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

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

The description explicitly says 'Use whenever the agent needs to check whether something a user said is factually correct', and gives clear routing guidance for company-financial versus other claims. It does not explicitly state when not to use this tool or name alternative sibling tools, so it lacks the full 'when-not/alternatives' bar but provides strong contextual guidance.

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