Nager Holidays

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint true and destructiveHint false. Description adds valuable behavioral context: default model free, _apiKey for Anthropic with BYO key and direct payment, return structure details. No contradiction.

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

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

Two sentences with no fluff: front-loaded with purpose, then details on models and return. Every sentence earns its place.

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

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

Given no output schema, description sufficiently explains return format (per-model objects with score, confidence, signals, raw_response + combined view). Parameters fully described. Tool complexity well covered.

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%, baseline 3. Description adds meaning beyond schema: explains default models, _apiKey purpose, context disambiguation role. Suffices for clear parameter understanding.

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

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

Description clearly states it probes LLMs for knowledge about an entity and scores visibility, with specific verb ('probe', 'score') and resource ('AI visibility'). It distinguishes from sibling tools like 'scan_competitor_ai_presence' by focusing on multi-model probing and 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?

Explicitly states usage contexts: 'AI-marketing audits, pre-launch brand checks, competitive monitoring.' Does not mention alternatives or exclusions, but context is clear.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds meaningful context: routing across thousands of tools, argument filling, structured answer with stable citation URIs, universal tier availability, and single fast call. This goes beyond the annotations without contradicting them.

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

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

The description is long but front-loads the most critical guidance ('PREFER OVER WEB SEARCH', 'START HERE') and every sentence adds value: domains covered, examples, step-up alternatives, and special cases. No redundancy or filler, though it could be tightened slightly for scannability.

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 router tool with no output schema, the description is remarkably complete: it explains what the tool does, when to use it, what it returns, alternatives, and provides diverse examples. It covers all necessary context for an agent to invoke it correctly.

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

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

The input schema has 100% coverage with the 'question' parameter and five aliases each clearly described. The description does not need to re-explain parameters, and provides usage examples that illustrate expected input. Baseline 3 is appropriate since schema carries the 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 routes questions to 5,529 tools across 1,455 verified sources, fills arguments, and returns structured answers with pipeworx:// citation URIs. It explicitly distinguishes itself from siblings like ask_pipeworx_grounded and deep_research, 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 provides explicit when-to-use guidance: 'PREFER OVER WEB SEARCH', 'START HERE for most questions', and lists concrete examples and triggers (what is, look up, find, get the latest). It also names alternatives and explains when to step up to ask_pipeworx_grounded or deep_research, plus special handling for news.

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 the beta/experimental nature, the live candidate routing improvements, the current lack of an active candidate, and the fact it matches ask_pipeworx exactly right now. This goes well beyond the provided annotations (readOnlyHint, openWorldHint, idempotentHint) and adds critical context about its testing role and full functionality.

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

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

The description is somewhat long but front-loaded and information-dense, covering identity, current state, usage, and relationship to the stable router. Every sentence carries meaningful content, though a few points are repeated (e.g., 'matches ask_pipeworx exactly' appears twice in different forms).

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

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

Despite lacking an output schema, the description references the 'same response shape' as ask_pipeworx, which is sufficient given the sibling context. It explains the experimental status, the comparison process, and the absence of fallback, making the tool's behavior adequately complete for selection.

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 covers 100% of parameters, including the required 'question' and all aliases. The description adds no additional parameter-level detail beyond 'same arguments,' so the baseline of 3 applies without further compensation.

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 beta version of ask_pipeworx, a universal router with 5,529 tools, and explicitly notes it is a full working router. It distinguishes itself from the stable sibling by highlighting its experimental edge and identical functionality.

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 given: 'Use it exactly like ask_pipeworx when you want the newest routing.' It also states results are compared against the stable router to decide merges, effectively naming the alternative and the intended testing 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?

Adds substantial behavioral detail beyond annotations: the response includes an 'evidence (verbatim quote)' field, explicit refusal reasons ('not_in_source', 'no_tool_match', etc.), and the fact that it uses only the tool result. Annotations only state readOnly/idempotent/non-destructive, so this description significantly enhances transparency with no contradiction.

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

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

The description is front-loaded with the core purpose and every sentence carries unique information (routing, extraction, response shape, usage, cost). It is longer than ideal but justified by the tool's complexity; the structured lists of refusal reasons aid readability.

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

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

The tool is complex (routing across 5,529 tools), and there is no output schema to document the return shape. The description fills this gap by fully specifying success and refusal response structures, including enum values for refusal_reason, and covers trade-offs vs. the sibling tool, making it highly 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% for the single required 'question' parameter and its aliases, all already described in the schema. The description adds no additional parameter-specific meaning, so baseline 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 this is a 'Hallucination-resistant answer mode' for 'high-stakes reads' and explains the extraction behavior ('EXTRACTS the answer using ONLY what the tool result contains'). It also distinguishes itself from sibling 'ask_pipeworx' by noting 'Same routing as ask_pipeworx' but with grounded, evidence-based answers.

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 usage guidance: 'Use whenever an answer will be quoted, cited, or acted on' and warns not to invent facts for specific domains. Also names the alternative: 'prefer ask_pipeworx for casual lookups' and mentions the cost trade-off ('Costs one extra LLM call').

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

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

Annotations indicate safe, idempotent behavior. Description adds extensive behavioral details: fan-out logic, resolver contract, cancellation rules, safety short-circuits for low-confidence matches and closed markets, and response structure. No contradiction with annotations.

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

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

Description is long but well-organized with clear section headers and examples. Each sentence adds value, though it could be slightly more concise for agent parsing. No redundancy.

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

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

Given the tool's complexity (multiple classifiers, fan-outs, response shapes, safety mechanisms) and lack of output schema, the description thoroughly covers all aspects, including edge cases and fallback behavior.

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

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

Schema coverage is 100%, so baseline is 3. Description adds value by explaining depth options (quick vs thorough), providing examples for market parameter, and detailing the impact of include_raw on response size and use cases.

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

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

Description clearly states the tool researches a Polymarket bet by pulling Pipeworx data. It specifies inputs (slug, URL, question text) and distinguishes from siblings by being a comprehensive research tool that categorizes and fans out to data packs.

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

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

Provides explicit use cases ('should I bet on X', etc.) and examples of when to inspect market_match_confidence and parent_event. Does not explicitly compare to alternative tools, but usage context is clear.

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

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

Beyond annotations (readOnlyHint, openWorldHint, etc.), the description details parallel execution, off-calendar fiscal year handling, sorted results by primary metric, and return format (paired data + citation URIs). It also specifies data sources (SEC EDGAR/XBRL, FAERS), adding significant behavioral context.

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

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

The description is a single dense paragraph with front-loaded trigger phrases. Every sentence adds value (examples, data sources, behavior). While it is efficient, slight restructuring (e.g., bullet points for parameters) could improve scanability, but current form is not bloated.

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 covers return values (paired data + URIs), sorting behavior, and data sources. It fully explains the tool's functionality for both entity types, including edge cases like off-calendar fiscal years, making it self-contained.

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 enriches both parameters: for 'type', it explains data sources and metrics (revenue, net income, adverse events); for 'values', it provides examples and constraints (2–5, tickers vs drug names). This adds substantial value over the schema alone.

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

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

The description opens with explicit trigger phrases ('Compare X and Y', 'X vs Y', etc.) and states 'side-by-side comparison of 2–5 companies or drugs in ONE parallel call.' It clearly identifies the action (compare), resource (entities), and scope (2–5), distinguishing it from sequential lookups and sibling tools like entity_profile.

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

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

The description instructs 'ALWAYS PREFER over sequential single-pack lookups when comparing entities,' providing explicit when-to-use guidance. It explains data behavior per type (company vs drug) and notes limitations (e.g., specific financial metrics). However, it does not explicitly list when not to use or mention alternative sibling tools, leaving minor ambiguity.

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

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

Beyond the annotations (read-only, open-world, idempotent), the description discloses the findings packet structure, the gaps[] array with a 'never invented' guarantee, contradictions[] for standard/thorough, the citation_uri fetchability condition, semantic excerpting of large records, and expected latency estimates. This richly supplements the sparse annotation hints and does not contradict them.

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

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

Although the description is long, every sentence earns its place: account requirements, usage exclusions, output semantics, depth behavior, and performance expectations are each addressed once with no redundancy. It is front-loaded with purpose and usage, then dives into behavioral specifics, ending with latency. For a complex tool, this density is appropriate and structurally effective.

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

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

For a tool with this complexity (5,529 tools, three depth modes, gap recovery, contradiction detection), the description covers prerequisites (account, paid tier), alternatives (ask_pipeworx), output format including gaps and contradictions, behavioral guarantees (never invented, citations always fetchable), and performance bounds. With no output schema, this textual specification is essential and leaves few gaps in the agent's ability to invoke and interpret results.

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

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

The schema already covers both parameters (question and depth) at 100%, so the baseline is 3. The description adds higher-level semantic guidance, such as 'Broad/multi-part is fine — decomposition is the point' for the question, and elaborates the depth enum with 'second-hop iteration,' 'gap recovery,' and the paid-tier restriction for 'thorough.' These enrich the parameter meaning beyond the schema's literal 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 phrase: 'Grounded multi-source research' across Pipeworx's 1455 STRUCTURED data sources, explicitly distinguishing this from open-web search and naming examples like 'compare X and Y's regulatory + financial exposure.' This makes the tool's unique value clear and concrete, easily separating it from sibling tools.

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

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

The description gives explicit when-to-use and when-not-to-use rules: it is best for broad/multi-part structured-data questions, while 'For a single lookup use ask_pipeworx' and 'For BREAKING or colloquial CURRENT-NEWS topics, prefer ask_pipeworx.' It even names an account prerequisite and an alternative ('If you are not signed in, use ask_pipeworx instead'), fully covering when-to-use vs alternatives.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds value by explaining that results include full input schemas with curated examples ready to call directly, and that no second schema lookup is needed. No contradictions.

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

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

The description is well-structured, starting with the main purpose, then listing examples, and finally providing usage guidance. It is slightly long but every sentence contributes meaningful information. Could be trimmed slightly without losing value.

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

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

Given the tool's complexity (searching across many domains) and the lack of an output schema, the description is complete. It explains the input (query with aliases, limit), the output (top-N tools with names, descriptions, schemas), and the context (call first when many tools are available). No gaps.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning by explaining that the query accepts natural language and provides examples ('look up FDA drug approvals', 'analyze housing market trends'). It also mentions aliases for query, which the schema also lists. This adds modest value above the schema.

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

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

The description clearly states the tool's purpose: 'Find tools by describing the data or task.' It lists many specific domains (SEC filings, FDA drugs, etc.) and explains that it returns top-N tools with schemas. This distinguishes it from sibling tools by being a discovery tool that should be called first.

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 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' This gives clear when-to-use guidance. It doesn't explicitly say when not to use, but it's implied that if you know the tool, you don't need discovery.

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, etc., so the description adds value by detailing the tool's behavior: it fans out across multiple sources (SEC, XBRL, USPTO, news, GLEIF), notes specific return fields, and discloses that the patents component 'soft-fails until reactivated'. This provides rich behavioral context beyond annotations.

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

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

The description is relatively long but front-loaded with example queries and the key directive. Every sentence adds useful information, though it could be slightly more concise without losing clarity. The structure is logical: examples, purpose, when to prefer, what it covers, input constraints.

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

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

Given the tool's complexity (multiple data sources, potential failure), the description covers inputs, return items, and limitations (patent sunset, name unsupported). No output schema exists, so the description appropriately summarizes return fields. It is sufficiently 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 meaning by reinforcing that names are not supported (schema says 'Names not supported') and explicitly mentions using resolve_entity as an alternative. It also clarifies the format for value (ticker or zero-padded CIK). This goes beyond the schema alone.

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

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

The description explicitly states the tool's purpose: providing a full cross-source profile of US public companies. It starts with example queries that make the intent immediately clear, lists the specific data sources and return fields, and distinguishes itself from sibling tools by recommending this over chaining individual lookups for holistic views.

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 guidance on when to use this tool ('ALWAYS PREFER over chaining ... when the user asks for a holistic view'), when not to use it (names not supported, use resolve_entity first), and provides a clear alternative (resolve_entity for name resolution). This fully satisfies the dimension.

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

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

Annotations already declare destructiveHint=true. Description adds context about clearing sensitive data, which is helpful. No contradiction, but could mention permanence or that deletion is irreversible.

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 succinct sentences, front-loaded with action, no filler. Every sentence provides 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?

Simple tool with one required param, no output schema. Description covers purpose, usage guidance, and sibling relationships. Fully adequate.

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

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

Schema coverage is 100% with param description 'Memory key to delete'. Description adds 'by key' but no extra meaning beyond schema. Baseline 3 is appropriate.

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

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

The description states 'Delete a previously stored memory by key' – a clear verb-resource pair. It distinguishes itself from siblings 'remember' and 'recall' by direct mention.

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 when to use: context stale, task done, clear sensitive data. Also pairs with siblings, giving clear context for 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?

Describes the process: fetches page, extracts title/description/links, emits standard llms.txt markdown. Output is a single text blob. No contradiction with annotations (readOnlyHint, idempotentHint, destructiveHint false).

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

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

Concise with two paragraphs: first is core purpose and technical detail, second is use cases. Front-loaded with main verb and resource. Every sentence serves a purpose.

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

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

Despite no output schema, the description explains the output format ('standard llms.txt markdown' and 'single text blob'). Parameter handling and required URL are clear. Complete for the tool's complexity.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds default and max for max_links, replicating the schema. No additional semantic value beyond what the schema provides, meeting baseline expectation.

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

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

Clearly states the tool generates a production-ready llms.txt file, specifies the output format, and lists use cases for multiple AI crawlers. Differentiates from siblings by focusing on a specific output format.

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 lists three use cases (indexing client sites, drafting own project, auditing competitors), providing clear guidance on when to use. Does not include exclusions or when not to use, but the context is sufficient for most scenarios.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. Description adds return field details but doesn't add behavioral context beyond annotations. Adequate but not enhanced.

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

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

Two sentences, front-loaded with action and returns, no fluff. 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?

For a simple list tool with no output schema, it provides return fields, usage context, and parameter hint (via schema). Complete and sufficient.

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

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

Schema covers 100% of parameters with descriptions. Description adds no parameter context, but schema is sufficient. Baseline 3.

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

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

The description states 'List the caller's active subscriptions' and enumerates return fields, clearly distinguishing from sibling tools like 'subscribe' and 'unsubscribe'.

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

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

Explicitly says 'Use this to review what you're monitoring before adding more or to find an id to cancel', providing clear when-to-use and when-to-use alternatives 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?

All annotation hints are false, so the description must carry behavioral transparency. It discloses rate-limiting (5 per identifier per day), the claim_token workflow for anonymous reporting and later retrieval of resolution status, that the team reads digests daily, and that it is free with no quota impact. This is rich behavioral context beyond what annotations (or lack thereof) 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 moderately long but every sentence earns its place: purpose, usage triggers, exclusion, workflow, rate limit, and quota impact. It is front-loaded with the core action and then logically structured, making it scannable without redundancy.

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

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

With annotations all false and no output schema, the description still comprehensively covers purpose, when to use, when not to use, how to structure feedback, the claim_token workflow, rate limits, cost, and team visibility. It even clarifies the scope boundary (Pipeworx connection only) and provides a fallback identification method, 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?

Input schema covers 100% of parameters with detailed descriptions, giving a baseline of 3. The description adds meaningful extra context by explaining the claim_token lifecycle (file without an account, receive pwfb_…, pass it back later to read status) and implicitly maps the type parameter to the feedback categories in the purpose text. This elevates it above the schema alone.

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

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

The description opens with a specific verb 'Tell' and object 'the Pipeworx team,' clearly defining the tool as a feedback submission channel. It further enumerates exact feedback categories (bug, feature/data_gap, praise) and explicitly differentiates this tool from sibling research/query tools by stating it is for issues with Pipeworx tools themselves.

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 when-to-use guidance: use for wrong/stale data, missing tools, or praise. It also provides a clear exclusion rule: do NOT report issues for tools from other MCP servers, directing users to file those with the respective vendor. It even offers a disambiguation hint ('Pipeworx tool names are the ones this connection lists'), making usage boundaries 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false. The description adds key behavioral context: data source (CF analytics-engine), no PII, and caching behavior (5min-1h). No contradiction.

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

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

Four sentences with clear structure: first sentence states return value, then bullet-pointed use cases, then data source info. No redundant words.

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

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

For a simple tool with one parameter and no output schema, the description covers purpose, usage, behavior, and parameter semantics completely. No missing information for an agent to decide.

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

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

The single parameter 'window' has 100% schema coverage with enum and description. The description adds value by explaining that shorter windows surface hot topics while longer windows show steady-state demand.

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

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

The description clearly states it returns top tools, top packs, and total call volume over a configurable window. It distinguishes from siblings like 'ask_pipeworx' by focusing on trending usage data.

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

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

Three explicit use cases are provided (discovering hot data sources, confirming canonical choice, aligning with agent needs). While it doesn't name alternatives, the context makes it clear when to use.

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

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

Annotations already declare readOnly, openWorld, idempotent, non-destructive. The description adds significant behavioral details: semantic anchor (Jaccard ≥0.30), partition filter (placeholder slugs), fill check behavior (realizable_edge_pp ≤ 0 means not in book), and response structure. No contradictions.

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

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

The description is information-dense and well-structured, front-loading the main purpose and then detailing modes. While somewhat long, it is efficiently organized with clear technical details. Minor redundancy could be trimmed but overall effective.

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

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

Given no output schema, the description explains the response fields (opportunities, partition_check, fill check). It covers edge cases like skipped_low_similarity and placeholder filtering. Missing explicit mention of empty results, but still highly complete.

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

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

The input schema has 100% description coverage. The description adds substantial meaning: explains event slug format, that full URLs are accepted, topic as seed question, and how each parameter triggers different tool behavior. This goes well beyond the schema.

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

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

The description clearly states the tool finds arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It distinguishes three modes (no args, event, topic) and explicitly differentiates from the sibling tool polymarket_fill_risk for custom sizing.

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

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

The description provides explicit guidance: 'Call with NO args for a trending_scan; pass event for strongest per-event partition_check; pass topic for themed cross-event scan.' It explains when to use cross-event mode, warns about the fill check, and directs 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?

The description extensively details behavioral traits beyond annotations: caching (1h at KV level), output structure (by_segment, diagnostics), tradeable-edge knobs, specific formulas (partition algorithm, Kelly caps), and warnings about 24h move. Annotations already declare safety, so description adds rich 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 very thorough but excessively long, containing detailed model methodology and internal formula details that may not be necessary for an agent to invoke the tool. It could be more concise while retaining essential usage 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 (9 parameters, no output schema), the description is remarkably complete: it explains all three segments, diagnostics, caching, Fed bet handling, and provides filters and knobs. No important aspect 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 coverage is 100%, so baseline is 3. The description adds high-level context for parameters (e.g., tradeable-edge knobs) but does not explain individual parameter semantics beyond the already comprehensive 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 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price.' It identifies itself as 'Built for "what should I bet on today"' and distinguishes from siblings by focusing on edge scanning and not just arbitrage or tracking.

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 tool provides clear context for when to use it (daily betting discovery, scanning top markets) and mentions tradeable-edge knobs and filters. However, it does not explicitly contrast with sibling tools or 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 indicate readOnly, openWorld, idempotent, and non-destructive hints. The description adds critical behavioral context: snapshots are written on cache-miss leading to gaps, decay is computed on |edge_pp_net| with signed values, and the response structure includes expired opportunities with lifespan. No contradictions.

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

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

The description is dense but well-structured: starts with purpose, then args, then response format. Every sentence provides necessary information. Slightly long but justified by the complexity of the telemetry 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?

No output schema, but the description fully explains the response structure (tracked[], expired[], snapshot_dates[]) with field meanings. All parameters are covered, and the tool's complexity (time-series, decay trends) is accounted for. Complete contextual guidance for an agent.

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

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

Schema covers 100% of parameters with descriptions. The description adds value by explaining defaults (days=14, window='1wk'), clamping (days clamp 2-30), and the concept of 'window' as snapshot family. It also indirectly explains parameter impact through response structure details.

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

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

The description clearly states the tool provides 'edge persistence and decay telemetry' and answers a specific question about edge age and shrinkage. It distinguishes itself from sibling tools like polymarket_edges by focusing on time-series and decay, not just current snapshots.

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

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

The description explains when to use this tool (to distinguish fresh vs. old edges) and provides limits on history depth and decay computation. It does not explicitly mention when not to use or alternatives, but the context from sibling tools and the detailed explanation sufficiently guides usage.

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

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

Annotations already declare readOnly, idempotent, and non-destructive. Description adds detailed behavioral context (walks ladder, returns verdict, forced_directional_risk) beyond what annotations provide.

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

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

Front-loaded with purpose, then required conditions, then mode-specific details. Uses bold headings for sections. Every sentence is informative; no redundancy.

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

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

Although no output schema, description fully enumerates return fields for both modes and explains the risk scenario. Covers all aspects needed for an agent to decide and invoke correctly.

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

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

Schema coverage is 100%, but description adds significant value: explains defaults for side in both modes, how size_usd is interpreted for buys vs sells and basket settlement notional, and the distinction between market and event parameters.

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

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

Description clearly states it performs a realizable-vs-theoretical edge check against live CLOB depth. Distinct modes (single-market vs basket) are explained, differentiating it from sibling tools like polymarket_arbitrage and polymarket_edges.

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

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

Explicitly specifies when to use: 'before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500'. Also explains why (theoretical overround not capturable, partial fills lead to directional risk).

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 extensive behavioral context: compatibility_warning conditions, temporal_alignment logic, skipped leg counters, and the fact that most pre-mapped topics currently return warnings. No contradiction with annotations.

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

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

The description is well-organized into paragraphs covering purpose, modes, response, and safety fields. It is front-loaded with the core purpose and uses concise, informative sentences. No superfluous content.

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 fully covers the tool's behavior given its parameter count (3) and no output schema. It explains response format (leg-by-leg prices, spread array, safety fields), temporal alignment, and skipped leg counters. Paired with annotations, the agent has sufficient context.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the topic shortcuts (list of 10), how explicit tickers override topic, and the behavior of optional parameters. This goes beyond the schema descriptions.

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

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

The description clearly states 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' It distinguishes this from sibling tools like polymarket_arbitrage by focusing on cross-venue comparison. The two modes (topic shortcuts and explicit tickers) are explained.

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

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

The description explains two modes for invoking the tool and provides explicit guidance on when the output is meaningful through safety fields like compatibility_warning and temporal_alignment. It warns that pre-mapped shortcuts may not always yield tradeable spreads. However, it does not explicitly state when not to use this tool vs. alternatives like polymarket_arbitrage.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds scoping details (anonymous IP, BYO key hash, account ID) and lists behavior when key omitted, providing helpful context beyond annotations.

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

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

Three sentences with no wasted words. Purpose is front-loaded, key functionality and pairing are concisely 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?

For a simple tool with one optional parameter, no output schema, and comprehensive annotations, the description covers retrieval, listing, scoping, and pairing with siblings sufficiently.

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

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

Schema coverage is 100% with a clear description. Description adds the crucial behavior of listing all keys when the key parameter is omitted, which is not explicit in the schema description.

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

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

Description clearly states the tool retrieves saved values or lists keys, with specific verb 'retrieve' and resource 'value previously saved via remember'. It effectively distinguishes from sibling tools 'remember' and 'forget'.

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

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

Explicitly describes when to use (to look up stored context) and pairs with remember/forget. Context scoping is mentioned, but no explicit exclusion or alternative criteria beyond sibling names.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds valuable context: the effect of mark_read on subsequent calls ('so the next call only shows newer ones') and that 'Polls work fine', reinforcing idempotency and safety.

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

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

Four sentences, each purposeful. The first sentence states core action, followed by return format, filtering options, and a behavioral note about polling. No redundancy or wasted words.

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

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

Given no output schema, the description adequately explains return values (source, citation_uri, payload). It covers key parameters and mentions an alternative endpoint. Missing error details, but overall sufficient for a simple fetch 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 detailed parameter descriptions. The description reinforces these (e.g., type example 'sec_8k', mark_read effect) but does not add substantial new meaning beyond the schema.

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

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

The description clearly states the tool retrieves 'fired events from your subscription feed' and specifies the returned fields (source, citation_uri, raw event payload). It distinguishes itself from siblings like list_subscriptions by focusing on events rather than subscription management.

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

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

The description implies usage for retrieving recent alerts and mentions polling is fine, but does not explicitly contrast with alternative tools or state when not to use this tool. Sibling tools exist but no guidance on 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?

Beyond annotations (readOnly, idempotent, non-destructive), the description details the tool's behavior: fans out to three sources, explains fallback logic (GDELT→GNews), notes USPTO soft-fail, and describes the return structure. No contradictions with annotations.

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

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

The description is front-loaded with example queries and well-organized, but somewhat lengthy. Every sentence adds value, though minor trimming could improve conciseness.

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

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

Given no output schema, the description thoroughly explains the return format (changes grouped by source, total_changes, citation URIs). It covers source behavior, fallbacks, and limitations, making the tool fully comprehensible.

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

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

Schema coverage is 100%, and the description adds significant value: explains `since` formats (ISO date or relative) and suggests typical values, clarifies `value` accepts ticker or CIK, and notes `type` is limited to 'company'.

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

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

The description clearly states the tool's purpose: a change feed for a company in a recent time window. It uses specific verbs and resources, and distinguishes itself from the sibling tool entity_profile by contrasting temporal changes vs. static profile.

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

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

Explicitly tells when to use this tool (for temporal changes) and when not to (use entity_profile for static profile). It also provides guidance on `since` parameter with default '30d' or '1m' for typical monitoring.

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

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

Annotations indicate idempotentHint=true, which aligns with storing key-value pairs. The description adds behavioral context: scoped by identifier, persistent for authenticated users, 24-hour retention for anonymous. 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 front-loaded with purpose and usage, followed by details. It is concise with four sentences covering all necessary aspects without redundancy.

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

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

For a memory store tool with no output schema, the description covers purpose, usage, persistence details, and pairing with sibling tools. It is complete for an agent to understand and invoke correctly.

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

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

Schema description coverage is 100% with both key and value described. The description adds example key patterns but does not provide significant additional semantics beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Save data the agent will need to reuse later' with concrete examples like 'resolved ticker, target address, user preference'. It distinguishes it from sibling tools recall and forget.

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

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

Explicitly says 'use when you discover something worth carrying forward' and provides context about session scoping and pairing with recall and forget. Gives clear when-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?

The description discloses significant behavioral detail beyond the annotations, including that identifiers are labeled with their source, unresolved identifiers are explicitly listed under `unresolved`, LEI/FIGI enrichment degrades gracefully if external services are unavailable, and each call cascades through multiple endpoints. It also explains the ownership information available for company entities and the RxNorm citation for drugs. Annotations already establish read-only/idempotent traits, and the description adds concrete operational context without contradicting them.

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

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

The description is long but densely packed with useful information. It is front-loaded with example user phrasings, then states the core purpose and usage directive, and then breaks down each supported type with output specifics. Every sentence contributes either to identifying when to use the tool, what it returns, or how it behaves under degradation, so there is no waste.

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

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

For a tool with no output schema, the description thoroughly explains the return values: CIK, ticker, company name, LEI with ownership hierarchy, FIGI, and RxCUI with ingredient and brand, plus the citation format. It covers edge cases like unresolved identifiers and graceful degradation, making it self-sufficient for an agent to know exactly what to expect. The tool's complexity is well-matched by the description's detail.

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

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

Both parameters (`type` and `value`) are already fully documented in the input schema with enums and examples, including accepted input formats for company and drug. The description reinforces this by repeating the accepted input types, but it adds no new parameter-specific meaning beyond the schema. With 100% schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly states the tool's function: resolving user-spoken names to canonical/official identifiers. It provides multiple example queries, lists supported entity types (company, drug), and specifies the kinds of IDs returned (CIK, ticker, LEI, FIGI, RxCUI). It distinguishes itself by noting that other tools require these identifiers as input and instructs to 'Use FIRST whenever you have a name but need an ID.'

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

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

The description gives explicit guidance to use this tool first when transitioning from a name to an ID, and notes that it substitutes for 2-3 manual lookups. However, it does not explicitly name sibling alternatives such as entity_profile or define when not to use it, so it falls 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?

Annotations already declare readOnlyHint, idempotentHint, etc. Beyond that, the description adds behavioral context: it probes each entity using ai_visibility_check, ranks by score, and returns a ranked list. 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?

Three sentences with no wasted words. The first sentence states core function, the second gives a usage example, and the third describes output. Well-structured and efficient.

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

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

With no output schema, the description appropriately describes the output format (ranked list with score, confidence, signal density). Combined with high schema coverage, it provides complete guidance for an agent.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the 'entities' array order (first is subject) and the role of 'context' for disambiguation. This provides meaning beyond the schema descriptions.

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

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

The description clearly states the tool compares AI visibility across multiple entities, ranks them, and surfaces the most/least recognized. It uses specific verbs and distinguishes from sibling tools like ai_visibility_check (single entity) and compare_entities (generic).

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 is useful for competitive AI-marketing audits and provides an example question, making the context clear. It does not explicitly state when not to use it, but the purpose is well-defined.

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

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

Annotations (readOnlyHint, idempotentHint, destructiveHint) already indicate safety. The description adds valuable behavioral details: fans out across deps.dev and bundlephobia, partial failures degrade gracefully, and bundlephobia's first measurement can take 5-30s. No contradiction with annotations.

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

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

The description is a single paragraph that front-loads the purpose and usage, then adds behavioral details. It is concise but could be slightly more structured (e.g., bullet points for return fields). Still effective and not verbose.

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

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

Given the composite nature and lack of output schema, the description thoroughly explains return values (summary block, per-advisory detail, links, recent alternatives) and handles edge cases like partial failures and initial latency. Complete for an agent to decide invocation.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds minor clarifications: scoped packages accepted for 'package', default version behavior for 'version'. This adds value beyond the schema.

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

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

The description clearly states this is a composite check for npm packages covering license, advisories, version history, and bundle size. It specifies 'scan_dependency' as a single-call solution, distinguishing it from sibling tools that are unrelated (e.g., bet_research, deep_research).

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

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

Explicit usage guidance is provided: 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me".' It also notes ecosystem limitations (NPM only, with alternatives for other ecosystems).

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

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

Beyond annotations (readOnlyHint, idempotentHint), the description adds critical behavioral details: embedding model (BGE-base-en), chunking strategy (500-char overlapping windows), similarity measure (cosine), character limit (200K chars with truncation flagging), and that passages include character offsets for verification.

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 slightly verbose but each sentence serves a purpose. It is front-loaded with the core purpose and usage, then dives into technical details. Could be slightly more concise, but overall 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?

Given the tool's complexity (semantic search with chunking), no output schema, and rich annotations, the description is highly complete. It explains return values (top-N passages with offsets and scores), algorithm details, and limitations (truncation). No missing context for an agent to use the tool correctly.

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

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

Schema description coverage is 100%, so baseline is 3. The description provides some extra value (e.g., example queries, max length for text), but it largely reiterates information already present in the schema. No significant additional semantics beyond what the schema offers.

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 semantic search inside a fetched record, using specific verbs and resource identification. It distinguishes from sibling tools like ask_pipeworx_grounded by explaining the pairing and use case for large records.

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

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

Explicit guidance is given on when to use this tool: 'Use when the record is too big to cram into the prompt.' It also mentions pairing with ask_pipeworx_grounded. However, it doesn't explicitly state when not to use it or provide exclusion criteria.

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

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

The description adds substantial behavioral context beyond annotations: OAuth requirement, return of subscription ID, delivery channel specifics (email templates, SMS cap and verification, webhook signing and auto-disable). However, the idempotentHint: true annotation is potentially contradicted by the implied creation of a new subscription each call, lowering transparency slightly.

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. It uses examples and lists constraints, but could be slightly more concise or broken into bullet points for easier parsing.

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?

While the description covers many aspects, it lacks full detail on the return value (only mentions subscription ID, but webhook delivery also returns a secret) and does not address error conditions or rate limits beyond the SMS cap. Missing output schema places more burden on the description.

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 extensive meaning: explains type options with examples, details params for each type, and elaborates on delivery channel constraints (verification, caps, signing). This provides significant value beyond the raw 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 'Create a proactive monitoring subscription to a live-data event stream', specifying the verb and resource. It distinguishes from sibling tools like list_subscriptions, unsubscribe, and recent_alerts by focusing on creation of new subscriptions.

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

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

The description provides context on when to use (to monitor live-data events) and includes an exclusion: 'anonymous + BYO cannot persist subscriptions'. It offers guidance on types and delivery channels, but does not explicitly compare to all alternative tools for every scenario.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds context about what the tool returns (example questions with tool+argument shapes) and that it draws from a live catalog, which is useful 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 well-structured and front-loaded with the canonical questions. All sentences contribute meaningfully, though it could be slightly more concise.

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

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

With no output schema, the description fully explains what the tool returns (category-bucketed example questions with exact tool+argument shapes). It covers all necessary aspects for a simple tool with one optional parameter.

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

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

Schema coverage is 100% with a description for the topic parameter. The description adds examples (e.g., 'finance', 'pharma') and explains the effect of omitting vs. using the parameter, adding 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 identifies the tool as the onboarding entry point, stating its purpose to suggest questions and show what Pipeworx can do. It distinguishes itself from sibling tools like ask_pipeworx by focusing on suggestions rather than direct answers.

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

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

Explicitly says 'Use this FIRST when you do not yet know what Pipeworx can do for you', providing clear when-to-use guidance. Also explains how to use the optional topic parameter to focus on specific areas.

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

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

The description adds significant behavioral context beyond annotations: it clarifies ownership enforcement, that the operation deactivates rather than deletes, and that historical data remains accessible. This aligns with annotations (readOnlyHint=false, destructiveHint=false, idempotentHint=true) and provides a complete picture of the tool's effects.

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

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

The description is three sentences long, each serving a distinct purpose: action, ownership constraint, and behavioral detail. It is front-loaded with the core function and contains no unnecessary words.

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

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

For a simple, single-parameter mutation tool with adequate annotations, the description covers all essential aspects: what it does, who can use it, the nature of the change (deactivation), and the impact on historical data. No additional content is needed.

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

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

The input schema has 100% coverage with a single required parameter 'id' described as 'Subscription id (uuid) returned by subscribe.' The description adds minimal value beyond this ('by id'), so the baseline score of 3 is appropriate.

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

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

The description clearly states 'Cancel a subscription by id,' matching the tool name and title. It further specifies ownership enforcement and the distinction between deactivation and deletion, which differentiates it from sibling tools like 'subscribe' and 'list_subscriptions.'

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

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

The description explicitly states that ownership is enforced ('you can only cancel your own subscriptions'), providing clear usage context. It also explains the behavioral nuance (deactivation vs. deletion) and the availability of historical events via recent_alerts. However, it does not explicitly list alternatives or when not to use 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?

The description adds significant behavioral context beyond the read-only/idempotent annotations. It explains that 'could_not_verify' means the check did not happen and must not be interpreted as evidence, distinguishes it from 'unsupported', and discloses the routing logic between the structured and grounded pipelines. It also notes that the tool returns a verdict, citation, and reasoning, and warns about verification_error details.

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

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

The description is long but information-dense, front-loaded with trigger phrases and organized with a clear flow: purpose, usage, routing, return values, and warnings. Every sentence contributes necessary detail, particularly the 'IMPORTANT for callers' note. It could be slightly trimmed, but the length is justified by 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?

With no output schema, the description fully carries the burden of explaining return values (verdict list, citation, reasoning), error semantics (could_not_verify vs unsupported), and pipeline routing. It also mentions the fast path math and the scope of sources covered. This is a complete and actionable description for an agent.

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

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

The input schema already provides detailed descriptions for both parameters (e.g., tolerance_pct semantics, default, and range). The tool description adds little new parameter-specific meaning beyond what the schema states, although it does reinforce usage for hallucination detection. Since schema coverage is 100%, the baseline of 3 is appropriate.

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

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

The description clearly identifies the tool as a natural-language claim verifier with specific verbs like 'verify', 'fact check', and 'confirm or refute'. It explains the resource (facts/claims) and the output (structured verdicts), and distinguishes itself from general Q&A tools by detailing its claim-specific pipeline and verdict types. The phrase 'Replaces 4–6 sequential calls' further clarifies its consolidated 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 gives explicit guidance: 'Use whenever the agent needs to check whether something a user said is factually correct.' It also differentiates between company-financial claims (SEC EDGAR fast path) and other factual claims (grounded pipeline), which helps decide what to expect. It stops short of explicitly naming alternative sibling tools or when not to use the tool, but the context is strong enough.

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