Skiddle

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds valuable behavioral context: default model is free, Anthropic requires BYO key with direct payment, and returns per-model fields (score, confidence, signals, raw_response). No contradictions found.

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

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

The description is concise and well-structured: first sentence states main function and output, second sentence explains models and pricing, third details return structure, fourth lists use cases. 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 no output schema, the description fully explains the return structure per-model and combined view. All 4 parameters are documented with examples. Use cases are provided. It is adequately complete for an agent to decide and invoke the tool.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds extra meaning: explains default model for 'models' parameter, specifies that _apiKey is only needed for Anthropic and is passed through, and provides disambiguation examples for 'context'. This is a meaningful addition 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 function: probing LLMs for knowledge about an entity and scoring visibility (0-100). It specifies the default model and optional Anthropic probing, and lists concrete use cases. Though sibling differentiation is not explicit, the purpose is highly specific and actionable.

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

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

The description provides clear usage context with enumerated use cases (AI-marketing audits, pre-launch checks, competitive monitoring), but does not explicitly exclude alternatives or compare to siblings like scan_competitor_ai_presence. The guidance is strong but lacks exclusionary notes.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior, and the description adds useful mechanics beyond that: it routes across thousands of verified sources, auto-fills arguments, and returns structured answers with citation URIs. No contradiction exists between description and annotations, though failure modes and limitations are not disclosed.

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 opening is front-loaded and information-dense, but the description contains an apparent verbatim repetition: the phrase 'even if web search could also answer it. Examples: ... START HERE for most questions' appears twice. This redundancy wastes tokens and prevents the description from being 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?

For a single-required-parameter tool with no output schema, the description covers the key context: domain coverage, trigger phrases, example questions, source count, argument-filling behavior, and the citation-URI return format. It lacks caveats about sibling variants, ambiguous questions, or fallback behavior, but it is largely complete for selecting and invoking the tool.

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

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

Schema description coverage is 100%, and the schema already documents the 'question' parameter and all aliases as natural-language input. The description's examples reinforce the expected style but do not add meaningful parameter-level semantics beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description clearly identifies the tool as a natural-language fact-query router: it 'Routes the question to the right one of 5,798 tools across 1517 verified sources, fills arguments, returns the structured answer with stable pipeworx:// citation URIs.' This is a specific verb+resource statement with a broad domain list. It does not distinguish this tool from sibling variants ask_pipeworx_beta or ask_pipeworx_grounded, so it misses the top score.

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

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

The description gives explicit trigger phrases ('what is', 'look up', 'find', 'get the latest') and tells agents to PREFER OVER WEB SEARCH for authoritative factual questions, even providing concrete examples. It also says 'START HERE for most questions,' which is strong routing guidance. However, it provides no exclusions and does not explain when to use the sibling ask_pipeworx variants instead.

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 is highly transparent: it explains that candidate routing improvements may or may not be active, notes that no candidate is currently active, and confirms the tool is a full working router with no fallback. This adds valuable behavioral context beyond the annotations, such as the experimental nature and current parity with ask_pipeworx.

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

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

The description is somewhat dense but every sentence carries meaningful information: beta identity, current no-candidate status, usage guidance, and no-fallback guarantee. The key point about being experimentally equivalent to ask_pipeworx is front-loaded. A few parentheticals add extra detail without being purely redundant.

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

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

Given that this is a beta wrapper around ask_pipeworx, the description provides essential context: current parity with the stable version, the experimental purpose, and the routing comparison workflow. It does not describe the actual response shape, but it explicitly says it is the same as ask_pipeworx, which is sufficient given the sibling relationship and absence of an output schema.

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

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

The input schema already fully documents all six parameters, including the alias relationships for q, text, input, query, and prompt. The description adds general context about arguments being the same as ask_pipeworx but does not provide any new parameter-level semantics. With 100% schema coverage, the baseline score of 3 is appropriate.

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

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

The description clearly identifies this as the beta version of ask_pipeworx, a universal router with the same tools, arguments, and response shape. It distinguishes itself from the stable ask_pipeworx by its experimental routing improvements. However, it does not independently explain what the universal router does, relying on the reader's understanding of ask_pipeworx.

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

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

The description explicitly states to use this tool exactly like ask_pipeworx when you want the newest routing, and explains that results are compared against the stable router. This gives a clear use condition and names the primary alternative. It stops short of explicitly saying 'do not use for stable production routing', but the implication 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?

The description goes well beyond the readOnlyHint, idempotentHint, openWorldHint, and destructiveHint annotations by disclosing the exact success return shape, the refusal_reason enum values, the verbatim-evidence behavior, and the extra LLM call cost. This gives an agent a precise model of what will happen, including failure modes, without contradicting any 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 information-dense without being bloated, and the most important differentiator—hallucination-resistant grounded answering—is front-loaded. Every subsequent sentence earns its place: routing behavior, return contract, refusal reasons, usage guidance, and cost tradeoff.

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 present, the description compensates thoroughly by specifying both success and refusal response shapes, including the refusal_reason enum. It also covers the key invocation decision (grounded vs casual) and the internal routing behavior, so an agent has enough context to select and call the tool correctly.

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

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

Schema description coverage is 100%, with all six parameters documented as aliases for the natural-language question. The tool description adds no parameter-specific semantics, but that is acceptable because the schema already fully explains the single logical input; the baseline of 3 applies.

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

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

The description states a specific verb/resource pair: a hallucination-resistant answer mode for high-stakes reads. It clearly differentiates from ask_pipeworx by explaining that it routes identically but extracts answers only from tool results, which is a distinctive behavioral contrast.

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 when to use this tool: whenever an answer will be quoted, cited, or acted on and the agent must not invent facts, with concrete domains like financial verdicts, legal claims, medical lookups, and public statements. It also gives the alternative guidance: prefer ask_pipeworx for casual lookups because this mode costs one extra LLM call.

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

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

Annotations indicate read-only, idempotent, non-destructive. Description adds extensive behavioral details: fan-out to data sources, low-confidence short-circuiting, closed/dead market handling, wide-spread warnings, resolution-rule risk parsing, and parent-event extraction. No contradictions with annotations.

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

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

Description is long but front-loaded with purpose and usage. Detailed sections cover classifiers, examples, response shapes, resolver contract, and safety. Could benefit from white-space separation or bullet lists, but every section adds value for a complex tool.

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

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

Given the tool's complexity (3 params, no output schema), the description is remarkably complete: input types, fan-out behavior, response structure (market, analysis, evidence), resolver contract, parent-event extraction, news fields, safety mechanisms, and resolution-rule parsing. Leaves no significant gaps.

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

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

Schema provides descriptions for all 3 parameters (market, depth, include_raw). Description adds meaning: input formats (slug, URL, question text), depth options (quick vs thorough with source counts), include_raw behavior (summarized vs full payloads). This exceeds basic schema coverage.

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

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

The description clearly states the tool's purpose: research a Polymarket bet by pulling Pipeworx data in one call. It specifies acceptable inputs (slug, URL, question text) and outputs (evidence packet + comparison). This distinguishes it from siblings like polymarket_arbitrage which focus on arbitrage, not 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?

Explicitly recommends use cases: 'should I bet on X', 'what does the data say about Y', 'is there edge in Z'. Includes classifier list and fan-out examples for different bet types. Does not explicitly state when not to use it or provide alternatives, but sibling tools cover different functionalities.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds that it returns 'event category codes' and that they are for a filter, providing domain context beyond what annotations offer.

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?

A single, front-loaded sentence with no wasted words. Every part of the description is necessary and efficiently conveys the tool's 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?

Given no parameters, no output schema, and clear annotations, the description is fully complete for a simple listing tool. The sibling list includes search_events, making its usage context obvious.

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

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

The input schema has zero parameters, so the baseline is 4. The description does not need to add parameter info; it adds value by explaining the tool's output (codes for a filter).

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

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

The description uses a specific verb 'List' and identifies the resource 'Skiddle event category codes' with a clear purpose for the 'search_events category filter'. It effectively distinguishes itself from sibling tools like search_events.

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 used for obtaining category codes for search_events, implying when to use it. It does not explicitly state when not to use it, but the context is clear and connects to a sibling tool.

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

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

Beyond annotations (readOnly, idempotent), description details data sources, handling of off-calendar fiscal years, sorting by primary metric, and citation URIs. 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?

Description is moderately long but efficient, with each sentence adding value (examples, data sources, sorting, alternatives). Could be slightly more terse, but well-structured.

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

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

Despite no output schema, description covers return format (paired data + citations), data sources, and sorting. With only 2 parameters, it fully explains tool behavior and output.

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: explains type enum values (company vs drug) with specific data sources, and values parameter with examples and limits (tickers/CIKs for company, drug names).

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 tool performs side-by-side comparison of 2-5 companies or drugs, with specific data sources (SEC EDGAR, FAERS). Distinguishes from single-entity lookups by explicitly preferring over sequential calls.

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

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

Provides explicit triggers ('X vs Y', 'which is bigger') and states 'ALWAYS PREFER over sequential single-pack lookups when comparing entities.' Offers clear guidance on when to use.

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

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

Annotations already mark the tool readOnly, openWorld, idempotent, and non-destructive, and the description adds substantial behavioral context: latency expectations, auth requirements, never-invented gaps[], fetchable citation_uri values, contradictions[] on standard/thorough, and semantic excerpting rather than head-truncation. No contradiction with annotations.

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

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

The description is front-loaded with useful information, but it repeats the sentence 'For a single lookup use ask_pipeworx.' four times, which is pure redundancy. Most other sentences earn their place, but the repetition makes the definition noticeably bloated.

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

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

There is no output schema, but the description compensates thoroughly by specifying the findings packet, gaps[], contradictions[], citation_uri/hop fields, latency, auth requirements, and when to use alternatives. For a tool with this much complexity, nothing critical 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 input schema already documents both parameters in full detail, including the depth enum semantics and the paid nature of thorough, so the baseline is 3. The description restates much of this but does not add substantially new parameter-level meaning beyond the schema.

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

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

The description clearly states the tool performs grounded multi-source research across 1517 structured data sources in one call, explicitly distinguishing it from open-web search. It also mentions the decompose/route/return packet mechanism, so an agent can tell what the tool does and how it differs from siblings like ask_pipeworx.

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

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

Usage guidance is explicit: best for broad/multi-part questions over structured data, and single lookups should use ask_pipeworx. It also tells agents to use ask_pipeworx when the user is not signed in and warns that the thorough depth requires a paid plan. This is strong when-vs-alternative routing.

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

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

Annotations declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds that results include full input schemas with curated examples and are ready to call directly, which is consistent and adds value.

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

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

The description is three sentences long and each sentence adds value: purpose, usage guidance, and detail about returns. It is efficient but not overly terse.

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 6 parameters (mostly aliases) and no output schema, the description adequately explains what the tool returns and when to use it. It provides sufficient context for an agent to decide and invoke.

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

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

Schema description coverage is 100% with all parameters documented. The description reiterates that the query parameter accepts natural language and lists aliases, but adds little beyond what the schema already provides.

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

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

The description clearly states the tool's purpose: 'Find tools by describing the data or task.' It lists numerous domains and distinguishes from siblings by being a discovery tool that returns a set of ready-to-call tools.

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

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

Explicitly says 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' Provides clear context, though no explicit 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?

Beyond the readOnly/idempotent/open-world annotations, the description discloses fan-out across sources, sources_used/sources_failed semantics, that empty sections mean real 'no data' rather than bugs, GDELT→GNews fallback behavior, and that missing small-molecule drug listings are expected. This is rich behavioral transparency.

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

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

The description is dense and front-loaded with user intent examples, and every sentence contributes useful information. However, it is delivered as one long semicolon-heavy paragraph that could be better structured for machine parsing and quick 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?

With no output schema present, the description carries the full burden of explaining return semantics, and it does so thoroughly: it enumerates all returned sections, source coverage, fallbacks, no-data behavior, and resolution edge cases. For a complex multi-source tool, this is exceptionally 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?

Although the schema already covers both parameters, the description adds genuine value: 'type' values are interchangeable, 'value' can be a ticker, zero-padded CIK, or company name regardless of type, and names resolve via SEC EDGAR's company-name match. Concrete examples like AAPL, 0000320193, and Moderna further clarify expected input formats.

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

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

Description opens with concrete user utterances ('Tell me about X', 'research Acme') then states the specific function: 'full cross-source profile of a US public company in ONE parallel call.' It identifies the resource, the verb, and distinguishes itself from chaining single-source lookups.

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

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

It explicitly instructs 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view,' giving the agent a clear routing rule. It also defines accepted input shapes and the private-company fallback behavior, so the agent knows when and how the tool applies.

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, and non-destructive behavior. The description adds valuable context by specifying that the response includes full details and venue, which goes 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?

Single efficiently worded sentence that front-loads the key information with no unnecessary words.

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

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

For a simple single-parameter read tool with good annotations, the description fully covers the purpose and what the result contains, making it complete for agent selection and invocation.

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

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

Schema coverage is 100% with a clear parameter description. The description does not add extra meaning beyond what the schema already provides.

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

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

Clearly states the verb 'Get', the resource 'single Skiddle event by id', and specifies the scope ('with full details and venue'), distinguishing it from sibling 'search_events' which would list multiple events.

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?

Implied usage (use when you have an event ID) is clear, but no explicit guidance on when not to use or alternatives (e.g., search_events) is provided.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false. The description adds that it deletes a 'previously stored memory' and provides context for sensitive data, complementing annotations well.

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

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

Two sentences, front-loaded with the main action, no unnecessary words. Every sentence adds value.

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

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

For a simple tool with one parameter and no output schema, the description covers purpose, usage, and relationship to siblings comprehensively.

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

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

Schema coverage is 100%, and the parameter 'key' is already described in the schema. The description does not add additional 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 deletes a previously stored memory by key, using a specific verb and resource. It distinguishes itself from siblings like remember and recall by mentioning pairing.

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 conditions for use are provided: stale context, task done, clearing sensitive data. Also suggests pairing with remember and recall, giving guidance on alternatives.

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

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

Annotations already declare readOnlyHint (safe read) and non-destructive. The description adds behavioral details: fetches the page, extracts title/description/key links, emits standard markdown format, and output is a single text blob. 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 concise and front-loaded with the purpose. It includes key details (fetching, extraction, format) without unnecessary words. Minor room for tighter phrasing, but overall efficient.

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

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

Given the tool's low complexity (2 parameters, no output schema), the description is complete. It explains the output format and provides use cases. Missing a note about error handling, but not critical for a simple 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 description coverage is 100%, with clear descriptions for both 'url' and 'max_links'. The tool description does not add extra semantic context beyond what the schema already provides, so baseline score of 3 is appropriate.

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

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

The description clearly states the tool's function: generate an llms.txt file for any URL. The verb 'Generate' and the specific resource 'llms.txt' clearly define the action. Since no sibling tool performs a similar function, it is well-distinguished.

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 own project, auditing competitors. While it doesn't specify when not to use it, the listed uses give clear guidance.

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

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

Annotations already declare readOnlyHint and idempotentHint. The description adds value by listing return fields but does not disclose additional behaviors like pagination or rate limits. However, for a read-only list tool, this is adequate.

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

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

Two sentences, no wasted words. The first sentence defines purpose and output, the second provides usage guidance. Front-loaded with the most important 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?

For a simple list tool with 0 required parameters and one optional boolean, the description covers purpose, usage, and return fields. No output schema exists, but the description lists the fields. Complete for this complexity level.

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

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

Schema coverage is 100% with a clear description for the single parameter 'include_inactive'. The description does not re-iterate parameter details, but it's not needed since the schema already documents it well. 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 action (list) and resource (the caller's active subscriptions), and specifies the exact fields returned. It distinguishes itself from siblings like 'subscribe' and 'unsubscribe'.

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

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

Explicitly advises when to use: 'before adding more' or to 'find an id to cancel', providing clear context and implying alternatives like 'subscribe' and 'unsubscribe'.

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

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

Even with annotations already indicating the tool is not read-only, the description adds crucial behavioral details: the dual-mode behavior (filing vs. checking via claim_token), rate limiting ('Rate-limited to 5 per identifier per day'), and that it's free and doesn't count against tool-call quota. This goes beyond what annotations provide and helps anticipate side effects.

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

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

The description is quite long but every sentence carries a specific purpose, covering use cases, exclusions, token mechanics, rate limits, and roadmap impact. It is well-structured, starting with the core purpose and then branching into details, but could be trimmed slightly without losing meaning.

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

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

The tool has a complex dual-mode behavior and constraints (exclusions, rate limits, claim_token flow). The description covers all scenarios: new submission, token-based status check, tool attribution, and rate limit. It is complete enough for an agent to know when and how to invoke it, even 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?

The input schema already provides 100% description coverage for all four parameters. The description adds semantic value by explaining how the `claim_token` parameter is used to later retrieve status ('pass it back later as pipeworx_feedback({claim_token:"pwfb_…"})') and offers guidance for `message` content ('don't paste the end-user's prompt'). This is a modest enrichment 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: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' This uses a specific verb and resource, and distinguishes it from siblings by emphasizing it is for feedback about Pipeworx tools, not for questions or data lookup.

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

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

The description provides explicit when-to-use conditions: 'Use when a tool returns wrong/stale data (bug)...' and explicitly excludes other MCP servers: 'if the tool came from a different MCP server... file it with that server instead.' It also offers a fallback for uncertainty: 'Not sure? Pipeworx tool names are the ones this connection lists.'

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint false. Description adds valuable context: self-aggregating, derived from CF analytics-engine, no PII, caching behavior (5min-1h depending on window).

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 plus a bullet list. Every sentence adds value with zero fluff. Front-loaded with key information about what the tool returns.

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?

Lacks explicit return format but provides enough (top tools, top packs, total call volume). With strong annotations and simple tool, description is sufficient. Could mention response structure.

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 enum and description. Description adds context about shorter windows surfacing hot items and longer windows showing steady-state demand, slightly 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?

Description clearly states it returns top tools, top packs, and total call volume over a recent window, with specific use cases. It distinguishes itself from siblings like discover_tools by focusing on popularity 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 lists three use cases (discovering hot data sources, confirming canonical choices, checking alignment) and explains how window choice affects results (hot vs steady-state).

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

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

Annotations already declare read-only, idempotent, and non-destructive hints, but the description adds rich behavioral context: the scan scope, Jaccard similarity filter, partition filter, and the fill check logic. 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 detailed and structured, with clear sections for each mode. While it is somewhat lengthy, every sentence contributes useful information. It could be slightly more concise, but the structure is front-loaded and logical.

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

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

Given the tool's complexity and the absence of an output schema, the description covers the return structure (opportunities array with fields) and important edge cases like the fill check. It lacks explicit mention of empty return cases, but overall it provides sufficient context for an agent to use the tool effectively.

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

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

The input schema covers 100% of parameters, and the description adds substantial meaning: explains what event slugs and topic seed questions look like, gives examples, and describes how each parameter affects the scan mode and output. This goes well beyond the schema descriptions.

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

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

The description clearly states the tool's purpose: finding arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It distinguishes three modes (no args, event, topic) with specific use cases, making it unambiguous for an AI agent.

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

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

The description provides explicit guidance on when to use each mode (no args for trending scan, event for specific market, topic for cross-event scanning) and even directs the agent to use polymarket_fill_risk for custom sizing. It also advises against trading when the fill check shows no edge, offering clear do-not-use conditions.

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 signal readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds significant behavioral context beyond annotations: it explains caching (1h at KV level keyed on knobs), diagnostic sections to explain empty segments, inclusion of 24h move warnings, and slippage assumptions. 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 long but densely informative, front-loading the core purpose. Every sentence adds value, but the technical depth (e.g., model families, correction factors) may burden agent parsing. A slight trim could improve conciseness.

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

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

Given the tool's complexity (9 parameters, no output schema), the description is exceptionally complete. It covers all segments, diagnostics, caching, tradeable-edge filters, and caveats (Fed bets). No critical gaps remain for agent decision-making.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaningful semantics beyond schema, e.g., explaining why min_kelly does not filter partition arbs and how min_partition_leg_kelly compensates, and clarifying that edge is net of slippage. These details help an agent understand parameter interplay.

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 specifies the tool's purpose: scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price. It explicitly states the use case 'what should I bet on today' and distinguishes itself from siblings like polymarket_arbitrage and polymarket_edge_tracker by detailing its unique model-driven, structural arbitrage, and concentrate longshot segments.

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 strong usage guidance: it tells agents to use this tool for discovering opportunities without manual paging, defines tradeable-edge knobs (min_liquidity, max_spread_pp) for filtering, and notes that Fed bets are excluded from ranking. However, it does not explicitly state when not to use it or name alternatives, leaving slight ambiguity.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, providing a strong baseline. The description adds critical non-obvious behaviors: 60-day snapshot TTL, snapshots written only on cache miss (gaps mean no scan that day), and decay computed from daily closes not intraday. This exceeds annotation coverage and fully informs the agent.

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 but front-loads the key question and uses examples effectively. It earns its length by providing essential operational details, though it could be slightly more structured with bullet points or explicit sections to improve scanability.

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 two optional parameters, no enums, no nested objects, and no output schema, the description is exceptionally complete. It covers input defaults and constraints, output structure with all fields explained, data source behavior (cache-miss gaps, snapshot start dependency), and limitations (60-day TTL). No gaps remain for an agent to make informed decisions.

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, but the description adds context-specific defaults (days default 14, max 30; window default '1wk') and explains their purpose within the tool's logic. Additionally, the description thoroughly documents all three output arrays (tracked, expired, snapshot_dates) with detailed field explanations, compensating for the lack of an output 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 that the tool provides edge persistence and decay telemetry derived from daily polymarket_edges snapshots, using the specific question 'how long has this edge existed and is it shrinking?' as a concise purpose statement. It differentiates from the sibling tool polymarket_edges, which likely provides current snapshots, by focusing on historical time-series analysis.

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

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

The description implies when to use this tool by contrasting fresh edges with older ones ('a 3-week-old wide edge is wide for a reason'), but it does not explicitly state when not to use it or name alternatives. However, the context signals show sibling tools like polymarket_edges, and the description's focus on persistence suggests it is the next step after obtaining current edges.

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. The description adds rich behavioral details: walking the order book ladder, returning fields like slippage_pp, verdict, and the warning that partial basket fills convert arb into directional risk. This goes beyond annotations.

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

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

The description is dense but somewhat verbose. It front-loads purpose and modes, but the detail on return fields and risks makes it lengthy. Could be more concise while retaining key info.

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

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

Given the tool's complexity, absence of output schema, and high parameter count, the description covers all essential aspects: input modes, parameter behavior, return values, and usage context. It is fully self-contained.

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

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

Schema coverage is 100%, but the description adds meaning beyond schema names: clarifies side default for basket (auto based on partition sum), size_usd interpretation differences between single-market and basket, and the clamp range. This helps the agent select correct 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 states it performs a 'Realizable-vs-theoretical edge check against live CLOB order-book depth' and clearly distinguishes two modes (single-market and basket). It differentiates from sibling tools like polymarket_arbitrage and polymarket_edges by framing itself as a pre-trade risk check.

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

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

Explicitly tells when to use: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500'. It explains why partial fills are dangerous and implies when not to use (trades below threshold).

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

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

Beyond the readOnly/openWorld/idempotent annotations, the description discloses many non-obvious behaviors: gross spreads do not model Kalshi fees, compatibility_codes can be non-empty even when pairs are returned, unknown-type legs are never paired, pairing_unverified applies in both modes, and temporal_alignment null has a specific meaning. This is exemplary behavioral disclosure.

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

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

The description is long but well-structured with prefixed labels like RESPONSE, SAFETY FIELDS, and Codes, and it front-loads the core purpose. Some details are repeated (e.g., compatibility codes and temporal_alignment semantics are explained multiple times), so it is slightly heavier than it needs to be, but no section is truly wasted.

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

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

With no output schema present, the description compensates thoroughly by enumerating the response shape, spread fields, compatibility codes, skipped counters, and fee caveats. An agent has enough information to understand what the tool returns, what the flags mean, and how to interpret edge cases, which is complete given the tool's complexity.

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

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

Although the input schema already has 100% description coverage, the tool description adds critical semantic context: the topic parameter is a pre-mapped shortcut, kalshi_event_ticker and polymarket_event_slug override the topic-mapped side, and explicit custom pairings go through the same matching logic. This materially enriches parameter understanding.

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

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

The description clearly states the tool computes/returns cross-venue spread between Kalshi and Polymarket for the same resolving question, with explicit modes and expected outputs. It lacks an explicit verb like 'fetches' or 'calculates' and does not directly contrast itself with the sibling polymarket_arbitrage, but the resource and behavior are unmistakable.

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

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

The description strongly guides usage: it distinguishes the two modes (topic shortcuts vs explicit ticker/slug), explains that BOTH modes run the same matcher, and warns that pre-mapped topics are often not tradeable. It does not explicitly name alternatives among siblings, so it stops short of a 5.

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

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

Annotations already provide readOnlyHint, destructiveHint, idempotentHint. Description adds scoping context ('Scoped to your identifier (anonymous IP, BYO key hash, or account ID)') which adds behavioral transparency beyond annotations.

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

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

Three sentences, front-loaded with main action, no wasted words. Every sentence adds value.

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

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

For a simple tool with one optional parameter and no output schema, the description is complete: covers purpose, usage guidelines, scoping, and interaction with siblings.

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 semantic depth by explaining the optional key parameter behavior ('omit the key argument') and provides concrete use case examples (target ticker, address, research notes).

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 'Retrieve a value previously saved via remember, or list all saved keys (omit the key argument).' It distinguishes itself from sibling tools remember and forget by explicitly naming them.

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

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

Description explicitly states when to use ('to look up context the agent stored earlier') and when not to need re-derivation. It names alternatives: 'Pair with remember to save, forget to delete.'

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 contradicts the readOnlyHint annotation by describing the mark_read parameter, which modifies state (flags events as read). While the description is transparent about this behavior, the contradiction reduces reliability. Score 1 per rubric for 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 four sentences, front-loaded with the main purpose, and every sentence adds distinct value (return format, filtering, mark_read effect, alternative access). No redundant or wasted words.

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

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

Given five parameters, no output schema, and good annotations, the description covers return format, filtering, mark_read behavior, and an alternative endpoint. However, the contradiction with readOnlyHint slightly undermines completeness for agents interpreting the tool's safety profile.

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 has 100% coverage with descriptions for each parameter. The description adds value by providing examples (e.g., 'sec_8k' for type), specifying ISO timestamps, and explaining the effect of mark_read (next call shows newer events). This is more than the baseline of 3.

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

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

The description clearly states the tool pulls fired events from a subscription feed, specifies what each alert carries (source, citation_uri, payload), and outlines filtering options (type, since). It is a specific verb-resource pair with concrete details, distinguishing it from generic tools.

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

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

The description provides context for usage, mentioning that polls work fine and that the same feed is accessible via HTTP for scripts/dashboards. It does not explicitly differentiate from sibling tools like search_events, but the filtering and mark_read behavior imply typical use cases for recent alerts.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds value by detailing the fan-out to multiple sources, rate-limiting fallback, and return structure (changes grouped by source, citation URIs). It does not contradict annotations.

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

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

The description is slightly verbose but well-structured: trigger phrases first, then sources, parameter details, fallback, and sibling comparison. Every sentence adds value, though it could be trimmed slightly without loss.

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

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

Given the complexity (multiple sources, fallback, relative date parsing, citations), the description is comprehensive. It explains the behavior, limitations (soft-fail for USPTO), and even hints at future reactivation. It describes the return structure despite no 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?

With 100% schema coverage, the baseline is 3, but the description adds significant value: explains that `type` is currently only 'company', `since` accepts ISO dates and relative shorthand with examples, and `value` accepts ticker or CIK. It also suggests typical usage ('Use 30d or 1m').

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 a change feed for a company over a recent time window, fanning out to multiple sources (SEC, GDELT/GNews, USPTO). It distinguishes itself from sibling tools like entity_profile, making the purpose unmistakable.

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

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

The description provides explicit usage guidance with example queries ('What's new with X'), explains when to use this tool vs entity_profile, and details fallback behavior (GDELT→GNews) and soft-fail for USPTO. This helps the agent decide correctly.

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 idempotentHint=true, destructiveHint=false, and readOnlyHint=false. The description adds valuable behavioral details: storage is scoped by identifier, memory persistence differs for authenticated users (persistent) vs anonymous (24 hours). This goes beyond annotations, though the description doesn't detail failure modes or limits.

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 (four sentences) and front-loaded with the core purpose. Every sentence adds value: purpose, use case, scoping, persistence, and related tools. 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 tool's simplicity, no output schema, and clear annotations, the description covers all needed context: what to store, when, persistence rules, and related tools. It is complete for an agent to select and use the tool correctly.

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

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

Schema coverage is 100% with descriptions for key and value. The description adds examples (e.g., 'subject_property', 'target_ticker') that enrich meaning and help the agent choose appropriate keys. This provides context beyond the schema's generic descriptions.

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

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

The description clearly states the tool's purpose: 'Save data the agent will need to reuse later.' It specifies the action (save), resource (key-value pair), and context (across conversations/sessions). It distinguishes from sibling tools like recall and forget explicitly, making the agent's selection unambiguous.

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

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

The description provides explicit guidance on when to use: 'when you discover something worth carrying forward... so you don't have to look it up again.' It also mentions pairing with recall and forget, though it doesn't explicitly state when not to use or mention alternatives. Overall, clear usage 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 already declare read-only/open-world/idempotent behavior, and the description adds substantial non-obvious behavior: explicit `unresolved` fields, `figi_candidates` on ambiguity, graceful degradation when GLEIF/OpenFIGI are down, and cross-source identity stitching. 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 heavily front-loaded and information-dense, but the company-type section is one enormous run-on parenthetical with multiple nested clauses. There is useful material, yet it is poorly structured and much longer than needed to convey the same guidance.

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 output shape (source-labelled IDs, `unresolved`, `figi_candidates`, RxNorm citation), input acceptance, edge cases, and failure/degradation behavior. For a two-parameter resolver, this is complete enough 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 goes beyond the schema by giving concrete accepted values (AAPL, 0000320193, CH0038863350) and warning against trailing security-class words. This materially helps an agent format the `value` parameter correctly.

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

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

The opening phrase 'resolve a user-spoken NAME to the canonical/official identifiers other tools require as input' states a specific verb (resolve), resource (name-to-identifier), and outcome. It also gives many concrete trigger examples and names the supported entity types, making it easy to distinguish from sibling entity tools.

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

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

Explicitly says 'Use FIRST whenever you have a name but need an ID', which is strong when-to-use guidance. It lacks an explicit when-not-to-use clause or named alternatives, though the trigger examples cover the common decision points.

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, destructiveHint=false. Description adds that it probes each entity with ai_visibility_check, returns a ranked list, and surfaces most/least recognized—behavioral details beyond 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?

Two concise sentences with no wasted words. Front-loaded with verb and resource, immediately useful 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?

Given 4 parameters (all described in schema), no output schema, and rich annotations, the description explains the high-level output structure (ranked list with score, confidence, signal density). One might wish for more detail on signal density, but overall sufficient.

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

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

Schema coverage is 100%, so baseline is 3. Description does not add extra semantic meaning to parameters beyond what schema already provides.

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

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

Description uses specific verb 'Compare' and resource 'AI visibility across multiple entities', and clearly states it ranks by score and surfaces most/least recognized. It distinguishes from sibling ai_visibility_check by focusing on multi-entity comparison.

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

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

Provides explicit use case ('competitive AI-marketing audits') and an example question. Does not explicitly state when not to use or name alternatives, but context is clear enough for a typical 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?

Adds significant behavioral context beyond annotations: mentions partial failure degradation, bundlephobia's first measurement can take 5-30s, and that sources_failed will list timeouts. Annotations already declare readOnly, openWorld, idempotent, non-destructive.

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 longer but each sentence adds important detail. It front-loads the core purpose and then provides structured output and edge-case info. Could be slightly trimmed but not excessive.

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 the return structure (summary block fields, per-advisory detail, links, alternative versions) and partial failure behavior. Extremely complete for a tool with only two parameters.

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

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

Input schema has 100% coverage with descriptions for both parameters (package and version). Description adds minimal extra meaning beyond schema, such as mentioning 'scoped packages accepted' which is already in schema. Schema does the heavy lifting.

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 composite nature of the tool for checking npm packages across deps.dev and bundlephobia, listing specific aspects like license, advisories, bundle size, etc. It distinguishes itself from sibling tools by focusing on a specific npm package evaluation.

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 an agent asks "is X safe / popular / small" or "what does adding lodash cost me"'. Also notes ecosystem limitation (NPM only) and directs to deps.dev:version for other ecosystems.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds behavioral context: results sorted by date or distance, default radius 10 miles, and location-based filtering. No contradictions. With good annotations, the description provides useful additional transparency.

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 concise sentences. The first sentence defines the tool's scope and supported event types. The second lists key filters and sorting. Efficient and front-loaded.

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

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

No output schema is present. The description covers filters and sorting, but does not mention pagination (offset/limit) or result structure. Schema fills some gaps, so overall it is quite complete for a search tool with well-documented parameters.

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

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

Schema coverage is 100%, so baseline is 3. The description groups parameters (location, keyword, category, date window) but does not add meaning beyond the schema descriptions. No new semantic insights are provided.

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

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

The description clearly states it searches UK events and lists event types (gigs, club nights, festivals, comedy, theatre, exhibitions). It distinguishes from siblings like 'event' (single event retrieval) and 'categories' (listing categories) by specifying the broad search and filtering capability.

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

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

The description implies usage for searching events but does not explicitly state when to use this tool vs alternatives like 'event' for specific event details or 'categories' for category codes. It briefly mentions using the categories tool, but lacks exclusions or decision guidance.

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

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

The description adds technical details beyond annotations: 'BGE-base-en embeddings + cosine over 500-char overlapping windows; cap is 200K chars (longer inputs are truncated and flagged)' and explains that passages carry offsets for verification. Annotations already indicate read-only, idempotent, open-world, so 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 four sentences, front-loaded with purpose, and every sentence adds essential information without redundancy. It is concise and well-structured.

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

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

Given no output schema, the description covers what is needed: purpose, usage, technical details (embedding, window, cap, offsets), and pairing with sibling tool. It is 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 good description of each parameter. The description adds value by reiterating the cap and truncation for 'text' and providing example queries for 'query'. While not adding entirely new semantics, it reinforces and clarifies, especially the max length and truncation behavior.

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

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

The description clearly states the tool performs semantic search inside a fetched record, with specific examples (SEC 10-K, article) and explicitly distinguishes it from siblings by noting when to use it (record too large for prompt) and pairing with ask_pipeworx_grounded.

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

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

The description provides explicit guidance on when to use the tool ('Use when the record is too big to cram into the prompt') and mentions a sibling tool (ask_pipeworx_grounded) for grounding, giving clear context for 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 description adds significant behavioral context beyond annotations: it explains the return value (subscription id), prerequisites (OAuth account), supported types with examples, delivery channels (feed, email, sms, webhook) with constraints (SMS verification, caps, webhook signing secret one-time, auto-disable). No contradiction with annotations (idempotent, non-destructive).

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: first sentence captures purpose, then details supported types and delivery channels. Every sentence adds information. Minor reduction could be made but overall justified given 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?

No output schema, but description mentions return value. Parameters are fully covered. The description includes edge cases (SMS verification, webhook auto-disable, signing secret one-time). Complete for a subscription creation tool with no 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%, so baseline 3. The description adds concrete examples for each type (e.g., 'items:["5.02"]') and explains delivery fields (webhook HMAC signing, SMS verification). This adds value beyond the schema's property descriptions.

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

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

The description clearly states the tool's purpose: 'Create a proactive monitoring subscription to a live-data event stream. Returns the new subscription id.' It uses a specific verb ('Create') and resource ('subscription'), and distinguishes from sibling tools like 'unsubscribe' and 'list_subscriptions'.

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

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

The description provides clear context for when to use, listing supported subscription types and requiring a Pipeworx OAuth account. It does not explicitly state when not to use or compare to alternatives, but the examples and delivery options give strong guidance.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint false. The description adds valuable context: returns category-bucketed examples with exact tool+argument shapes, drawn from live catalog. 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 relatively long but front-loaded with common queries. Every sentence adds value, though slight trimming possible. Structure is clear with examples and guidance embedded.

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 fully covers return structure: category-bucketed example questions with exact tool+argument shapes. It also addresses the full use case (onboarding, discovering capabilities, learning meta-tools).

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

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

Schema covers 100% of parameters. Description adds meaning by explaining what 'topic' values are acceptable and the effect of omitting vs including it ('full spread' vs 'focus').

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 Pipeworx, with specific verb 'returns' and resource 'category-bucketed example questions'. It distinguishes from siblings by being the onboarding entry point, mentioning meta-tools like ask_pipeworx, entity_profile, etc.

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, or to learn how to call the meta-tools'. Also provides guidance on when to omit vs pass a topic, and lists possible topic values.

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 readWrite, idempotent, and non-destructive hints. The description adds valuable behavioral context beyond annotations: ownership enforcement (auth requirement) and the fact that rows are deactivated not deleted, preserving history. This fully informs the agent of critical constraints and effects.

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

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

The description is three sentences, each serving a distinct purpose: stating the action, imposing an ownership constraint, and explaining the side effect. No extraneous words or redundancy; it is efficiently front-loaded.

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

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

Given the tool's simplicity (single required parameter, no output schema), the description fully covers the purpose, authorization, and side effects. It references a sibling tool ('recent_alerts') to clarify the impact, which enhances completeness. No missing information is apparent.

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 covers 100% of parameters with descriptions. The description reiterates 'by id' but adds no new semantic details beyond the schema's 'Subscription id (uuid) returned by subscribe.' This meets the baseline expectation without exceeding it.

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

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

The description explicitly states the action ('Cancel a subscription') and the resource ('by id'). It also distinguishes from sibling tools like 'subscribe' by indicating cancellation, and from 'list_subscriptions' by being a mutation. The ownership enforcement further clarifies the scope.

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

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

The description clearly implies when to use this tool (to cancel a subscription) and provides important context about ownership (you can only cancel your own). However, it does not explicitly discuss when not to use it or mention alternatives, but the singular purpose is sufficiently clear.

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

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

Beyond the readOnly/openWorld/idempotent annotations, the description discloses important behavior: the dual-path execution, the verdict vocabulary, the presence of citations, the critical distinction between 'could_not_verify' (check did not happen) and 'unsupported' (no source found), and a warning not to treat 'could_not_verify' as evidence. This is rich, non-obvious context.

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

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

The description is front-loaded with query examples and a one-sentence definition, followed by concise, information-dense elaboration. Every sentence earns its place, including caveats and efficiency notes, without being bloated.

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

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

For a tool with no output schema, the description fully covers return values (verdict types, actual value, citation, reasoning), error semantics, and usage boundaries. It leaves no critical operational ambiguity for an agent.

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

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

Schema coverage is 100%, so both parameters are already well-documented. The description adds no extra parameter-specific meaning (e.g., tolerance_pct override behavior is only in schema), so baseline 3 is appropriate.

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

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

The description uses a specific verb ('validate'/'verify') with a clear resource ('natural-language claim verification against authoritative sources') and includes user-intent examples. It distinguishes itself from sibling tools by explicitly covering both structured and grounded pipelines, making its scope unmistakable.

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

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

Provides an explicit 'Use whenever...' directive for factual verification, clarifies that it handles both company-financial and any other factual claims via automatic fall-through, and notes that it replaces 4–6 sequential calls. This gives clear context and efficiency rationale, though it does not name alternative tools explicitly.

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