Gitignore

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive. The description adds value by disclosing the default free model (Workers AI), the need for a BYO API key for Anthropic probes, and the return structure (per-model fields + combined view). No contradictions with annotations.

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

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

The description is concise (three sentences) and front-loaded with the primary action. It efficiently covers purpose, defaults, key parameter, and use cases without redundant words. A slightly more structured layout could improve readability, but it remains effective.

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

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

Despite no output schema, the description clearly outlines the return format (per-model score, confidence, signals, raw_response + combined view), cost implications, and optional parameters. Given the tool's moderate complexity (4 params), the description is sufficiently complete for agent invocation.

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

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

Schema coverage is 100% with all parameters described. The description adds meaning beyond the schema by explaining default model behavior, the purpose of _apiKey, and how the context parameter disambiguates entities. This helps the agent understand parameter usage beyond basic 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 uses specific verbs ('probe', 'score') and clearly identifies the resource (LLMs for entity knowledge) and output (visibility score 0-100). It differentiates from siblings by focusing on AI visibility scoring, a unique functionality not offered by other tools like ask_pipeworx or bet_research.

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

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

The description provides usage context ('useful for AI-marketing audits, pre-launch brand checks, competitive monitoring') but does not explicitly state when to not use the tool or suggest alternatives among siblings. The agent can infer appropriate scenarios but lacks clear exclusion criteria.

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

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

Annotations already mark readOnly, idempotent, and non-destructive, and the description aligns with those. Beyond annotations, the description adds useful behavioral context: it routes to one of 5,710 tools across 1,494 sources, fills arguments automatically, and returns stable pipeworx:// citation URIs. It also mentions fallback behavior for news queries. Minor gap: it doesn't explain failure modes or latency, but it does disclose multi-tool routing, which is central 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 extremely rich in guidance and examples, which makes it useful, but it is overwrought for a tool whose interface is a single free-text argument. The 'Step up only: when needed' phrasing is garbled and appears to be an encoding artifact. Despite that, the core guidance is front-loaded with 'PREFER OVER WEB SEARCH' and 'START HERE', and the examples are valuable. The length is justified by the routing complexity, but the garbled tail costs a point.

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-argument tool with no output schema, the description covers the input semantics, the routing behavior, the citation output, and sibling differentiation. The main missing piece is a clear statement of what the output format looks like beyond 'structured answer with citations.' However, given that there is no output schema, the description still provides substantial context for correct invocation, and the aliases are documented.

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 only required parameter (question) is fully described. The description adds semantic context that 'question' is natural language, and gives examples with revenue, SEC filings, and bitcoin price. However, it doesn't add anything substantial beyond the schema since the schema already describes the question parameter and aliases. 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 is explicit about the resource (Pipeworx tool network), the action (routes questions to the right tool among 5,710 tools and returns authoritative structured answers), and the domain (SEC, FDA, FRED/BLS, patents, real estate, weather, clinical trials, news, stocks, crypto, sports, etc.). It clearly differentiates itself from siblings like deep_research, ask_pipeworx_beta, and ask_pipeworx_grounded by positioning itself as the default or starting point.

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

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

The description explicitly says 'PREFER OVER WEB SEARCH', 'START HERE for most questions', and gives concrete example phrasings. It also states when NOT to use it vs deep_research ('for a broad/multi-part question... use deep_research'), and notes that breaking-news questions are handled through its own news routing. This is strong when-to-use and when-not-to-use guidance with named alternative tools.

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

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

Annotations already mark it read-only, open-world, idempotent, and non-destructive. The description adds live behavior: candidate routing improvements are only active during tests, none is active now, so it currently matches ask_pipeworx exactly. It also clarifies it does not fall back to a stub and is a full working router.

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 carry multiple concrete facts (5,710 tools, no active candidate, retirement date, comparison purpose) without padding. The only awkward bit is 'Falls back to nothing', which is immediately explained.

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 a universal router with one required parameter, and the description references ask_pipeworx's response shape rather than duplicating it. It covers current operating state and the fact that it is a working tool. No output schema exists, so a concrete return-format example would have improved completeness, but it is adequate.

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

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

The schema describes all six parameters with question plus aliases at 100% coverage. The description only says 'same arguments' without adding syntax or format details, so it adds no value beyond the schema. Baseline 3 is appropriate since schema carries the burden.

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

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

The description immediately defines it as a beta version of ask_pipeworx and states it is an 'identical universal router' exposing the same 5,710 tools, arguments, and response shape. This makes both the function and its relation to the sibling tool obvious.

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 an explicit usage instruction: use it exactly like ask_pipeworx when you want the newest routing. It does not explicitly name a when-not-to-use scenario, but the beta/stable contrast and 'experimental edge' imply using ask_pipeworx for stability, so guidance is strong but not perfect.

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 carry readOnly/openWorld/idempotent/non-destructive; the description adds materially beyond them: the explicit refusal contract with four named refusal_reasons, the success shape with verbatim-quote evidence, the 'EXTRACTS using ONLY what the tool result contains' grounding rule, and the one-extra-LLM-call cost. All of these are non-obvious behavioral traits an agent cannot derive from the 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?

Five dense sentences, each carrying non-redundant information: identity, mechanism, success+refusal contract, use-case, and cost trade-off. Front-loaded with the core differentiator (hallucination-resistant, high-stakes). The embedded return-shapes are justified because no output schema exists to carry them. Zero filler 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 high-complexity tool with no output schema, the description fully specifies both return contracts including every refusal_reason enum value, states the routing scale and mechanism, names the alternative, and quantifies the cost trade-off. With 100% parameter coverage in the schema and rich safety annotations, everything an agent needs to select and invoke this tool correctly is present.

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 even without param detail in the description. The description adds one param-adjacent insight — that routing and argument-filling are handled automatically, so the agent mainly supplies the question — but it provides no per-parameter format, alias, or constraint information beyond the schema. At this coverage level the description is not required to compensate, 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?

States a specific verb+resource+mode: answering a question in grounded, hallucination-resistant mode by routing over Pipeworx's 5,710 tools. Explicitly distinguishes itself from sibling ask_pipeworx by naming it and describing the extraction+refusal mechanism, so an agent can tell them apart without opening the schema. Nothing is tautological; every clause pins down what the tool does.

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

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

Sives explicit when-to-use criteria ('whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts') with concrete domains (financial verdicts, legal claims, medical lookups, public statements) and an explicit when-not-to with the cost-based reason ('prefer ask_pipeworx for casual lookups'). Names the alternative directly and explains the trade-off. Nothing is left to inference.

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 mark the tool as readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds extensive behavioral disclosure: how markets are resolved, classification, fan-out logic, response shapes, safety mechanisms (low-confidence match, closed markets, wide spreads), resolution rule risk, and error handling (GDELT 429s). No contradictions with annotations.

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

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

The description is lengthy but well-structured with capitalized sections (CLASSIFIERS, FAN-OUT EXAMPLES, RESPONSE SHAPES, RESOLVER CONTRACT, etc.). Every sentence adds essential detail for a complex tool. While not maximally concise, the structure aids readability and the length is justified by the tool's sophistication.

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 thoroughly documents the response structure (result.market, result.analysis, result.evidence, result.parent_event, etc.), edge cases (low confidence, closed markets, wide spreads), and safety mechanisms. It covers resolution rule risk and error handling, making the tool fully understandable without an output schema.

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

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

Schema coverage is 100%, with three parameters (market, depth, include_raw) all having descriptions in the schema. The description adds value beyond schema: it explains accepted market input formats (slug, URL, question text), depth levels (quick vs thorough with default thorough), and include_raw behavior (summarized vs full payloads). This enriches the agent's understanding beyond the schema alone.

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

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

The description clearly states the tool researches a Polymarket bet by pulling Pipeworx data, resolving the market, classifying the bet, fanning out to data packs, and returning an evidence packet with market-vs-model comparison. It distinguishes from sibling tools like polymarket_edges and polymarket_arbitrage by focusing on research rather than arbitrage or edge detection.

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

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

The description explicitly says 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z"', providing clear usage context. It also gives examples of classifiers and fan-outs, implicitly guiding when to use this tool over alternatives. It could be improved by explicitly stating when not to use, but current guidance is 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?

Beyond annotations (readOnly, openWorld, idempotent), the description details data sources (SEC EDGAR/XBRL for companies, FAERS for drugs), handling of off-calendar fiscal years, result sorting by primary metric, and output format (paired data + citation URIs). No contradictions with annotations.

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

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

The description is concise, fitting all key information in a single paragraph. It starts with trigger phrases, then purpose, then per-type details. Slight lack of structural formatting (e.g., bullets) but efficient overall.

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 2 parameters and no output schema, the description covers entity types, data sources, handling of fiscal years, result sorting, output format, and efficiency gains, providing sufficient context for an agent to invoke correctly.

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

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

Schema coverage is 100% and parameters are well-described. The description adds example values and entity-specific data context but does not significantly enhance parameter semantics 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?

Description clearly states the tool performs side-by-side comparison of 2-5 companies or drugs. It provides trigger phrases like 'compare X and Y' and explicitly distinguishes itself from sequential single-pack lookups, 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?

Explicit guidance: 'ALWAYS PREFER over sequential single-pack lookups when comparing entities.' It gives context for when to use (comparing entities) and mentions efficiency (replaces 8-15 lookups), though it does not explicitly state when not to use it.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds behavioral context by noting that the result is separated by headers, which is not captured in the annotations. It could mention that templates are fetched from a predefined source or that no side effects occur.

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, clear sentence with no unnecessary words. It immediately conveys the tool's purpose and is front-loaded.

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

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

For a simple tool with one parameter and an output schema, the description is largely complete. It briefly explains the 'separated by headers' behavior, though more detail on what that means (e.g., section headers) would improve completeness.

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

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

The schema includes a complete description and example for the single parameter 'names'. The tool description adds little beyond the schema, only implying that names refer to template names. With high schema coverage, a baseline of 3 is appropriate.

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

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

The description clearly states the action (compose), the resource (combined .gitignore), and the method (from multiple templates, separated by headers). It effectively distinguishes the tool from the set of sibling tools, which are unrelated (e.g., polymarket, 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?

The description implies the tool should be used when needing a combined .gitignore from templates, but it does not explicitly state when not to use it or provide alternatives. Given the siblings are unrelated, the lack of explicit exclusions is acceptable, but some guidance would improve 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 the annotations (readOnly, openWorld, idempotent, not destructive), the descrip discloses account/paid requirements, structured-data limitation, parallel decomposition, findings-packet fields, gaps[] never invented, citation_uri fetchability, contradictions[], semantic excerpting, and expected latency. These are material behaviors not encoded in annotations.

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

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

The descrip is long but front-loaded with the most critical constraint (account/alternative) and every major section earns its place for a complex tool with no output schema. It loses one point because the depth, return-format, and latency details could be consolidated; still far from 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?

With no output schema, the descrip carries the full burden of explaining return semantics: findings packet fields, gaps[], contradictions[], hop, citation_uri, semantic excerpting, and latency. It also covers auth, data scope, and example usage. Nothing essential for invoking correctly is missing.

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

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

The schema already covers both parameters at 100%, so the baseline is 3. The description adds real value by explaining depth levels (quick=3 single-hop, standard=default gap-recovery, thorough=6 paid iterative) and by noting 'thorough' requires a paid plan. This is additive but not fully complete as a structured parameter reference.

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

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

The description states a specific verb+resource: grounded multi-source research across Pipeworx's 1494 STRUCTURED data sources, with decomposition and parallel routing. It explicitly says 'this is NOT open-web search' and provides concrete example questions, distinguishing it from ask_pipeworx and other siblings.

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

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

It gives explicit conditions and alternatives: signed-out users should use ask_pipeworx instead, single lookups should use ask_pipeworx instead, and deep_research is for broad/multi-part structured-data questions. This is exactly the when/when-not guidance an agent needs.

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

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

Annotations indicate idempotent, read-only, non-destructive behavior. The description adds value by explaining that results include full schemas with curated examples and are ready to call directly, providing context 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 a single paragraph that front-loads the purpose, lists supported domains, and highlights key features. It is efficient without extraneous detail, though a slight structure improvement could tighten it further.

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 broad scope of discoverable topics and the lack of an output schema, the description adequately explains what the tool returns (names, descriptions, schemas with examples), how to use it, and why to call it first. No critical information is missing.

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

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

Schema coverage is 100% with all 6 parameters described. The description adds meaning by explaining that the 'query' parameter accepts natural language and providing examples, which enhances usability beyond the schema descriptions alone.

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

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

The description clearly states the tool's purpose: 'Find tools by describing the data or task.' It provides a comprehensive list of supported domains and explains that it returns top-N relevant tools with schemas, making it distinct from sibling tools that serve other functions.

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

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

The description explicitly advises 'Call this FIRST when you have many tools available and want to see the option set,' giving clear context for when to use. It does not describe when not to use, but the positive guidance is 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, idempotentHint, and non-destructive behavior. The description adds valuable context: parallel fan-out across sources, specific data returned, patent soft-failure explanation (USPTO sunset), and fallback mechanisms (GDELT→GNews). 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 front-loaded with common query examples and is compact given the amount of detail. Every sentence adds value, though it could be structured into clearer sections for even quicker scanning.

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

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

Given the tool's complexity and lack of output schema, the description details return fields and sources. It briefly mentions error conditions (patent soft-fail) but could further clarify pagination or rate limits. Overall adequate.

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

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

Schema coverage is 100% with descriptions for both parameters. The description reinforces the value parameter format (ticker or zero-padded CIK) and type parameter (only 'company' supported). While useful, it does not add substantial meaning beyond what the schema provides.

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

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

The description clearly states the tool provides a full cross-source profile of a US public company in one parallel call, listing specific outputs like CIK, filings, fundamentals, patents, news, and LEI. It distinguishes itself from sibling tools like resolve_entity and compare_entities by specifying when to use each.

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

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

Explicitly advises to prefer this tool over chaining single-pack lookups for holistic views, and instructs to use resolve_entity if only a name is available. Also clarifies that names are not supported and provides the alternative tool name.

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

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

Annotations include destructiveHint=true and idempotentHint=true. Description confirms deletion and adds context about clearing sensitive data, but no additional behavioral details (e.g., irreversibility, permissions). Does not contradict annotations.

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

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

Two sentences clearly front-loaded: first states purpose, second gives usage guidance. Every sentence adds value; no redundant or vague language.

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

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

For a simple tool with one parameter and no output schema, the description covers purpose, usage context, and pairing with siblings. No gaps remain given the tool's simplicity and annotation support.

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?

Single parameter 'key' with schema description 'Memory key to delete.' Schema coverage is 100%, so description adds no extra meaning beyond the schema. 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?

Description states 'Delete a previously stored memory by key.' Verb is specific ('delete'), resource is clear ('memory'), and method is explicit ('by key'). Distinguishes from sibling tools like 'remember' and 'recall.'

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

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

Explicitly states when to use: 'when context is stale, the task is done, or you want to clear sensitive data.' Also mentions pairing with related tools. Lacks explicit when-not-to-use or alternatives, but provides sufficient guidance.

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

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

Annotations already indicate read-only and idempotent behavior. The description adds that the tool fetches an external URL and extracts content, which is crucial for understanding side effects. No contradictions and no missing major traits, though rate limits or URL validity constraints could be noted.

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

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

The description is four sentences with a clear front-loaded purpose, followed by mechanism and use cases. Every sentence is informative with no redundancy or unnecessary words.

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

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

Despite no output schema, the description explains the output format ('standard llms.txt markdown format', 'single text blob') adequately. Parameters are fully covered. It does not mention potential errors or limitations, but overall completeness is high for a straightforward generation tool.

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

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

Schema coverage is 100% with both parameters described. The description elaborates on the 'url' parameter by stating what the tool fetches and extracts, and it gives default and max values for 'max_links' beyond the schema. This adds value over bare 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 specifies a concrete verb ('generate'), a clear resource ('llms.txt file'), and the target audience ('AI crawlers'). It distinguishes the tool from siblings by its unique output format and use case, with no overlapping sibling tool.

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

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

The description provides explicit use cases ('getting a client's site indexed', 'drafting for your own project', 'auditing a competitor') but does not mention when to avoid using it or list alternatives. However, no sibling tool competes directly, so the guidance is adequate.

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

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

Annotations already declare readOnly, idempotent, non-destructive. Description adds case-sensitivity and examples, but no further behavioral traits beyond schema and 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?

Single sentence, front-loaded, no wasted words.

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

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

Low complexity; annotations and output schema cover most; description is sufficient for usage.

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

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

Schema coverage 100%; description adds value by specifying case-sensitivity and examples, enhancing schema info.

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

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

Clear verb 'Fetch', resource 'raw .gitignore content for named template', case-sensitivity and examples provided. Distinguishes from sibling 'list_templates'.

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?

Context clear: use to fetch content of a specific template. Implicitly not for listing. No explicit when-not but sibling differentiates.

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, destructiveHint=false, idempotentHint=true. Description adds return field details, which is useful. No contradictions. Additional context about cancellation implies it is safe.

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?

Very concise: two sentences, front-loaded with the action and outputs. No wasted words.

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

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

Given good annotations, one optional parameter, and no nested objects, the description sufficiently covers purpose, usage, and return fields. Lacks explicit response format but fields are listed.

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% (only one parameter with description). Description does not add meaning beyond 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 clearly states the tool lists active subscriptions and enumerates returned fields (id, type, etc.), with a specific verb and resource. Siblings like subscribe and unsubscribe are distinct, so no confusion.

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

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

Explicit usage scenarios given: 'review what you're monitoring before adding more or to find an id to cancel'. It implies when to use, though does not list explicit alternatives or when not to use. Context with siblings is sufficient.

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 the source ('from github/gitignore'), which is a behavioral detail beyond annotations. This is sufficient for a simple read-only listing.

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 sentence front-loaded with the action verb. Every word is necessary and there is no redundant information.

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

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

The tool is simple with no parameters and an output schema is present. The description fully explains what the tool does (list names from a specific source), leaving no ambiguity for the agent.

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

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

The tool has zero parameters and schema description coverage is 100% (no params to document). Baseline for 0 parameters is 4; the description does not need to add parameter information.

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

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

The description 'List all available .gitignore template names from github/gitignore' uses a specific verb (list) and resource (template names from github/gitignore). It clearly defines scope and distinguishes from sibling 'get_template' which retrieves a specific template.

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?

While no explicit when/when-not guidance is given, the description implies this is the tool to explore available templates before using 'get_template'. The context of listing all templates from a known source (github/gitignore) makes usage clear, though explicit alternatives would earn 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?

With annotations all false (providing negligible information), the description carries the full burden of behavioral disclosure—and it excels. It reveals rate limits ('Rate-limited to 5 per identifier per day'), the claim_token follow-up mechanism, cost implications ('Free; doesn't count against your tool-call quota'), and the internal handling ('The team reads digests daily and signal directly affects roadmap'). It also warns against pasting end-user prompts, adding a meaningful behavioral constraint. No contradictions with annotations.

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

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

Though long, every sentence earns its place. The description is front-loaded with purpose, followed by usage conditions, exclusions, a clarity heuristic, formatting guidance, the token mechanism, signal impact, rate limits, and cost—each critical for correct invocation. It is well-structured, with no filler or redundancy, and the length is justified by the complexity of the tool.

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

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

Given the tool's moderate complexity (4 params, nested object, no output schema), the description is remarkably complete. It covers what the tool does, when and when not to use it, what to include in the message, the claim_token return and follow-up behavior, rate limits, cost, and the distinction from other MCP servers. It even addresses the 'read the reply' use case. There are no obvious gaps that would leave an agent uncertain about selection or invocation.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful value beyond the schema, especially for claim_token: it explains the round-trip usage ('pass it back later as pipeworx_feedback({claim_token:"pwfb_…"})') and the requirement to include no other arguments. It also adds typical length for message ('1-2 sentences typical') and reinforces the context object's optionality. While not every param is expanded, the schema already documents them thoroughly; the description's extra context is a clear improvement.

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

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

The description opens with a specific verb+resource: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It clearly distinguishes this from sibling tools by explicitly limiting scope to 'tools served by this Pipeworx connection' and providing concrete examples (bug, feature/data_gap, praise). This gives the agent an unambiguous understanding of what the tool does and when it applies.

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

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

Usage guidelines are explicit and comprehensive. The description states exactly when to use the tool ('Use when a tool returns wrong/stale data (bug), when a tool you wish existed isn't in the catalog (feature/data_gap), or when something worked surprisingly well (praise)'), provides a clear exclusion ('if the tool came from a different MCP server... file it with that server instead'), and offers a heuristic for uncertainty ('Not sure? Pipeworx tool names are the ones this connection lists'). This is exemplary guidance.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds valuable details: data source (CF analytics-engine), absence of PII, caching behavior (5min-1h), and self-aggregating nature. 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 concise (three short paragraphs) with front-loaded purpose, structured use cases, and brief technical notes. Every sentence adds value without redundancy.

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

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

Given no output schema, the description adequately explains return content (top tools, packs, call volume). It could optionally detail the output format, but the tool's simplicity makes this sufficient. Context signals (1 param, no output schema) support this score.

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 provides full coverage (100%) with an enum for 'window'. The description adds semantics by explaining that shorter windows surface hot trends while longer windows show steady-state demand, aiding selection beyond the enum values.

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

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

The description begins with a clear verb phrase 'What other AI agents are calling on Pipeworx right now' and specifies outputs (top tools, top packs, total call volume) and time windows. It distinguishes itself from siblings like 'discover_tools' and 'ask_pipeworx' by focusing on aggregate usage trends.

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

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

Three explicit use cases are listed (discovering hot data sources, confirming canonical tool, aligning with agent needs). However, it does not explicitly state when NOT to use the tool or compare directly to siblings; the guidance is still clear and actionable.

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

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

Discloses detailed behaviors: Jaccard similarity threshold, placeholder filters, fill check against live CLOB depth, and response structure. Annotations already indicate read-only and idempotent, and description adds significant context beyond that.

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

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

The description is detailed and well-structured with clear sections, but slightly verbose. Every sentence adds value, though some repetition could be trimmed.

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 complexity of arbitrage detection and no output schema, the description comprehensively covers all modes, edge cases (low similarity, placeholder filters), and fill risk, making it fully actionable.

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 description adds rich meaning: for 'event' it explains walking child markets and partition_check; for 'topic' it explains cross-event scanning and semantic anchor. Both parameters are thoroughly documented.

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

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

The description clearly states it finds arbitrage opportunities via monotonicity violations and partition-sum checks. It distinguishes between trending_scan, event mode, and topic mode, and contrasts with sibling tools like polymarket_fill_risk.

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

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

Explicitly describes when to use each parameter: no args for trending_scan, 'event' for single-event, 'topic' for cross-event. Provides examples and explains when not to trade (realizable_edge_pp ≤ 0). Recommends polymarket_fill_risk for custom sizing.

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

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

The description goes far beyond the annotations (which already indicate read-only, idempotent, non-destructive) by detailing the three model segments, caching behavior, diagnostics, and the meaning of each field. It fully discloses internal logic such as model families, filter criteria, and edge calculation.

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

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

The description is verbose but well-structured, starting with the high-level purpose and then detailing models, response structure, and knobs. While every sentence adds value, it could be slightly more concise without losing essential detail.

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

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

Given the tool's complexity (9 parameters, multiple segments, no output schema), the description fully covers the response structure (by_segment, diagnostics), explains why segments may be empty, and details caching. It leaves no significant gaps for an agent to understand the tool's 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?

All 9 parameters have high-coverage schema descriptions, and the tool description adds significant value by explaining their interplay (e.g., min_kelly vs min_partition_leg_kelly, slippage_pp interaction). It provides context for defaults and tuning, making parameter usage clear.

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

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

The description explicitly states the tool scans Polymarket markets for opportunities where Pipeworx data disagrees with market price, with a clear purpose of finding betting opportunities. It distinguishes itself from sibling tools like polymarket_arbitrage and polymarket_edge_tracker by its scope and methodology.

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 is built for 'what should I bet on today' and details tradeable-edge knobs and filters, providing clear guidance on when to use and how to configure. However, it does not explicitly contrast with sibling tools or specify when not to use it, missing some exclusionary guidance.

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

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

Annotations already indicate safe, read-only, idempotent behavior. The description adds value by detailing the data source (daily snapshots), response structure (tracked, expired, snapshot_dates), and decay computation. 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?

Well-organized with clear sections (RESPONSE, LIMITS) and front-loaded core question. Each sentence provides necessary detail; minor redundancy but overall efficient 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?

Despite lacking an output schema, the description thoroughly explains all response fields (tracked, expired, snapshot_dates) and their meanings. Limits section covers important constraints. Fully compensates for missing 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 schema covers both parameters with descriptions, and the description adds default values (days=14, window='1wk'), valid range (2-30), and clarifies window as 'snapshot family' with options beyond defaults.

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

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

The description clearly identifies the tool's purpose: tracking edge persistence and decay telemetry from daily snapshots, answering 'how long has this edge existed and is it shrinking?'. It distinguishes itself from the sibling polymarket_edges tool by focusing on temporal behavior rather than raw edge values.

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 context on when to use (e.g., distinguishing fresh vs. old edges) and describes limitations like 60-day TTL. It does not explicitly state when not to use or list alternative tools, but the guidance is sufficient 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?

Annotations already indicate safe read-only, idempotent behavior. Description adds that it checks live order-book depth, returns a verdict (clean|degraded|cannot_fill), and reveals the critical risk of partial fills converting arbs to directional positions—value 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?

Description is long but well-structured with headings (SINGLE-MARKET, BASKET) and clear sections for parameters and returns. Every sentence adds value, though slightly more concise phrasing could be possible. Front-loaded with the core purpose.

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

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

Despite no output schema, the description thoroughly explains return fields for both modes (top_of_book, vwap_fill_price, slippage, verdict, etc.) and covers edge cases like thin_legs and forced_directional_risk. Agents have sufficient information to understand tool behavior and consequences.

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

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

Schema coverage is 100%, but description adds meaning: default values for 'side' (auto in basket), interpretation of 'size_usd' as settlement notional in basket mode, clamp range 10–1,000,000, and specifies that 'market' and 'event' are mutually exclusive but one is required. Adds significant semantic 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?

Clearly states it performs a realizable-vs-theoretical edge check against live order-book depth, distinguishes single-market and basket modes, and provides verdicts. Explicitly contrasts with sibling tools by stating when to use this tool before acting on arb 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?

Explicitly says 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500', providing clear when-to-use context and implicit when-not-to-use. Also warns about partial fills converting to directional positions, guiding appropriate invocation.

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/non-destructive, and the description adds substantial behavioral context beyond those. It discloses that compatibility_warning and compatibility_codes can both be non-empty even when matched_pairs > 0, defines every compatibility code, and explains that unknown legs are never paired and are routed to skipped_unclassified or low_confidence_pairs. No annotation contradiction is 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 long, but it is deliberately structured with blank-line sections for TWO MODES, RESPONSE, and SAFETY FIELDS, and the core purpose is front-loaded. It is dense rather than padded; most sentences carry caveats or output semantics that are necessary because no output schema exists. It could be trimmed, but the structure makes it navigable for an agent.

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?

Because there is no output schema, the description must carry the full return-value explanation, and it does: it specifies leg-by-leg raw probabilities, top_spreads_pp, compatibility fields and codes, skipped_unclassified, low_confidence_pairs, temporal_alignment, and skip counters. It also addresses edge cases like unknown legs and unverified pre-mapped pairings, leaving no major gap for a caller to guess.

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

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

Schema description coverage is 100%, so the baseline is 3; the description adds interaction semantics by explaining that topic auto-fetches the matching event on each venue and that explicit kalshi_event_ticker/polymarket_event_slug override the topic-mapped side. This mode-level behavior is not derivable from the individual parameter descriptions and helps an agent choose the right call style.

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 by defining the tool as the cross-venue spread between Kalshi and Polymarket for the same resolving question, which is a specific resource and operation. It further distinguishes itself from related tools by emphasizing shared-resolution comparison and explicitly warning that "pre-mapped ≠ tradeable," so an agent can separate it from arbitrage or edge-detection siblings.

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

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

The description clearly separates the two modes: topic shortcuts for pre-mapped pairings and explicit kalshi_event_ticker/polymarket_event_slug for custom ones. It also tells the agent when to be skeptical of results by stating that most pre-mapped topics currently return compatibility_warning and that pre-mapped ≠ tradeable. It does not explicitly name sibling tools as alternatives, so the guidance is strong but not fully comparative.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds context: behavior when omitting the key (list all keys), scoping to identifier, and pairing with sibling tools. 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 concise (3 sentences), well-structured with the main purpose first, then use case, then scoping and pairing. No redundant words.

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

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

For a tool with one optional parameter and strong annotations, the description is complete. It covers input, output (value or list), scope, and relationship to siblings. No missing critical information.

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

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

Schema coverage is 100%, baseline 3. The description adds meaning by explaining the parameter's dual behavior: retrieving a value or listing keys if omitted. This goes beyond the schema's simple 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's purpose: 'Retrieve a value previously saved via remember, or list all saved keys (omit the key argument).' It uses a specific verb (retrieve/list) and resource (saved memory), and distinguishes from siblings like remember and forget.

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

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

The description explains when to use the tool: 'Use to look up context the agent stored earlier... without re-deriving it from scratch.' It also implicitly excludes storing or deleting, and explicitly mentions pairing with remember and forget 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?

The annotations declare readOnlyHint: true, but the description allows setting mark_read:true to flag events as read, which is a write operation. This is an annotation contradiction, hence the low score.

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

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

The description is concise (4 sentences) with front-loaded purpose. Every sentence adds meaningful information, including parameter usage, return fields, and a mention of alternative access. No redundancy or fluff.

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

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

Despite having no output schema, the description covers return fields, all parameters, side-effects of mark_read, and alternative access. For a tool with 5 optional parameters, it provides sufficient context for an agent to use it correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by providing an example for the type parameter ('sec_8k'), explaining the ISO timestamp for since, and detailing the side-effect of mark_read. This goes beyond the schema descriptions.

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

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

The description clearly states the action ('Pull fired events') and the resource ('your subscription feed'). It specifies what is returned (recent alerts with source, citation_uri, payload) and mentions filtering options, 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 provides practical usage context, such as noting that polls work fine and that the same feed is available via a REST endpoint for scripts. It explains when to use parameters like type and since, but it does not explicitly contrast this tool with sibling tools or specify when not to use it.

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

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

Discloses multiple data sources, fallback logic (GDELT→GNews), soft-fail for USPTO, and return format (structured changes with sources and citation URIs). No contradiction with annotations.

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

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

Description is front-loaded with example queries and packs significant detail, but is slightly verbose. Every sentence is informative, though could be slightly more concise.

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

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

Given no output schema, describes return structure (changes[] grouped by source, total_changes count, citation URIs). Covers all three parameters completely and addresses error/fallback behavior.

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

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

Adds meaning beyond schema: since accepts ISO date or relative shorthand with examples and typical monitoring recommendation; value can be ticker or CIK; type enum explained as limited to 'company'.

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

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

Description specifies verb ('change feed'), resource ('company'), and scope ('last N days/weeks/months'). It lists three data sources and distinguishes from sibling entity_profile.

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

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

Provides explicit example queries, recommends when to use (change feed) vs when not (static profile via entity_profile). Also describes fallback behavior between GDELT and GNews.

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

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

Discloses storage as key-value scoped by identifier, retention policies, and pairing with other tools. Annotations (idempotentHint: true, destructiveHint: false) are consistent and description adds valuable context beyond them.

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

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

Three sentences, each earning its place: first states purpose, second gives usage guidance, third adds behavioral details. No redundancy or wasted words.

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

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

For a simple write tool with no output schema, the description covers storage and retention well. Missing detail about return values (e.g., success confirmation) but paired with recall for retrieval, so largely 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?

Input schema provides 100% coverage with descriptions for key and value. The description reiterates 'key-value pair' but adds no new semantic detail beyond the schema.

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

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

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

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

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

Explicitly states when to use: 'Use when you discover something worth carrying forward'. Also guides pairing with recall and forget, and notes differences between authenticated (persistent) and anonymous (24-hour) sessions.

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

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

The description discloses behavior beyond the readOnly/idempotent annotations: unresolved identifiers are explicitly listed under 'unresolved' rather than omitted, each identifier is labeled with its source, and enrichment degrades gracefully if GLEIF/OpenFIGI are unavailable. It also explains internal cascading lookups, providing expectations for latency and manual effort saved.

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 examples, core purpose, supported types, and behavioral notes. It is front-loaded with query examples and clearly organized. Some details, like the specific pipeworx URL for RxCUI citations, could be trimmed without loss, but overall 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?

Despite having no output schema, the description covers return structure (source-labeled identifiers, unresolved placeholders), failure behavior (graceful degradation), and internal cascading. It also explains the scope of supported entity types and input forms. This gives an agent all necessary context to decide when and how to call the tool.

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

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

The input schema already covers both parameters at 100% (enum and descriptions). The description adds value by elaborating on accepted input formats for 'value' (ticker, CIK, ISIN, name for company; brand/generic for drug) and explaining domain-specific behavior like ISIN-to-LEI resolution for non-US issuers. 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 resolves user-spoken names to canonical identifiers (CIK, ticker, LEI, FIGI, RxCUI) that other tools require as input. It provides concrete query examples and differentiates itself from siblings by emphasizing 'other tools require as input.' The supported types and distinct identifier sources make 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?

Explicit guidance is given: 'Use FIRST whenever you have a name but need an ID.' This tells the agent when to call the tool. However, it does not explicitly name alternatives or exclusions (e.g., when not to use it), so it stops short of full alternative comparison. Still, the 'FIRST' directive strongly implies the appropriate context.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds behavioral details: probes each entity with ai_visibility_check, ranks by score, returns score/confidence/signal density, and mentions the models parameter and API key requirement. 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 3-4 sentences, front-loaded with the core function, followed by use case and output format. Every sentence adds value with no redundancy.

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

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

Despite lacking an output schema, the description states the return format: ranked list with score, confidence, signal density per entity. It also explains internal mechanism (calling ai_visibility_check) and covers all four parameters' semantics. Complete for a tool of this complexity.

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

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

Schema coverage is 100% with parameter descriptions. The description adds critical context: first entity treated as 'subject' for narrative, rest as competitors; 'workers-ai' is free default; _apiKey needed only if 'anthropic' in models. This significantly enhances understanding beyond schema.

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

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

The description clearly states the tool compares AI visibility across multiple entities, uses ai_visibility_check per entity, ranks results, and surfaces most/least recognized. It gives a concrete use case (competitive AI-marketing audits) and distinguishes from likely sibling tool ai_visibility_check (single entity).

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 the tool is useful for competitive AI-marketing audits and gives an example question. It implies single-entity checks should use ai_visibility_check, but does not explicitly say when not to use this tool or list alternative sibling tools.

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

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

Annotations already indicate safety (readOnlyHint, idempotentHint). Description adds valuable context: fans out across two services, specific return fields, graceful degradation, timing for bundlephobia first measurement.

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

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

Description is somewhat long but well-structured and front-loaded. Every sentence earns its place, providing necessary detail without redundancy.

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

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

Given two parameters and no output schema, the description covers return fields, ecosystem scope, partial failures, and version defaults, making it complete for agent use.

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

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

Schema coverage is 100%, so baseline 3. Description adds that scoped packages are accepted and version defaults to latest, providing meaningful context beyond schema.

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

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

The description clearly defines the tool as a composite check for evaluating npm packages, combining deps.dev and bundlephobia data. It distinguishes from sibling tools like deps.dev:version for other ecosystems.

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 an agent asks about safety, popularity, size, or cost. Mentions alternatives for other ecosystems (PyPI, Maven, etc.) and notes graceful partial failures.

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

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

Annotations already provide readOnly, openWorld, idempotent hints. Description adds implementation details (BGE-base-en embeddings, cosine similarity, 500-char windows, 200K char cap with flagging) and return values (offsets, scores), going well beyond annotations.

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

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

Four concise sentences: first defines purpose, second gives usage context, third links to sibling, last provides technical details. Front-loaded and every sentence adds value.

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

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

Given no output schema, description explains return format (passages with offsets and scores), input constraints, model details, and windowing. It is fully self-contained for an AI 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?

With 100% schema coverage, description further enriches parameters by providing example queries, explaining the 'text' parameter as fetched document, and clarifying truncation behavior and max chars. This adds significant value beyond schema.

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

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

The description clearly states the verb 'search' and resource 'inside a fetched record', and distinguishes it from siblings like 'ask_pipeworx_grounded' by specifying use case for large records. It 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 explicitly says 'Use when the record is too big to cram into the prompt' and references a sibling tool. While it lacks an explicit when-not-to-use, it provides clear context for usage.

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

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

Annotations indicate non-read-only, non-destructive, idempotent. The description aligns by stating it creates a subscription and returns an ID, implying idempotency. It adds behavioral details: requires OAuth, type-specific parameters, delivery channel limitations (phone verification, 10/day SMS cap, webhook signing). No contradiction with annotations.

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

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

The description is a single dense paragraph that front-loads the main purpose and then provides necessary details. It is efficient but packs a lot of information; a bit more structure (e.g., bullet points) could improve readability, but it is still very functional.

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

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

Given the tool's complexity (3 parameters, nested objects, no output schema), the description covers prerequisites, type-specific parameters, delivery options with constraints, and return value. No obvious gaps remain for correct invocation.

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

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

Schema coverage is 100% but the description adds significant value beyond basic schema descriptions. For 'type', it provides examples and meanings for each enum value. For 'params', it gives concrete structures per type. For 'delivery', it explains channels, constraints, and even webhook signing details. The description enriches the schema substantially.

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

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

The description clearly states the action (create a subscription) and the resource (proactive monitoring subscription to a live-data event stream). It distinguishes itself from siblings like 'list_subscriptions' and 'unsubscribe' by focusing on creation. The title 'Subscribe to Alerts' aligns perfectly.

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 detailed context on when to use: requires Pipeworx OAuth, supported subscription types with examples, delivery channels and their constraints (phone verification, SMS cap). It implicitly guides users away from anonymous/BYO accounts and does not explicitly discuss alternatives, but the context is clear enough.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds that it returns example questions with tool+argument shapes from the live catalog, and explains calling with/without topic. Does not contradict annotations.

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

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

Front-loaded with example queries and structured well, but slightly verbose. Every sentence adds value, but some redundancy could be trimmed (e.g., 'what can you do?' is similar to other phrases).

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

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

Given no output schema, the description fully covers what to expect (category-bucketed examples with tool+argument shapes). Explains arguments and use case completely for a simple onboarding tool.

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

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

Schema coverage is 100% but description adds significant value: lists possible topic values (finance, pharma, etc.), explains effect of omission, and describes return content. This exceeds schema's minimal 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 for onboarding, with specific verb 'suggest' and resource 'question ideas'. It distinguishes from siblings by positioning as the entry point for understanding what Pipeworx can do.

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

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

Explicitly says 'Use this FIRST when you do not yet know what Pipeworx can do for you' and explains when to pass topic. Implicitly suggests that for specific questions, other tools like ask_pipeworx are better. Could more explicitly state when not to use.

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

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

The description adds important behavioral details beyond annotations: ownership enforcement and soft-deletion. Annotations already indicate non-destructive and idempotent, but the description elaborates on the deactivation policy.

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

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

The description is two sentences, directly addressing purpose, ownership, and effect. No redundant or unnecessary words.

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

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

Given the single parameter, no output schema, and clear annotations, the description covers ownership, deactivation, and historical availability. It is complete for a simple mutation tool.

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

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

Schema coverage is 100% and describes the id parameter as 'Subscription id (uuid) returned by subscribe.' The description mentions 'by id' but adds no further semantic nuance, so it meets the baseline.

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

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

The description clearly states the action (Cancel a subscription by id) and distinguishes from sibling tools like subscribe and list_subscriptions by explaining the effect (deactivation rather than deletion).

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

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

The description explains ownership enforcement and that historical events remain available via recent_alerts, giving context for when to use. It could explicitly contrast with subscribe or list_subscriptions, but the guidance is sufficient.

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 list readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description adds significant behavioral detail: explains verdict values (confirmed, refuted, etc.), clarifies that 'could_not_verify' indicates a failed check (not evidence), and differentiates 'unsupported' from 'could_not_verify'.

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?

While long, every sentence earns its place: trigger phrases, scope, routing, output, error semantics, and efficiency. It is front-loaded and well-structured, with no fluff.

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

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

No output schema is present, but the description explicitly enumerates return values (verdict, actual value with citation, reasoning) and error handling. It fully covers the tool's behavioral complexity.

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

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

Schema coverage is 100% for both parameters ('claim' and 'tolerance_pct'). The description adds no parameter-specific details beyond what the schema already provides, so baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'natural-language claim verification against authoritative sources.' It distinguishes from siblings by noting it 'replaces 4–6 sequential calls' and is the go-to for fact-checking user claims. It also provides a specific scope for financial vs. other claims.

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: 'Use whenever the agent needs to check whether something a user said is factually correct.' It gives clear routing context (financial vs. other claims) but doesn't name specific alternative tools or explicitly state when not to use it, which prevents a 5.

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