Arcgis Dublinoh

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

Annotations already declare readOnlyHint/idempotentHint/destructiveHint=false, and the description adds valuable behavioral context beyond that: default free model, BYO API key cost implication ('you pay Anthropic directly'), and the detailed return structure (per-model score, confidence, signals, raw_response + combined view). This significantly enhances transparency without contradicting annotations.

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

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

The description is four tightly constructed sentences, each earning its place: core purpose/action, default + cost behavior, return format, and use cases. It is front-loaded and contains no filler, redundancy, or vague phrasing.

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

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

For a read-only, idempotent probing tool with 4 params (1 required) and no output schema, the description covers all necessary context: what the tool does, default behavior, optional key handling, output shape, and practical scenarios. An agent can correctly invoke it with this information alone.

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 all 4 parameters, so baseline is 3. The description adds extra meaning by showing the default model value ('workers-ai'), clarifying that `_apiKey` is only needed when 'anthropic' is in models, and implying a relationship between `models` and `_apiKey`. This goes beyond the field-level descriptions.

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

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

Description uses a specific verb+resource: 'Probe one or more LLMs' and 'score visibility (0-100) per model'. It clearly distinguishes what the tool does from siblings by stating the default model (Workers AI Llama-3.3-70b) and optional Anthropic probing, plus enumerating concrete use cases like AI-marketing audits and pre-launch brand checks. This is specific and actionable.

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

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

The description provides explicit usage guidance with 'Useful for AI-marketing audits, pre-launch brand checks, competitive monitoring' and clearly explains when to pass `_apiKey` (to also probe Anthropic). It does not explicitly state when not to use this tool or name alternative sibling tools, so it stops short of a full 5.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive behavior. The description supplements this by explaining the routing mechanism, citation URIs, tier availability, and 'one fast call' performance. It doesn't contradict annotations and adds meaningful context beyond the structured hints.

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-loaded and organized: it starts with a strong directive, lists covered data categories, then explains behavior, escalation paths, and examples. Some redundancy exists in the trigger phrases ('what is', 'look up', etc.) and repeated emphasis, but every major point is delivered efficiently for the tool's complexity.

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

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

For a routing tool with a single question parameter and no output schema, the description captures the essential context: what it does, which data domains it covers, when to use it over alternatives, how to use it, and what kind of result to expect (structured answer with citations). It also handles the open-world nature and sibling differentiation thoroughly.

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: every parameter is documented as an alias for 'question', and the descriptions are clear. The description adds example queries but no additional parameter-level semantics beyond what the schema already provides. This matches the schema-heavy baseline.

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

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

The description clearly states what the tool does: it routes questions to one of 5,462 verified tools and returns structured answers with citations. It distinguishes itself from siblings by explicitly naming ask_pipeworx_grounded and deep_research as alternatives. The scope is specific and backed by domain examples.

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?

Highly explicit usage guidance: 'START HERE for most questions', 'Use whenever the user asks...', and clear escalation paths ('Step up only when needed') with specific named alternatives. It also contrasts with web search and gives concrete example queries, leaving no ambiguity about when to invoke this tool.

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

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

The description discloses the beta status, that no candidate is currently active, and that it is a full working router rather than a fallback stub. This adds behavioral nuance beyond the readOnly and idempotent annotations, including experimental changes and current parity with the stable version.

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 providing essential information about the tool's identity, current status, and usage guidance. While it is dense, the length is justified by the need to explain beta behavior and alternatives, and it is logically structured from definition to usage.

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

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

Although there is no output schema, the description says the response shape matches ask_pipeworx, providing continuity. It covers the experimental status and usage context sufficiently for a variant tool, though it relies on prior knowledge of the sibling tool to fully understand the routing behavior.

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

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

The input schema already documents the question parameter and all aliases with 100% coverage. The description only references the same arguments as ask_pipeworx without adding new semantic detail, so it does not exceed the schema baseline.

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

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

The description clearly states it is a beta version of ask_pipeworx, an identical universal router with the same 5,462 tools and response shape. It distinguishes itself from the stable ask_pipeworx by highlighting its experimental routing improvements, making the purpose specific and unambiguous.

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

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

The description explicitly says to use it exactly like ask_pipeworx when the newest routing is desired, and notes that results are compared against the stable router to decide merges. This provides clear when-to-use guidance and implicitly identifies ask_pipeworx as the alternative stable option.

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 readOnly/openWorld/idempotent annotations, the description discloses crucial behavioral traits: it 'EXTRACTS the answer using ONLY what the tool result contains,' returns an explicit refusal with specific reasons (not_in_source, no_tool_match, etc.) when data doesn't answer, and provides a structured success response with evidence and confidence. This adds significant context and aligns with annotations (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 three sentences long, front-loaded with the purpose, then the mechanism, then usage guidance. Every sentence earns its place; there is no filler or repetition. The return format is compactly listed inline, and the refusal reasons are enumerated clearly. It is both concise and well-structured.

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

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

The description covers the full behavior needed for selection and use: purpose, mechanism, use cases, cost trade-off, alternatives, and the exact return shape including refusal reasons. Since there is no output schema, disclosing the return structure in the description is essential, and it does so completely. Annotations and schema are fully leveraged, leaving no significant gaps.

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

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

Schema description coverage is 100% for all six parameters, all of which are documented aliases for the main question parameter. The tool description does not add parameter-specific detail, but with the schema fully covering semantics, the baseline of 3 is appropriate. The description's mention of routing and fetching does not enrich parameter understanding beyond the schema.

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

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

The description opens with a specific and distinctive purpose: 'Hallucination-resistant answer mode for high-stakes reads.' It clearly states the tool's function—same routing as ask_pipeworx but with extraction restricted to the tool result—and explicitly distinguishes it from the sibling tool ask_pipeworx by cost and use case.

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

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

The description provides explicit when-to-use guidance: 'Use whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts' with concrete examples (financial verdicts, legal claims, medical lookups). It also names the alternative: 'prefer ask_pipeworx for casual lookups' and explains the trade-off (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?

The annotations already declare readOnly, openWorld, idempotent, and non-destructive. The description goes far beyond that, detailing fan-out behavior, response shapes (result.market, result.analysis, result.evidence), the resolver contract (market_match_confidence, alternatives), safety mechanisms (low-confidence short-circuit, closed-market handling), and resolution-rule risk (cancellation_rule). This extensive disclosure provides deep insight into the tool's internal behavior and failure modes, far exceeding the annotations.

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

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

The description is long but well-structured with clear labels (CLASSIFIERS, FAN-OUT EXAMPLES, RESPONSE SHAPES, etc.). It front-loads the core purpose in the first sentence and then uses sections to convey complex behavioral details. Every section adds meaningful information about safety, output, or resolution rules. While verbose, the structure makes it scannable and 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?

Given that the tool has no output schema, the description effectively documents the return shape (result.market, result.analysis, result.evidence) and key fields. It also covers edge cases: low-confidence matches, closed/dead markets, illiquid wide spreads, resolution-rule risk, and news fallback handling. This is a complete picture for an agent to invoke the tool and interpret results 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 for its three parameters, so the baseline is 3. The description adds some context about the 'market' parameter by explaining it accepts a slug, URL, or question text and how it gets resolved, but this largely duplicates the schema's description. It does not add new semantic details for 'depth' or 'include_raw' beyond what's already in the schema, though it does illustrate fan-out behavior which indirectly relates to 'depth'.

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

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

The description opens with a clear, specific statement: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It names the resource (Polymarket bet), the verb (research), and the data source (Pipeworx). It also provides concrete usage intent ('should I bet on X', 'what does the data say about Y', 'is there edge in Z'), and the classification/fan-out examples distinguish it from sibling tools like polymarket_edges or ask_pipeworx by emphasizing a comprehensive, one-call research package.

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

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

The description explicitly states when to use the tool: 'Use for ...'. It also gives examples of the input types (slug, URL, question text). However, it does not explicitly mention when NOT to use it or name alternative tools, so it lacks explicit exclusion criteria. The guidance is clear and actionable, but not complete with respect to 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 read-only and idempotent, but the description goes much further by revealing data sources (SEC EDGAR/XBRL for companies, FAERS for drugs), handling of off-calendar fiscal years, sorting by primary metric, and output citation URIs. These behaviors add significant context beyond the structured annotation hints.

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

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

The description is dense but every clause contributes: usage triggers, preference rule, data-source details, fiscal-year edge case, sorting behavior, and return format. It is front-loaded with the most important instruction and does not repeat schema fields verbatim, though slightly long for a single paragraph.

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 specifies return contents (paired data, citation URIs) and sorting behavior, and even addresses edge cases like off-calendar fiscal years. For a two-parameter tool with rich schema coverage, this is fully complete for an agent to select and invoke correctly.

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

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

Schema coverage is 100% with parameter descriptions, providing a baseline of 3. The description adds concrete semantics by explaining what each enum value retrieves (latest 10-K financials vs. FAERS counts) and gives real examples for values (['AAPL','MSFT'], ['ozempic','mounjaro']), which helps agents format parameters correctly.

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

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

The description opens with explicit trigger phrases and clearly names the action (side-by-side comparison) and resource (2–5 companies or drugs in ONE parallel call). It is distinct from sibling tools like entity_profile and search tools, clearly differentiating itself as the comparison tool.

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

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

It explicitly lists user intents ('Compare X and Y', 'X vs Y', 'which is bigger', 'rank these companies') and states 'ALWAYS PREFER over sequential single-pack lookups when comparing entities.' It also provides type-specific guidance for company vs. drug, making when-to-use completely clear.

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

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

Beyond the provided annotations (readOnly, openWorld, idempotent), the description adds substantial context: account requirements, paid tier for 'thorough', parallel decomposition, the structure of the findings packet (verbatim evidence, confidence, source, fetched_at, citations), explicit gaps[] for unanswered facets, second-hop iteration behavior, contradictions[] scanning, and expected latency. This fully discloses the tool's behavioral profile without contradicting annotations.

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

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

The description is long but every sentence contributes essential information: account prerequisites, tool differentiators, output structure, behavioral nuances, and performance expectations. There is no redundancy or filler; the front-loading of the account requirement is practical, and the structured enumeration of features is easy to scan.

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

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

Given the tool's complexity, strong annotations, fully documented parameters, and absence of an output schema, the description compensates by detailing the return format, gaps, contradictions, citation resolvability, excerpting behavior, and timing. It provides enough context for an agent to select and invoke the tool correctly, and to interpret results appropriately.

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 100% (question and depth with enum descriptions). The description adds meaningful semantics by explaining what each depth value actually does (quick=3 facets, standard=5 with gap recovery, thorough=8 with iterative hop), notes the paid requirement for 'thorough', and clarifies that broad/multi-part questions are intended. This goes beyond the schema's basic descriptions.

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

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

The description clearly states the tool performs 'grounded multi-source research' across Pipeworx's 1419 structured data sources, with a specific verb and resource. It explicitly distinguishes itself from open-web search and sibling tools like ask_pipeworx, making its unique role unambiguous.

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

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

It gives explicit when-to-use guidance: 'Best for broad/multi-part questions over structured data', and names alternatives with specific conditions: 'For a single lookup use ask_pipeworx', 'For BREAKING or colloquial CURRENT-NEWS... prefer ask_pipeworx', and 'If you are not signed in, use ask_pipeworx instead'. This leaves no ambiguity about tool selection.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable context about return behavior: it returns top-N tools with full schemas and curated examples, ready to call directly without a second lookup. No side effects are mentioned, but the annotations cover 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?

The description is efficiently front-loaded with the core purpose and usage, then adds return details. The list of domains is somewhat verbose but informative. Every sentence contributes to understanding, though the domain list could be shortened without losing essential meaning.

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

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

For a read-only discovery tool with no output schema, the description covers the key aspects: what it does, when to use it, what it returns, and that results are directly callable. It doesn't address error cases or rate limits, but the annotations and schema provide adequate context for the tool's simplicity.

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

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

Schema description coverage is 100%, so the baseline is 3. The description reinforces the query semantics ('describing the data or task') and gives domain examples, but the schema already provides thorough descriptions for query, aliases, and limit, so the description adds marginal value beyond the schema.

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

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

The description opens with 'Find tools by describing the data or task,' a specific verb+resource statement. It clearly distinguishes itself from the sibling tools by being the meta-tool for discovering other tools, listing covered domains and contrasting with tools like search_datasets or validate_claim.

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

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

The description gives explicit when-to-use guidance: 'Use when you need to browse, search, look up, or discover what tools exist' and 'Call this FIRST when you have many tools available.' It lacks explicit when-not-to-use or named alternatives, but the 'FIRST' directive provides clear placement in the workflow.

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

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

Beyond the readOnly/idempotent annotations, the description reveals fan-out across SEC EDGAR, XBRL, USPTO, news, GLEIF, discloses the patents endpoint sunset with soft-fail behavior, and specifies GDELT→GNews fallback and LATEST 10-K fields. This provides rich behavioral context without contradicting annotations.

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

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

The description is longer than average but front-loaded with example queries and a clear directive, and the return list is organized with semicolons. It is dense and structured; slight redundancy ('full cross-source profile' vs. the fan-out list) prevents a 5.

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

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

With no output schema, the description enumerates the returned fields (cik, company_name, recent_filings with URIs, fundamentals, patents, news, LEI) and caveats (soft-fail, fallback). It also addresses input prerequisites, making it complete for an agent to invoke correctly.

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

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

The input schema already covers both parameters comprehensively with examples (ticker, zero-padded CIK) and the name limitation, so baseline is 3. The description largely restates this guidance and does not add significant new parameter-level meaning.

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

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

Description opens with concrete user phrasings then states 'full cross-source profile of a US public company in ONE parallel call', making the action and target unambiguous. It distinguishes itself from single-pack lookups and by explicitly addressing name-based input.

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

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

Provides explicit when-to-use guidance ('ALWAYS PREFER...when the user asks for a holistic view') and an exclusion: names are not supported; use resolve_entity first. This gives clear decision logic versus sibling tools.

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

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

The annotations already declare destructiveHint=true and idempotentHint=true, covering the destructive and repeatable nature. The description adds no new behavioral details beyond those annotations, though it does specify the target is a previously stored memory. With annotations present, the added value is limited, so a mid-range score is appropriate.

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

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

The description is two concise sentences, front-loaded with the action and followed by targeted usage guidance. Every word earns its place, and the structure is clear 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?

For a single-parameter destructive tool with full schema coverage and clear annotations, the description is complete. It provides both the purpose and usage context, and the lack of an output schema is acceptable for a delete operation.

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 fully describes the only parameter 'key' as 'Memory key to delete', covering 100% of the schema. The description does not add additional semantic value beyond repeating the key concept, so the baseline score of 3 is applied.

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

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

The description clearly states the tool deletes a previously stored memory by key, using a specific verb and resource. It distinguishes itself from the sibling tools 'remember' and 'recall' by explicitly framing the delete operation, leaving no ambiguity about its function.

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

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

The description provides explicit usage conditions: when context is stale, the task is done, or sensitive data should be cleared. It also suggests pairing with 'remember' and 'recall', effectively guiding the agent on when to use this tool versus its siblings.

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

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

Annotations declare readOnly, openWorld, idempotent, and non-destructive hints. The description goes beyond annotations by explaining the process: fetches the page, extracts title/description/key links, and emits markdown. It also discloses the output as a single text blob ready for site-root placement.

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 adding value: purpose, process, output format, and use cases. It is front-loaded with the core function and contains no fluff.

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

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

The tool is simple (2 params, no output schema) and the description covers purpose, behavior, output format, and usage scenarios comprehensively. Annotations complement with safety hints, making the description sufficient for an agent to use correctly.

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

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

Schema description coverage is 100%, with both 'url' and 'max_links' clearly documented. The description does not add parameter-specific detail beyond the schema, so the 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 states a specific verb ('generate') and resource ('a production-ready llms.txt file for any URL'), with clear output format and example AI crawlers. It distinguishes itself from sibling tools like ai_visibility_check by focusing on file generation rather than visibility checks.

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

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

Provides three concrete use cases (client site indexing, own project drafting, competitor auditing) with clear context. Lacks explicit when-not-to-use guidance or named alternative tools, but the usage scenarios are strong.

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

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

Annotations already declare readOnlyHint and idempotentHint, so safety is covered. The description adds value by specifying the precise schema components returned (fields, geometry, count, capabilities), which sets concrete expectations beyond the generic annotation hints.

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

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

The description is a single, well-structured sentence that front-loads the purpose and uses a concise list for outputs. Every part earns its place, and there is no redundancy or filler.

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

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

With one well-documented parameter and no output schema, the description compensates by clearly listing all expected return elements. Given the tool's simplicity and the read-only annotations, this is fully 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 description for `url` is complete and includes an example, giving 100% coverage. The tool description only repeats the notion of 'by url' without adding new parameter nuances, so it carries no additional semantic weight.

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

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

The description uses a specific action ('Get') and a clear resource ('ArcGIS Feature/Map Service layer's schema'), enumerating exactly what is returned (fields, geometry type, record count, capabilities). This distinguishes it from sibling tools like query_layer, which would focus on data retrieval rather than metadata/schema.

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

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

The description clearly implies this tool is for retrieving schema metadata, giving the agent context on when to use it. However, it explicitly mentions no alternatives or exclusionary criteria, so it stops short of full usage guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is known. The description adds valuable behavioral context by specifying the return fields and the default filter to active subscriptions (via 'active subscriptions' and the include_inactive parameter), going 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?

Two sentences, front-loaded with the core purpose and return fields, followed by a clear usage scenario. No filler or redundancy; every sentence earns its place.

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

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

Given the simple tool signature (one optional parameter, no output schema), rich annotations, and clear usage guidance, the description is complete for an agent to select and invoke correctly. The return fields are enumerated, and the default behavior is implied and supported by the parameter schema.

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

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

The input schema already fully describes the only parameter (include_inactive) with 100% coverage, so the description does not need to add parameter details. The description adds no extra semantic meaning beyond the schema, so 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 uses the specific verb 'List' with the resource 'subscriptions', clearly distinguishing it from sibling tools like subscribe and unsubscribe. It further specifies scope ('the caller's active subscriptions') and lists the return fields, making the tool's 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 gives explicit usage context: 'Use this to review what you're monitoring before adding more or to find an id to cancel.' This clearly indicates when to use the tool, though it doesn't explicitly contrast with alternative tools like unsubscribe. It still provides solid guidance for an agent.

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 annotations are false, so the description carries the full transparency burden. It discloses that filing without an account returns a claim_token, how to use it to check resolution status, rate limiting (5 per identifier per day), cost ('Free; doesn't count against your tool-call quota'), and that the team reads digests daily. This is rich behavioral detail beyond what annotations provide.

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

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

The description is longer than two sentences but every sentence earns its place: it covers purpose, use cases, exclusions, token behavior, rate limits, and quota impact. It is front-loaded with a clear purpose statement and remains structured and scannable.

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

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

Despite the absence of an output schema, the description explains what a call returns (claim_token when no account) and how to follow up. It also covers scope, exclusions, and practical constraints (rate limit, quota), making the tool adequately comprehensible for an agent to use correctly.

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

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

Schema description coverage is 100%, but the tool description adds value by explaining the claim_token workflow ('pass it back later as pipeworx_feedback({claim_token:...})') and advising on message content. This goes beyond the schema's parameter descriptions, elevating it above the baseline of 3.

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

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

The description clearly states the tool's function: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It also enumerates specific feedback categories (bug, feature/data_gap, praise), making it distinct from sibling tools like ask_pipeworx or discover_tools.

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

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

The description provides explicit 'Use when' conditions for each feedback type and gives a clear exclusion rule: tools from other MCP servers should not be reported here. It also offers content guidance (describe in Pipeworx tool terms, don't paste end-user prompt), which helps agents decide when and how to invoke it.

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

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

Beyond annotations (readOnly, openWorld, idempotent, non-destructive), the description adds valuable behavioral context: it is 'derived from CF analytics-engine', 'no PII, just (pack, tool, count)', and 'Cached 5min-1h depending on window'. This discloses aggregation, privacy, and caching behavior, significantly enriching the annotation-only picture.

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

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

The description is concise, front-loaded with the core statement, then structured into three bullet-point use cases and trailing notes on data source and caching. Every sentence contributes value, and the length is appropriate.

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

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

Despite having no output schema, the description explains the output shape ('(pack, tool, count)'), the time windows, the data source, and caching. It is complete for a simple read-only 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 description coverage is 100%, and the schema already explains the window parameter with '24h (default) | 7d | 30d. Shorter windows surface what's hot right now; longer windows show steady-state demand.' The tool description reiterates the windows but does not add additional parameter semantics beyond what the schema already provides. 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 what the tool does: 'Returns the top tools, top packs, and total call volume over a recent window'. It also establishes a unique niche by starting with 'What other AI agents are calling on Pipeworx right now', distinguishing it from sibling tools like discover_tools.

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

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

The description provides three explicit 'Useful for' scenarios, giving clear context on when to use the tool versus alternatives. It does not explicitly mention when not to use it, but the guidance is concrete and sufficient for agent decision-making.

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

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

Annotations already indicate readOnly and idempotent behavior, but the description adds rich context: thresholds (3pp deviation, Jaccard ≥0.30, >20% placeholder), the fill-check logic with realizable_edge_pp ≤ 0, and response field details. It even warns 'do not trade it' when the edge is not realizable, going 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 long but well-structured with labeled sections (SEMANTIC ANCHOR, PARTITION FILTER, FILL CHECK) and front-loaded purpose. Every sentence adds necessary detail for a complex tool, though it could be more scannable with bullet points. Slight density prevents a 5.

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

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

Given the tool's complexity and the absence of an output schema, the description fully covers response shapes, edge cases, thresholds, and a pointer to a related tool for custom sizing. It leaves no major ambiguity about invocation, behavior, or result interpretation.

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

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

Schema shows 100% coverage with detailed parameter descriptions, and the description further elaborates: 'event' is an event slug with examples and behavior, 'topic' is a seed question for cross-event scanning. It clarifies that no args are valid and explains the mode-specific outputs, adding 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 opens with a specific verb+resource+mechanism: 'Find arbitrage opportunities on Polymarket via monotonicity violations + partition-sum checks.' It clearly defines three distinct invocation modes (no args, event, topic) and distinguishes this tool from siblings like polymarket_fill_risk by focusing on opportunity detection rather than fill pricing.

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

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

Explicit when-to-use guidance is provided: 'Call with NO args for a trending_scan... pass event for the strongest per-event partition_check, or topic for a themed cross-event scan.' It also names an alternative tool for custom sizing: 'For custom sizing use polymarket_fill_risk,' which helps an agent choose between related tools.

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

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

The description discloses extensive behavioral traits beyond the annotations: model families, edge calculation methodology, slippage handling, the 24h-move warning, partition kelly behavior, Fed bet exclusion rationale, cache behavior, and diagnostics. Annotations only declare read-only/idempotent, and the description goes far beyond that to explain exactly what happens internally and why.

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

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

The description is long but every sentence carries substantive detail. It is front-loaded with purpose and structured with section labels (model families, response top-level, tradeable-edge knobs, diagnostics). However, it is a dense wall of text that could benefit from bullet points or clearer paragraph breaks. Still, it is not redundant or wasteful.

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

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

Given no output schema and 9 parameters, the description fully compensates: it explains the response segmentation (by_segment), diagnostics, filtering behavior, and caveats like Fed bets and the 24h-move warning. It leaves no significant gap in understanding what the tool returns or how it behaves.

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

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

Schema coverage is 100%, so the baseline is 3. However, the description adds meaningful context beyond the schema descriptions: it explains the tradeable-edge knobs (min_liquidity, max_spread_pp), why min_kelly does not filter partition arbs and how min_partition_leg_kelly applies, and the slippage_pp rationale. This adds real value over 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 opening sentence clearly states the tool's function: 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price.' This is a specific verb+resource+outcome that distinguishes it from siblings like polymarket_arbitrage or polymarket_edge_tracker. The scope is explicit: it surfaces opportunities without paging hundreds of markets.

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

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

The description includes a clear use case: 'Built for "what should I bet on today" — agents discover opportunities without paging hundreds of markets.' It implies when to use this tool for discovery vs. deeper analysis, though it does not explicitly name alternatives or state when not to use it. The context is strong but lacks explicit exclusions.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, but the description substantially expands on behavior: it details the exact response structure (tracked, expired, snapshot_dates), how decay is computed (on absolute value, daily closes), what snapshot gaps mean, and the 60-day TTL bound. This goes far beyond annotations with no contradictions.

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

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

The description is relatively long but well-structured with labeled sections (Args, RESPONSE, LIMITS) and a front-loaded purpose statement. Every sentence contributes operational detail, especially necessary because there is no output schema. The density is justified by the tool's richness.

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 must fully define the return objects and interpretation, which it does thoroughly: tracked entries include full time-series, trend, decay_pp_per_day; expired entries include lifespan_days; snapshot_dates clarify data availability. It also explains limitations like TTL and snapshot gaps, making it complete for selection and 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%, and the description mostly restates the same parameter semantics (defaults, max value, window families). It adds contextual meaning for 'window' as 'snapshot family' and clarifies max 30 days, but omits the schema's minimum clamp. Since schema already defines parameters well, the description provides marginal added value.

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: 'Edge persistence and decay telemetry' answering 'how long has this edge existed and is it shrinking?' This specifies a verb (tracks/answers), resource (edges from daily polymarket_edges snapshots), and temporal scope, distinguishing it from sibling tools like 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?

The description gives clear context for when to use the tool — when you need to assess edge age and persistence, warning that a 3-week-old wide edge is fundamentally different from a fresh one. It does not explicitly name alternatives or when-not-to-use, but the built-from-polymarket_edges phrasing makes the relationship to sibling tools obvious.

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

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

Annotations declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so there is no contradiction. The description adds genuine behavioral detail: mode-dependent ladder walking, verdict categories (clean|degraded|cannot_fill), basket per-leg detail, thin_legs[], and forced_directional_risk — all beyond what the annotations convey.

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

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

Though long, the description is densely packed and every sentence earns its place. It is front-loaded with the core purpose and uses labeled SINGLE-MARKET and BASKET sections to organize mode-specific behavior, making it easy to scan.

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

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

For a high-complexity tool with no output schema, the description enumerates all important return values (top_of_book, vwap_fill_price, slippage_pp, shares_filled, max_fillable_usd), per-leg detail, theoretical_sum vs realizable_sum, capture_ratio, and the risk leg list. It covers both modes, defaults, and error-prone execution details.

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, but the description adds substantial semantic value: 'size_usd (default 1000 — max spend on buys, target proceeds on sells)', basket size interpreted as settlement notional, and basket side default 'auto — sell if partition sum > 1, buy if < 1'. This makes all four parameters fully meaningful in context.

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 opening sentence names a specific function: 'Realizable-vs-theoretical edge check against live CLOB order-book depth,' with a clear verb ('check') and resource (Polymarket CLOB order book). The description also distinguishes this from siblings by explicitly positioning it as the pre-trade risk check for polymarket_arbitrage and polymarket_edges signals.

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

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

It states exactly when to apply: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500.' It also explains the failure mode (theoretical overround not capturable, partial basket fills convert an arb to an unhedged directional position), giving clear context for using it over alternatives.

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

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

The annotations already declare readOnlyHint, openWorldHint, and idempotentHint, but the description adds extensive behavioral detail: it defines compatibility_warning with two distinct trigger conditions, explains temporal_alignment, exposes skipped_cross_type/subtype counters, and notes that pre-mapped ≠ tradeable. This goes far beyond the structured annotations and provides a rich behavioral model.

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

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

Although lengthy, the description is well-structured and front-loaded: the first sentence states the core purpose, then it organizes modes, response fields, safety fields, and caveats in a logical flow. Every sentence adds value—there is no filler or repetition of schema/annotation 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?

With no output schema and a moderately complex tool, the description fully compensates: it explains the response shape (leg-by-leg prices, spread[].top_spreads_pp, compatibility_warning, temporal_alignment, skip counters), covers edge cases (matched_pairs:0 scenarios), and even advises on real-world tradability. It is complete for an agent to invoke and interpret correctly.

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

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

Schema coverage is 100% with each parameter having its own description. The description adds meaning by explaining the 10 topic shortcuts, how explicit ticker/slug overrides the topic-mapped side, and how the two modes interact. It also adds interpretive guidance about what the parameters mean in practice, exceeding the schema's raw definitions.

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

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

The description opens with a specific verb and resource: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' This clearly distinguishes it from siblings like polymarket_arbitrage by naming both venues and the 'same resolving question' scope, and the rest of the description reinforces this unique purpose.

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 lays out two usage modes (topic vs explicit kalshi_event_ticker + polymarket_event_slug) and when each is appropriate. It also warns that most pre-mapped topics return compatibility_warning today, setting realistic expectations. However, it does not explicitly name alternative tools or state when NOT to use this tool versus a sibling 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, openWorldHint, idempotentHint, and destructiveHint=false. The description adds useful behavioral context beyond this: it states that the tool 'Returns attribute rows (and geometry)' and offers a practical usage tip. No contradictions with annotations are present.

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, front-loaded with the primary purpose, and every sentence contributes either parameter context, return information, or a practical tip. It is concise with zero redundant wording.

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 moderate complexity, the combination of a fully described schema, comprehensive annotations, and a description that covers return type and usage patterns makes it complete. Even without an output schema, the description adequately explains what the tool returns and how to invoke it.

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

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

The input schema has 100% description coverage for all six parameters, so the baseline is 3. The description adds extra semantic value by labeling the 'where' clause as 'SQL-like' and providing a canonical sampling example (where="1=1" + out_fields="*"), which helps users understand parameter usage beyond the schema definitions.

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

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

The description clearly states the tool's function with a specific verb and resource: 'Query an ArcGIS Feature Service / Map Service layer by its url.' It also references 'from search_datasets', which distinguishes it from sibling tools like layer_info and search_within, 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 implies usage after search_datasets and provides a concrete sampling pattern ('Use where="1=1" + out_fields="*"'), giving clear context. However, it does not explicitly state when not to use it or how it differs from alternative sibling tools like search_within, so it lacks explicit exclusions.

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

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

With annotations already declaring readOnlyHint, idempotentHint, and destructiveHint false, the description adds valuable behavioral context beyond the annotations. It discloses scoping ('Scoped to your identifier (anonymous IP, BYO key hash, or account ID)') and the behavior of listing all keys when the key argument is omitted. This adds clarity about the tool's behavior without contradicting annotations.

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

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

The description is concise and well-structured. It consists of four short sentences, each adding value: the operation and parameter behavior, the use case, scoping, and related tools. There is no redundant or filler 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?

For a simple tool with one optional parameter and no output schema, the description is fairly complete. It covers purpose, usage context, scoping, and relationships to sibling tools. It does not detail return value format or error handling, but this is not critical for basic retrieval. The description is sufficient for an AI agent to select and invoke the tool correctly.

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

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

The input schema already has 100% coverage with a description for the 'key' parameter ('Memory key to retrieve (omit to list all keys)'). The tool description essentially repeats the schema's parameter semantics ('omit the key argument'). While it adds context about 'previously saved via remember', it does not provide substantial extra meaning beyond what the schema already conveys.

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: 'Retrieve a value previously saved via remember, or list all saved keys (omit the key argument).' It uses specific verbs (retrieve, list) and identifies the resource (saved keys). It also distinguishes itself from siblings by naming 'remember' and 'forget' as related tools.

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

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

The description provides explicit when-to-use guidance: 'Use to look up context the agent stored earlier — the user's target ticker, an address, prior research notes — without re-deriving it from scratch.' It mentions related tools ('Pair with remember to save, forget to delete') as alternatives, but does not explicitly state when not to use other lookup tools like search_within or ask_pipeworx.

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 states that setting mark_read:true 'flag[s] returned events read so the next call only shows newer ones,' which implies state modification. This directly contradicts the readOnlyHint:true annotation, which asserts the tool does not modify state. Per rubric, any description-annotation contradiction earns a score of 1.

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

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

The description is a single paragraph of moderate length. It is front-loaded with the main purpose and then expands with return details and usage options. The alternative feed URL is useful but slightly peripheral; still, no sentence is wasted.

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

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

With no output schema, the description compensates by enumerating the fields in each alert (source, citation_uri, raw event payload) and clearly explaining the semantics of mark_read. It does not detail unread_only, but the schema covers that parameter. The overall tool behavior is clear enough for an agent to invoke it correctly.

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

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

Schema already documents all 5 parameters with descriptions (coverage 100%). The description adds semantic nuance—e.g., type example 'sec_8k', ISO timestamp for since, and what mark_read does to future calls—going beyond mere schema labels.

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 opens with a clear verb+object: 'Pull fired events from your subscription feed.' It specifies what the tool returns (alerts with source, citation_uri, raw payload), distinguishing it from sibling tools like list_subscriptions or recent_changes.

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

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

Provides explicit filter options (type, since), mark_read behavior, and notes that 'Polls work fine,' indicating suitability for polling. It also offers an alternative access method (GET registry URL) for scripts/dashboards, but does not name sibling tools as alternatives.

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

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

Annotations already declare read-only/idempotent, but the description adds substantial behavioral detail: fan-out to three sources, GDELT→GNews fallback triggers, USPTO soft-fail due to PatentsView sunset, and return structure (changes[] grouped by source, total_changes, pipeworx:// citation URIs). This goes well beyond annotation coverage.

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

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

The description is dense but information-rich; every clause adds operational detail (sources, fallbacks, date formats, return fields). It is longer than a simple tool warrants but the complexity justifies the length. A bulleted layout could improve scannability, but current prose is tight.

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 covers the return shape (structured changes[] grouped by source + total_changes + citation URIs) and key constraints (since formats, supported type only 'company'). It also mentions the sibling alternative. Some specifics about individual change item fields are missing, but overall it is sufficiently complete for 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?

All 3 parameters have schema descriptions (100% coverage), so baseline is 3. The description adds value by explaining 'since' accepts ISO or relative shorthand with examples ('7d', '30d', '3m', '1y') and recommending '30d' or '1m' for monitoring, plus clarifying 'value' as ticker or zero-padded CIK. This extra guidance justifies a 4.

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

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

The description clearly defines the tool as a change feed for a company over a time window, listing specific data sources (SEC EDGAR, GDELT/GNews, USPTO). It opens with natural-language triggers and explicitly contrasts with entity_profile, making the purpose and scope unmistakable.

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

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

It provides explicit when-to-use context with example queries ('What's new with X') and window normalization. It names entity_profile as the alternative for static profiles and explains fallback behavior (GDELT preferred, GNews on rate-limit/5xx), giving clear decision guidance.

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

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

Annotations already indicate idempotent, non-destructive write behavior, and the description adds scoping and retention details ('scoped by your identifier,' 'anonymous sessions retain memory for 24 hours'). This is useful context beyond annotations, though it could mention overwrite semantics; 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?

Five tightly focused sentences front-load the core purpose, then usage context, then persistence caveats, then companion tools. Every sentence earns its place with no fluff or repetition.

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

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

For a simple two-parameter write tool with no output schema, the description fully covers what to store, when to use it, scoping, retention, and related tools. No critical missing context for an agent to select and invoke it correctly.

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

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

Schema covers both parameters 100% with descriptive examples, so the description adds little beyond naming 'key' and 'value' as generic containers. No additional parameter-level semantics are introduced beyond what the schema already provides.

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

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

Description uses a specific verb ('Save data') and resource ('key-value pair scoped by your identifier'), clearly distinguishing it from siblings like recall and forget. It explicitly frames the tool's job as cross-session or cross-conversation memory storage.

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 when you discover something worth carrying forward' with concrete examples (resolved ticker, target address) and pairs with recall/forget. However, it doesn't articulate when not to use this tool versus other data-related siblings, so it stops short of a 5.

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

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

Annotations already declare read-only/idempotent behavior, but the description adds valuable context: per-type return fields (ticker+CIK+RxCUI+ingredient), citation URI, internal endpoint cascading, and auto-disambiguation. No contradiction with annotations.

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

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

The description is longer than minimal but front-loaded with natural-language examples and organized by supported type. Each sentence earns its place, though it could be tightened.

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

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

With only 2 params and full schema, the description fully covers return values for each type (no output schema), internal behavior, and workflow position ('use first'), making it complete 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?

Input schema has 100% coverage for both params, including per-type examples. The description merely echoes schema content (AAPL, CIK, ozempic) without adding new meaning, so baseline 3 is fair.

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 explicitly states the tool resolves user-spoken names to canonical identifiers, with concrete examples (ticker, CIK, RxCUI) and distinguishes from sibling tools by noting other tools require these IDs as input.

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?

Directly instructs 'Use FIRST whenever you have a name but need an ID,' making the invocation condition explicit. Also notes it replaces 2-3 manual lookups, reinforcing when to choose it over alternatives.

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

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

Annotations already declare readOnly/idempotent behavior, but the description adds meaningful context by explaining the tool probes each entity with ai_visibility_check, ranks by score, and returns specific fields (score, confidence, signal density). This goes beyond what annotations alone convey, 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 three sentences of purposeful, front-loaded content: first states the core action, second explains the mechanism, and third provides the use case and return format. No wasted words, and the structure is easy to scan.

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

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

For a tool with four parameters, full schema coverage, and no output schema, the description adequately explains the return value and typical use case. It does not document edge cases like error conditions or API key requirements for the anthropic model, but those are partially covered by the schema. Overall, it is sufficiently complete for the complexity.

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

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

Schema description coverage is 100%, with all parameters adequately described. The description adds minimal semantic value beyond the schema, mainly reiterating the 'first entry as subject' detail already found in the entity parameter description. A baseline score of 3 is appropriate.

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

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

The description clearly states the tool compares AI visibility across multiple entities side-by-side, which distinguishes it from the single-entity sibling ai_visibility_check. It also provides a concrete use case and explicitly mentions the ranking/return behavior, making the purpose unmistakable.

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

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

The description gives a clear when-to-use context (competitive AI-marketing audits) and implies that single-entity checks should use ai_visibility_check. However, it does not explicitly mention alternatives like compare_entities or state when NOT to use this tool, so it falls just short of full guidance.

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

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

The description adds rich behavioral context beyond annotations: the tool fans out to two external services, has a potential 5-30s delay on first measurement, degrades gracefully with sources_failed field, and details the return structure. These are not covered by the readOnly/openWorld/idempotent hints, and no contradiction exists.

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 carrying distinct information: composite function, when to use, return fields, ecosystem limitation, and failure mode. No repetition or fluff; the primary purpose is front-loaded in the first sentence.

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

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

Given no output schema and moderate complexity, the description lists all expected output fields (summary block, per-advisory detail, links, alternatives, sources_failed) and explains the timeout behavior and ecosystem constraints. It is complete for an agent to decide when and how to invoke the tool.

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

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

Schema covers 100% of parameter descriptions, so baseline is 3. The description adds minimal new meaning—it reiterates npm scope and version default, plus behavioral context about version-specific timing, but does not significantly enrich parameter semantics beyond what the schema already provides.

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

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

The description states a specific composite check for npm packages, naming the verb 'check' and resource 'npm package', and clearly distinguishes from siblings by being the only tool focused on dependency safety. It enumerates data sources (deps.dev, bundlephobia) and expected output fields, making the purpose unmistakable.

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

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

Explicitly provides use cases: 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me"' and gives an exclusion for non-NPM ecosystems, directing users to deps.dev:version directly. This clearly delineates when to use this tool 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 declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds useful behavioral context by disclosing that the tool returns record_count and a Feature Service url, and that the url is intended for further querying—information not present in annotations or schema. No contradictions.

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

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

Two sentences, front-loaded with the action and resource, and every word earns its place. It communicates scope, return fields, and next-step guidance without 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 search tool with 3 optional params and no output schema, the description is complete: it explains what the tool does, what it returns, and how to use the result. The examples in the schema further support usage. No critical gaps.

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

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

Schema description coverage is 100%, so the baseline is 3. Each parameter (limit, query, org_id) is already well-described in the input schema. The description adds little beyond 'by keyword' and does not enrich parameter semantics beyond what the schema provides.

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

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

The description uses a specific verb ('Search') and resource ('City of Dublin GIS open geospatial datasets'), lists dataset categories, and explains exactly what is returned (name, summary, record_count, owner/org, Feature Service url). It also distinguishes this discovery tool from query_layer/layer_info by explicitly linking the returned url to those downstream tools.

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

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

The description implies clear usage context: use this tool to find datasets by keyword, then pass the returned Feature Service url to query_layer/layer_info for detailed querying. It lacks explicit when-not-to-use exclusions or named alternatives beyond the downstream tools, but the workflow is evident from the return value description.

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, and non-destructive. The description adds valuable behavioral specifics: truncation at 200K chars with a flag, BGE-base-en embeddings, cosine similarity over 500-char overlapping windows, and the return of character offsets and similarity scores. This goes well beyond the annotation baseline.

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

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

The description is compact yet information-dense. It front-loads the core function, then covers usage guidance, complementary tools, and technical constraints—all in three sentences with no filler. Every clause 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?

Despite lacking an output schema, the description details the return values (top-N passages, character offsets, similarity scores), explains truncation behavior, and provides sufficient technical context (embedding model, window size, char limit). For a read-only search tool with good annotations, this is fully complete.

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

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

Schema coverage is 100%, so baseline is 3. The description enhances parameter meaning with natural-language examples for query ('supply-chain risk', 'fiscal year 2024 revenue') and clarifies that 'text' is a previously fetched record. It adds context beyond the schema's property descriptions, justifying a 4.

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

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

The description clearly states a specific verb+resource: 'Semantic search INSIDE a fetched record.' It gives concrete examples (SEC 10-K, article) and distinguishes from siblings by emphasizing it operates on already-fetched text, not external sources. The pairing with ask_pipeworx_grounded further differentiates its 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?

Explicitly states when to use: 'when the record is too big to cram into the prompt' and mentions the alternative workflow with ask_pipeworx_grounded. This gives the agent clear usage context and points to a complementary tool, making alternatives explicit.

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 account requirement, SMS verification, 10/day cap, and the always-on feed behavior. These go beyond annotations. However, it omits webhook delivery behavior (HMAC signing, auto-disable), which is documented in schema, and doesn't explain idempotency semantics.

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?

Around 5 sentences, front-loaded with purpose and return value. Each sentence adds useful context, though the delivery portion is dense. No filler.

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

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

Covers OAuth requirement, supported types, return id, and main delivery channels. Webhook is absent but schema describes it extensively. No output schema, but return id is stated. Sufficient for a 3-parameter tool.

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

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

The schema covers all parameters with detailed descriptions (100% coverage), so the baseline is 3. The description adds examples like items:["5.02"] and topic:"fed" but largely mirrors schema. It adds no new parameter syntax beyond what schema provides.

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

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

The description opens with a specific verb+resource: 'Create a proactive monitoring subscription to a live-data event stream. Returns the new subscription id.' This clearly distinguishes it from siblings like list_subscriptions 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?

It states 'Requires a Pipeworx OAuth account' and explains delivery channels, implying use for long-lived monitoring. It does not explicitly name alternative tools for one-off checks, but the 'feed (always on)' mention contrasts with recent_alerts. Context is clear, but exclusions are not stated.

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/non-destructive, and the description adds that it returns category-bucketed examples with exact tool+argument shapes drawn from a live catalog. It also discloses that calling with no args gives the full spread and passing topic focuses, which is behavioral beyond the schema.

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

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

The description is well-structured, front-loaded with realistic user queries, and every sentence adds a distinct piece of information: purpose, output, invocation modes, and when to use it. Despite being longer than average, it earns its length.

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

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

Since there is no output schema, the description compensates by describing the return shape (category-bucketed examples with tool+argument shapes) and both invocation modes. It also names the meta-tools, making the tool self-contained for onboarding.

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 fully describes the optional topic parameter with expected values (100% coverage), so the description adds little new information. It repeats the 'full spread vs focus' pattern and gives examples, but these are essentially restatements of the schema's description.

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

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

The description clearly states the tool returns category-bucketed example questions with the exact tool and argument shape, positioning it as an onboarding entry point. It lists specific categories and names the meta-tools, which distinguishes it from sibling tools like discover_tools and ask_pipeworx.

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

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

It explicitly says 'Use this FIRST when you do not yet know what Pipeworx can do for you, or to learn how to call the meta-tools', and provides instructions for no-argument call vs topic focus. However, it does not mention when not to use it or name alternative tools to use instead, so it stops short of a full 5.

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

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

Annotations indicate a non-destructive mutation (readOnlyHint=false, destructiveHint=false). The description adds valuable behavioral details beyond annotations: ownership enforcement, row deactivation instead of deletion, and historical event availability via recent_alerts. No contradiction exists.

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

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

Three sentences, each earning its place: cancellation action, ownership constraint, and deactivation behavior. Information is front-loaded and there is no redundant text.

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 low-complexity with one parameter, clear annotations, and no output schema. The description covers purpose, side effects, and persistence behavior, making it complete for an agent to select 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% and the single parameter id is already documented as 'Subscription id (uuid) returned by subscribe.' The description only says 'by id', adding no further semantic value beyond the schema, so baseline 3 is appropriate.

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

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

The description uses a specific verb and resource: 'Cancel a subscription by id', which clearly states the action and target. It distinguishes itself from sibling tools like subscribe, list_subscriptions, and recent_alerts by focusing on cancellation.

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

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

The description provides clear context: ownership is enforced and cancellation deactivates rather than deletes. It doesn't explicitly name alternatives or state when not to use, but the purpose is unambiguous and enough for basic 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?

Even with annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint), the description adds significant behavioral context: it explains the two routing paths (SEC EDGAR + XBRL vs. grounded pipeline), the exact comparison math, the return verdicts, and the citation format. It also mentions the tool replaces multiple sequential calls, which is a non-obvious behavior.

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

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

The description is well-structured and front-loaded with user-intent examples. It is somewhat long, but each sentence adds meaningful information: intent, usage, routing logic, return values, and efficiency. The final note about replacing multiple calls is a minor extra but not wasteful. Overall, it is appropriately concise for the complexity.

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

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

Given the tool's complexity (no output schema, two routing paths, nuanced verdicts), the description is remarkably complete. It lists the exact verdict types, the evidence citation mechanism, and the fall-through behavior for non-financial claims. It adequately prepares an agent to invoke and interpret results without needing additional documentation.

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

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

The input schema already provides 100% coverage with rich descriptions for both 'claim' and 'tolerance_pct', including examples, default behavior, and usage guidance. The tool description does not add new parameter semantics beyond what the schema already states. Therefore, the baseline score of 3 is appropriate—the description does not diminish the schema but also does not enhance it.

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

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

The description clearly states the tool verifies natural-language factual claims against authoritative sources. It gives specific verbs ('validate', 'fact check', 'verify') and a resource ('claims'), and distinguishes from general query tools by focusing on claim verification with a specific verdict output. It also differentiates between company-financial claims and other claims, showing a clear scope.

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

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

The description explicitly says 'Use whenever the agent needs to check whether something a user said is factually correct.' It also explains when to use the SEC EDGAR fast path versus the grounded pipeline, effectively covering usage triggers. It does not name alternative tools, but the usage conditions are clear and exhaustive, including fall-through behavior.

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