Cso Ie

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

The description adds meaningful context beyond the readOnly/openWorld/idempotent annotations: the default model is free (Workers AI Llama-3.3-70b) and using Anthropic requires a BYO key with direct payment to Anthropic. This discloses cost implications and the range of possible behaviors.

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 dense sentences: purpose and output, default/optional model behavior, and use cases. No fluff, content is front-loaded, and every sentence earns its place.

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

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

Despite no output schema, the description spells out the return shape (per-model {score, confidence, signals, raw_response} + combined view) and covers default behavior, optional parameters, and real-world use cases. This is sufficient for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by naming the default model (Llama-3.3-70b), clarifying the free/paid distinction, and noting that the API key is passed straight through—details that enrich the schema's brief parameter descriptions.

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

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

The description opens with a specific verb ('Probe') and resource ('LLMs'), and defines the deliverable as a 0-100 visibility score per model. This clearly distinguishes it from siblings like ask_pipeworx (question-answering) and scan_competitor_ai_presence (competitor-focused scans).

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 use cases are provided ('AI-marketing audits, pre-launch brand checks, competitive monitoring'), giving clear context for when to invoke this tool. It does not name alternative tools or state exclusions, so it falls just short of a 5.

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

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

Annotations already declare readOnly/openWorld/idempotent, but the description adds meaningful context about routing behavior, stable citation URIs, and performance ('one fast call'). This goes beyond annotations by explaining how the tool selects sources and returns results, though it doesn't detail rate limits or failure modes.

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

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

The description is long but information-dense, front-loading the most critical guidance ('PREFER OVER WEB SEARCH'). Every section earns its place—usage triggers, examples, alternatives—though it could be tightened without losing value.

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

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

Given the tool's broad scope, the description is remarkably complete: covers dominant use case, domain list, citation behavior, default status, tier compatibility, and explicit escalations to two sibling tools. No output schema exists, but return-style (structured answer with citations) is disclosed.

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 well-defined 'question' parameter including aliases. The description reinforces this with examples but adds no new parameter-specific semantics, so a baseline score of 3 is appropriate since the schema carries the load.

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

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

The description clearly states the tool routes questions to 5,529 tools across 1,455 verified sources and returns structured answers with citation URIs, distinguishing it from web search. It provides explicit examples (e.g., 'current US unemployment rate') and names alternatives like ask_pipeworx_grounded and deep_research, making its 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?

It explicitly says 'PREFER OVER WEB SEARCH' and 'START HERE for most questions', with direct when-to-use triggers like 'what is', 'look up', 'find'. It also gives clear escalation paths: use ask_pipeworx_grounded for hallucination-resistant single answers and deep_research for broad/multi-part questions, plus notes breaking news is already covered.

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 (read-only, open-world, idempotent), the description discloses the beta nature, that candidate routing improvements may be activated live, that no candidate is currently active, and that it is a full working router, not a fallback. These are valuable behavioral traits not captured in annotations.

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

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

The description is moderately long but each sentence contributes useful context: beta status, identical behavior, candidate routing, current state, usage guidance, and clarification about full functionality. It is front-loaded with the main point but could be slightly trimmed without losing value.

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

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

Given the tool's complexity as a router and the lack of an output schema, the description adequately explains the response shape (same as ask_pipeworx), the scale (5,529 tools), and the experimental context. No output schema is needed because the description references the stable tool's shape.

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

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

The input schema has 100% coverage with all parameters documented as aliases for 'question'. The description adds no parameter-specific meaning beyond what the schema already provides, so a baseline of 3 is appropriate.

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

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

The description clearly identifies the tool as a beta version of ask_pipeworx, a universal router for 5,529 tools, and distinguishes it from the stable sibling ask_pipeworx. It states the resource (a question) and the action (routing), satisfying the verb+resource requirement.

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

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

The description explicitly advises using it 'exactly like ask_pipeworx when you want the newest routing', giving a clear when-to-use. It also implies the alternative (use the stable ask_pipeworx for non-experimental needs) by noting results are compared against the stable router.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive. The description adds substantial behavioral context beyond annotations: it details the refusal mechanism with specific refusal_reason enum values, explains that the answer is extracted using ONLY the tool result, reveals the additional LLM call cost, and lists the exact return shape. This is rich, actionable 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 dense but every sentence earns its place: it leads with the key differentiator (hallucination-resistant), explains the routing and extraction process, gives the exact success/refusal outputs, lists use cases, and notes the cost trade-off. It is well-structured, front-loaded with the most critical information, and appropriately sized for the tool's complexity.

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

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

This tool has no output schema, so the description correctly compensates by spelling out the return format on success and the possible refusal reasons. It also covers the tool's internal behavior (tool selection across 5,529 tools), the 'not in source' edge case, and the performance cost. For a tool with this level of complexity and no output schema, the description is remarkably complete.

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

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

Schema coverage is 100% and all six parameters are aliases for the same question field. The description does not elaborate on parameter semantics, but it doesn't need to since the schema fully documents each alias. The baseline of 3 applies here because the description provides no additional parameter-level insight beyond what the schema already offers.

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

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

The description clearly states the tool's core function: a hallucination-resistant answer mode that extracts answers strictly from tool results and returns structured output with evidence. It distinguishes itself from the sibling ask_pipeworx by emphasizing grounded extraction and explicit refusal behavior, making its unique purpose unambiguous.

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

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

Explicit when-to-use guidance is provided: 'Use whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts' and 'prefer ask_pipeworx for casual lookups.' This directly contrasts with the sibling tool and clarifies the trade-off of an extra LLM call, offering both positive and negative usage cases.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description goes far beyond this by detailing the resolver contract (market_match_confidence, market_match_score, alternatives), low-confidence matching behavior with status:"low_confidence_match", closed/dead market handling, wide-spread market tradeability flags, and resolution-rule risk (e.g., refund_50_50, resolves_no_on_cancel). This is exemplary 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 long but appropriately structured with clear headers (CLASSIFIERS, FAN-OUT EXAMPLES, RESPONSE SHAPES, RESOLVER CONTRACT, etc.) and front-loaded with the core purpose. Most sentences convey unique technical information that an agent would need, especially given the tool's complexity. It is not concise, but the density is warranted; however, it could be trimmed or organized more efficiently.

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

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

The description comprehensively covers all aspects needed to use the tool correctly: what inputs are accepted, how fan-out works, what the response contains (result.market, result.analysis, result.evidence), how to handle match confidence, parent event extraction, news fallback fields, safety statuses for low-confidence and closed markets, and resolution-rule risk. With no output schema, this description carries the full burden and succeeds completely.

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 value by explaining the impact of depth ('quick = 2-3 evidence sources, thorough = full fan-out'), include_raw size implications (responses under ~20KB vs 50KB-500KB), and providing concrete examples for the market parameter (slug, URL, question text). This extra context justifies a score above baseline.

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

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

The description clearly states the tool's function: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies the resource (Polymarket bet) and the action (research/pull data), and distinguishes itself from sibling tools like polymarket_edges or polymarket_arbitrage by focusing on a single bet's data fan-out rather than finding cross-market opportunities.

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 lists use cases: 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z".' It also provides numerous fan-out examples for different bet categories. However, it does not explicitly state when not to use this tool or mention alternative sibling tools for specific situations, so it misses the 'when-not/alternatives' element 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?

Beyond the readOnly/idempotent annotations, the description discloses data sources (SEC EDGAR/XBRL, FAERS, FDA), off-calendar fiscal year handling, sorting by primary metric, and citation URI returns. This gives a full behavioral model without contradicting the annotations.

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

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

The description is dense and front-loaded with examples and usage rules, followed by data-source details. It is somewhat long and uses uppercase emphasis, but every sentence adds substantive information with no filler.

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

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

With no output schema, the description compensates by explaining return values (paired data + citation URIs), sorting behavior, and data sources. Together with well-described parameters, it is sufficiently complete 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?

Though schema coverage is 100%, the description adds meaningful parameter semantics: what each 'type' value pulls (10-K metrics vs adverse-event/trial counts) and concrete examples for 'values'. This goes well beyond the schema's basic descriptions.

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

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

The description opens with concrete query phrasings and clearly states that it performs side-by-side comparison of 2–5 companies or drugs in one parallel call. It distinguishes itself from sequential single-pack lookups with the explicit 'ALWAYS PREFER' instruction.

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 trigger phrases for when to use the tool and instructs to prefer it over sequential single-pack lookups when comparing entities. It also clarifies type-specific usage for company vs drug, giving the agent clear decision criteria relative to alternatives.

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

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

Annotations already declare read-only, idempotent, non-destructive behavior, so the description adds value by disclosing the concrete outputs: dimensions, category codes, human labels, size, and last-updated date. This contextualizes what to expect from the call.

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: the first explains the tool's purpose and output, the second gives usage guidance. Every word earns its place; no redundancy or padding.

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 sufficiently enumerates what the tool returns and when to use it. The single parameter and read-only nature are already covered by schema and annotations, leaving no significant gaps.

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

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

The input schema already fully documents the 'matrix' parameter with type and examples (CPM01, QLF18). The description adds minimal semantic value beyond confirming that the parameter is a matrix code, but this is acceptable given 100% 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 function: 'Get the structure of one CSO table by matrix code' and lists the returned components. It distinguishes itself from siblings by mentioning 'before calling get_dataset with filters', positioning this as the metadata lookup step.

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

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

Explicit usage guidance is provided: 'Use this to discover valid dimension codes before calling get_dataset with filters.' This tells the agent exactly when to use this tool and names the related sibling (get_dataset) where this metadata is a prerequisite.

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?

Although annotations already indicate read-only, idempotent, open-world behavior, the description adds substantial behavioral context: it details the return packet format, latency expectations (15-60s, up to 90s), the multi-hop recovery behavior for depth variants, the presence of contradictions[] for standard/thorough, and the semantic excerpting of large records. It also warns that gaps[] may be empty for unsupported topics and that citation_uri is only present when fetchable, preventing misleading assumptions.

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

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

The description is long but every sentence earns its place. It is front-loaded with the critical account requirement and fallback, then logically progresses through the tool's mechanics, best-use cases, edge cases, and performance expectations. There is no fluff or repetition of schema details.

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

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

With no output schema, the description fully explains return values: verbatim evidence, confidence, source, fetched_at, pipeworx:// citation, gaps[], contradictions[], and hop field. It also covers prerequisites, alternatives, latency, and failure modes, making the tool's behavior completely comprehensible for an agent.

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

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

The schema already covers both parameters with 100% description coverage. The description adds value by noting the paid plan requirement for depth:'thorough', confirming that question is natural language with broad/multi-part support, and elaborating on the behavioral differences between depth levels (gap recovery, contradiction scan). This goes slightly beyond the schema's enum descriptions.

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

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

The description clearly states the tool's function: grounded multi-source research across structured data sources in ONE call, with explicit mention of decomposition and parallel routing. It distinguishes itself from siblings by naming ask_pipeworx as the alternative for single lookups and current news, and by emphasizing it is NOT open-web search.

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

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

The description provides explicit when-to-use guidance: 'Best for broad/multi-part questions over structured data' and 'For a single lookup use ask_pipeworx' plus specific examples. It also gives exclusions: for breaking/current news prefer ask_pipeworx and warns that deep_research returns empty gaps for such topics. Account requirements and alternatives are clearly stated.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds valuable return-format transparency: 'Returns the top-N most relevant tools with names, descriptions, and full input schemas (with curated examples) — each result is ready to call directly, no second schema lookup needed.' This 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?

The description is front-loaded with a clear purpose statement, followed by usage context and return details. The domain list is somewhat long but serves to illustrate scope. Each sentence contributes value, though the list could be trimmed for brevity.

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

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

With no output schema, the description compensates by explaining the return format and readiness for direct invocation. It also gives a clear usage directive ('Call this FIRST') and scopes the tool's role relative to the broader toolset. This is complete for a read-only discovery tool.

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

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

The schema provides 100% coverage for all parameters, including aliases and the limit parameter with default/max. The description does not add any additional parameter-level semantics beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Find tools by describing the data or task.' It also enumerates specific domains (SEC filings, FDA drugs, etc.) and distinguishes itself from sibling tools as a discovery/meta tool rather than a data-specific tool.

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

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

Explicitly says 'Use when you need to browse, search, look up, or discover what tools exist for...' and adds 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' This provides strong when-to-use guidance, though it stops short of naming specific alternative tools.

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

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

Annotations declare readOnly/idempotent/openWorld, and the description adds substantive behavior: fans out across multiple sources, handles patents via a sunsetting API with soft-fail, uses GDELT→GNews fallback, and returns specific fields. This aligns with annotations and adds context about failure modes and data origin.

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 it is front-loaded with examples and organized logically: intent, preference, data sources, return fields, and limitations. Each sentence contributes useful detail, though it could benefit from bullet points for readability.

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

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

With no output schema, the description thoroughly covers return values (cik, filings with URIs, fundamentals, patents, news, LEI) and notes key caveats like patent API sunset and input restrictions. It gives the agent enough context to invoke the tool and interpret results.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by providing concrete examples ('AAPL', '0000320193'), reiterating that names are unsupported, and pointing to resolve_entity for name inputs. This goes beyond the schema's bare field 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 returns a 'full cross-source profile of a US public company in ONE parallel call' with specific examples of user intents. It distinguishes from siblings by explicitly preferring this over chaining single-pack lookups and referencing resolve_entity for name-only requests.

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

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

Provides explicit when-to-use guidance: 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view.' Also states when not to use: names are not supported, use resolve_entity first. This clearly delineates the tool from 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 destructiveHint=true and readOnlyHint=false, so the tool's mutating nature is known. The description adds useful context ('previously stored memory', 'clear sensitive data') but does not disclose additional behavioral details such as irreversibility, permissions, or error behavior beyond what annotations imply.

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

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

The description is two sentences, front-loaded with the primary action, and every sentence adds meaningful guidance. It has no fluff or redundancy.

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

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

For a simple one-parameter tool with complete annotations and full schema coverage, the description covers all essential aspects: what it deletes, when to use it, and how it relates to sibling tools. No additional details are necessary.

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

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

Schema coverage is 100% and the only parameter 'key' is described in the schema as 'Memory key to delete'. The description's phrase 'by key' aligns with the schema but adds no extra semantic value 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 uses a specific verb ('Delete') and identifies the resource ('a previously stored memory by key'), clearly distinguishing it from sibling tools like remember and recall. It unambiguously states the action and object.

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: 'when context is stale, the task is done, or you want to clear sensitive data.' It also references related tools by saying 'Pair with remember and recall,' but it does not explicitly state when-not-to-use the tool or enumerate exclusions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds behavioral context by explaining that it fetches the page and emits a standard markdown blob, which implies an external network request. It does not disclose limitations or error cases, but given the strong annotations, 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?

The description is two efficient sentences plus a 'Useful for' list. It front-loads the core purpose, then explains mechanics, then gives applications. No word is wasted, and the structure is easy to scan.

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

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

The tool is simple, and the description covers inputs (URL, max links via schema), process (fetch, extract, emit), output (single text blob ready for site root), and use cases. With strong annotations and full schema coverage, the description provides sufficient context for an agent to select and invoke the tool correctly.

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

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

The input schema provides descriptions for both parameters, achieving 100% coverage. The description references 'any URL' and 'key links' but does not add new meaning to either parameter beyond what the schema already documents, so it meets 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 a specific verb and resource: 'Generate a production-ready llms.txt file for any URL.' It details the process (fetch, extract, emit) and explicitly mentions AI crawlers, which distinguishes it from sibling tools like scan_competitor_ai_presence or ai_visibility_check that focus on broader visibility rather than producing a specific file.

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 three explicit use cases: client indexing, drafting for your own project, and competitor auditing. This provides clear context on when to use the tool, but it does not explicitly exclude scenarios or mention alternative sibling tools, so it stops short of a full 5.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable context about the output format (dimensions + flat value array) and warns about large tables (e.g., CPI table ~60k values), which goes beyond the safety annotations. However, it does not describe potential pagination or response size limits beyond the warning, so slightly short of a 5.

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

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

The description is two sentences, front-loaded with the core action, and then provides essential warnings and alternatives. No filler or redundancy—every sentence earns its place.

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

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

For a simple read tool with one parameter and no output schema, the description covers the essential context: what it returns, potential size pitfalls, and when to use siblings. This is sufficient for an agent to select and invoke it correctly.

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

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

Schema description coverage is 100% for the only parameter 'matrix', with a clear example ('CPM01'). The description does not add further parameter-specific details, so it meets the baseline but does not exceed 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 reads a full CSO table as JSON-stat 2.0, with a specific verb ('Read') and resource ('CSO table'). It distinguishes itself from sibling tools by mentioning dataset_metadata and query_dataset as alternatives for size checking or filtered slices.

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

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

The description gives explicit usage guidance: 'use dataset_metadata first to gauge size, or use query_dataset to fetch a filtered slice instead.' This clearly tells the agent when to use alternatives, making the tool's appropriate context unambiguous.

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

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

Annotations already declare the tool as read-only, idempotent, and non-destructive. The description adds context about the large catalog size and the nature of the returned data (matrix code, label, dimensions, last-updated date), which goes beyond the annotations and helps set expectations.

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

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

The description is two concise sentences that front-load the core purpose and then provide a practical tip. Every word earns its place with no redundancy or irrelevant detail.

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

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

For a simple search/list tool with no output schema, the description adequately covers the tool's purpose, output format, and a caveat about the large catalog. Combined with the rich annotations and schema, this provides sufficient context for an agent to use the tool correctly.

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

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

The input schema already provides comprehensive descriptions for both parameters (100% coverage). The description adds value by emphasizing the query parameter as practically required ('always pass a keyword query'), which is not reflected in the schema's required field list.

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

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

The description clearly states the verb 'Search' and the resource 'CSO catalog of ~12,600 Irish statistics tables,' and specifies the output fields (matrix code, label, dimensions, last-updated date), which distinguishes it from sibling tools like get_dataset or query_dataset.

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

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

It provides clear usage guidance by stating 'The full catalog is large, so always pass a keyword query to narrow it,' which gives a strong recommendation for using the query parameter. However, it doesn't explicitly mention when not to use this tool or name alternative tools.

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

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

The description adds value beyond the annotations by specifying the return fields and stating the default behavior (active subscriptions only). Annotations already provide readOnlyHint, idempotentHint, and destructiveHint=false, so the description's extra detail about output shape is a meaningful supplement. 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 two concise sentences, the first states the action and output, the second gives usage guidance. No redundant or filler content; front-loaded with the main verb.

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 one optional parameter and no output schema, the description covers the purpose, return fields, and usage context. The safety profile is already captured by annotations, and the sibling relationships are clear. 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 only parameter, include_inactive, is fully described in the schema ('Include cancelled subscriptions in the response (default false)'). The description does not add extra parameter meaning, but with 100% schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly states the tool lists 'the caller's active subscriptions' and enumerates the returned fields (id, type, params, etc.). This distinguishes it from sibling tools like subscribe and unsubscribe while providing a specific verb, resource, and scope.

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

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

The description explicitly says 'Use this to review what you're monitoring before adding more or to find an id to cancel,' giving direct guidance on when to use the tool and implicitly contrasting with subscribe/unsubscribe. This is clear, actionable 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?

Beyond the annotations (which are all false and provide little safety profile), the description discloses critical behaviors: rate limiting ('Rate-limited to 5 per identifier per day'), the token-based follow-up flow ('Filing without an account returns a claim_token; pass it back later... to read whether it was fixed'), and operational transparency ('free; doesn't count against your tool-call quota'). No contradictions with annotations exist.

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

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

While the description is a single paragraph, every sentence contributes essential guidance: purpose, use cases, scope restriction, best practices (avoid pasting prompts), token behavior, rate limits, and cost. It is front-loaded with the core action and immediately clarifies when to use it. There is no redundancy or filler, making it appropriately sized for the tool's complexity.

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

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

Given the tool's moderate complexity (nested context object, enum type, optional claim_token) and absence of an output schema, the description provides all necessary context: what to report, how to report it, what happens after filing (claim_token, daily digests), and limitations (rate limit, scope). An agent can confidently select and invoke this tool without additional inference.

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

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

The input schema already covers all four parameters with detailed descriptions (100% coverage). The description goes further by explaining the dynamic between parameters: how filing without an account returns a claim_token that can be used in a later call to check status. This adds semantic meaning beyond the schema, especially for the claim_token parameter, which is otherwise just 'read the reply to a report you filed earlier.'

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

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

The description opens with 'Tell the Pipeworx team something is broken, missing, or needs to exist', a specific verb+resource that clearly distinguishes it from all sibling research/query tools. It fully explains the tool's role as a feedback channel for the Pipeworx platform, 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?

Explicit usage criteria are provided: 'Use when a tool returns wrong/stale data (bug), when a tool you wish existed isn't in the catalog (feature/data_gap), or when something worked surprisingly well (praise).' It also gives a clear exclusion—'ONLY for tools served by this Pipeworx connection'—and directs other MCP server issues elsewhere. The claim_token read-back workflow is also explained, leaving no ambiguity about when and how to use the tool.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive. The description adds valuable context beyond this: the data source (CF analytics-engine), the fact that no PII is included, the output shape (pack, tool, count), and cache behavior (5min-1h depending on window). 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 longer than a simple two-liner but every sentence carries distinguishing information: purpose, return contents, use cases, data source, privacy, and caching. The 'Useful for' list adds a bit of length but remains relevant; no wasteful filler.

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

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

Even though there is no output schema, the description clearly communicates what the tool returns (top tools, top packs, total call volume), the data shape (pack, tool, count), cache timing, and the practical contexts for use. For a tool with one optional parameter and no output schema, this is complete and self-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?

There is one optional parameter (window) and schema coverage is 100%. The schema already provides enum values and semantic guidance ('Shorter windows surface what's hot right now; longer windows show steady-state demand'), so the description adds no additional parameter meaning beyond what is already present.

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

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

The description opens with a clear, specific verb and resource: 'What other AI agents are calling on Pipeworx right now' and then states exactly what it returns (top tools, top packs, total call volume). It distinguishes itself from siblings like discover_tools by focusing on aggregate usage trends rather than general tool discovery.

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 provides three 'Useful for' scenarios, giving clear context on when to use the tool. However, it does not name alternative tools or state when not to use it, so it stops short of full when/when-not 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 mark the tool as read-only, open-world, idempotent, and non-destructive. The description goes far beyond this by detailing thresholds (3pp partition deviation, ≥0.30 Jaccard), placeholder filtering rules, fill-check semantics, and the concrete return structure. This gives the agent rich behavioral context for safe invocation.

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-organized into clear sections (SEMANTIC ANCHOR, PARTITION FILTER, FILL CHECK) and front-loaded with the core purpose and mode selection. Each sentence adds operational detail; while dense, it is structured for easy scanning. Not bloated given the tool's complexity.

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

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

No output schema exists, so the description must explain return values; it does so explicitly (opportunities[], partition_check{...}, fill_check fields). It also covers edge cases (placeholder slugs, thin legs, realizable_edge_pp ≤ 0), making the tool's behavior fully contextualized 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 the baseline is 3. The description adds meaningful semantics: no-arg default behavior, recommended use of event for specific markets, and concrete examples for both event slugs and topic seed questions. These examples and mode explanations go beyond the schema without being redundant.

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

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

The description opens with a specific verb and resource: 'Find arbitrage opportunities on Polymarket via monotonicity violations + partition-sum checks.' It clearly distinguishes the tool's scanning modes (no-args trending_scan, event, topic) and differentiates from siblings like polymarket_fill_risk.

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

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

Provides explicit guidance: call with NO args for trending scan, use event mode for a specific market, use topic for cross-event scanning. It also names an alternative tool for custom sizing ('For custom sizing use polymarket_fill_risk') and warns when not to trade ('realizable_edge_pp ≤ 0 ... do not trade it').

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

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

The description goes well beyond the readOnly/idempotent annotations by disclosing operational behaviors: 1h KV-level caching, slippage subtraction, model-family specifics (lognormal barriers, GDELT ratios), per-sport favorite-longshot bias adjustments, placeholder-slug filtering, diagnostics funnel counters, and 24h-move warnings. It also clearly separates response segments and explains why fed candidates are excluded from ranking. 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 and dense, but it is well-structured with clear section headers (MODEL_DRIVEN, STRUCTURAL_ARBITRAGE, CONCENTRATED_LONGSHOT, TRADEABLE-EDGE KNOBS, RESPONSE TOP-LEVEL) and leads with a concise purpose statement. Every sentence carries technical detail relevant to invocation, though some model formulas could be considered excessive for the average 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?

With no output schema, the description carries full responsibility for explaining the response. It details top-level keys (by_segment, fed_candidates, _diagnostics), per-opportunity fields (edge_pp_net, kelly_fraction, market.liquidity, etc.), the 24h-move warning, caching, and funnel counters—giving an agent a complete picture of what to expect and how to interpret empty segments.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds significant value beyond the schema, particularly for min_partition_leg_kelly (explaining that partition arbs always have parent-level Kelly=0 and that this knob applies per-leg), slippage_pp (market context on Polymarket fees and typical spread), and category_filter (explicit segment names). This pushes it to a 4.

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

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

The description explicitly states it 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price,' clearly identifying the action, resource, and scope. It further positions itself as a discovery tool with 'what should I bet on today' and differentiates its segmented output (model-driven, structural arbitrage, concentrated longshot) from sibling tools like polymarket_arbitrage or polymarket_edge_tracker.

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 strong contextual guidance: it is built for discovering daily betting opportunities and includes detailed knob explanations (e.g., min_liquidity, max_spread_pp, min_partition_leg_kelly) to filter tradeable edges. However, it does not explicitly mention when to use an alternative tool or when not to use this one, so it falls short of a 5.

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

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

Annotations are readOnly, idempotent, and non-destructive, which are already clear. The description goes far beyond that by detailing snapshot TTL limits, cache-miss behavior, gap interpretation, decay computation basis, and the signed nature of edge_pp_net. No contradiction with annotations; this is rich 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 a clear opening question, explicit ARGS and RESPONSE sections, and LIMITS paragraph. Every sentence carries substantive information (e.g., TTL, cache-miss implications, signed values). It is dense but appropriately sized for the tool's complexity; not wasteful, but could be slightly tightened without losing value.

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

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

For a read-only telemetry tool with no output schema, the description fully compensates by detailing the response structure, field semantics (trend, decay, lifespan, snapshot_dates), and limitations. It also covers operational context (snapshot write behavior, TTL, gap meaning). The tool's purpose is completely clear within its ecosystem.

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%, providing baseline 3. The description adds meaningful context: 'window' is explained as a 'snapshot family' and the lookback clamp is mentioned. It also clarifies that days controls lookback on snapshots, not just a generic number. This exceeds schema-only information, justifying a 4.

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

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

The description clearly states a specific verb and resource: it provides 'edge persistence and decay telemetry.' It answers a targeted question ('how long has this edge existed and is it shrinking?') that distinguishes it from sibling tools like polymarket_edges, which likely returns current edges only. The unique scope (persistence/decay over time) is explicit.

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 context well: it is for understanding edge longevity and decay, not just current edges. It contrasts 'fresh wide edge' vs '3-week-old wide edge,' which clarifies when this tool adds value. However, it does not explicitly name alternatives or state when NOT to use it, so it misses the top tier for this dimension.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds detail that it simulates fills across the order book, returns fields like vwap_fill_price and slippage_pp, and flags forced_directional_risk, going well beyond the annotation safety profile.

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

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

The description is a single dense paragraph of about 250 words. It is information-dense with no filler, but would benefit from section breaks or bullet points to improve scannability given the dual-mode structure.

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

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

There is no output schema, so the description must enumerate return values; it does so exhaustively for both modes, listing top_of_book, vwap_fill_price, slippage_pp, shares_filled, max_fillable_usd, verdict, and basket-specific fields. It also covers risk warnings and suggested use cases, making the tool self-documenting.

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 all four parameters with 100% description coverage. The tool description adds value by explaining how market/event modes alter interpretation of size_usd and side, and by contextualizing defaults. However, the schema already captures most of these details, so the increment is modest.

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

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

The description opens with 'Realizable-vs-theoretical edge check against live CLOB order-book depth', clearly identifying the tool's purpose. It explicitly distinguishes single-market and basket modes, and names related sibling tools (polymarket_arbitrage, polymarket_edges) to differentiate its role.

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

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

The description explicitly states 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500', providing concrete when-to-use guidance. It also explains why, citing partial basket fills converting an arb into an unhedged directional position as the dominant loss mode.

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 though annotations declare readOnlyHint and similar safe properties, the description goes far beyond by explaining compatibility_warning conditions, temporal_alignment, and skipped_cross_type counters. It also explicitly states that pre-mapped does not equal tradeable, revealing real limitations. 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 lengthy but well-structured with labeled sections (TWO MODES, RESPONSE, SAFETY FIELDS). Every sentence conveys essential information about behavior, limitations, and output. It is dense rather than verbose, though it could be trimmed for easier 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 provided, the description compensates by detailing the response structure: leg-by-leg prices, spread calculations, compatibility_warning scenarios, temporal alignment, and skip counters. It covers success and failure cases comprehensively, making it fully self-contained for an agent.

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

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

The schema lists parameters and examples, but the description adds crucial interaction semantics: how 'topic' auto-fetches matching events, how explicit tickers/slugs override it, and the exact shortcut list. It also clarifies that explicit parameters enable custom pairings, which is not evident from the schema alone.

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

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

The description opens with a specific verb and resource: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' It clearly distinguishes this from sibling tools by focusing on cross-venue comparison, and outlines two distinct modes of operation. Purpose is 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 clear context on when to use the tool and how to choose between topic shortcuts and explicit event IDs. It also warns that most pre-mapped topics currently return compatibility_warning, setting expectations. However, it doesn't explicitly compare against alternative tools (e.g., polymarket_arbitrage), so it misses explicit exclusion 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 read-only, idempotent, and open-world hints. The description adds valuable behavioral context: the result covers only the selected cells, omitted dimensions are returned in full, and time dimensions use YYYYMM index values. This goes beyond what annotations provide, though it doesn't address error handling or rate 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 two concise sentences that front-load the action and add key details about the filter mechanism and output size. Every sentence earns its place, and there is no wasted text.

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

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

For a tool with no output schema, the description explains the return type (JSON-stat 2.0), what it covers ('only the selected cells'), and how filters behave. It also directs users to dataset_metadata for codes. It is reasonably complete, though it could mention limits or error cases.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds examples and elaborates on the structure of the filters map, including the time dimension format and the behavior of omitted dimensions. This meaningfully supplements the schema.

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

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

The description clearly states the tool reads a filtered slice of a CSO table via JSON-RPC. It uses a specific verb (read), names the resource (CSO table), and explicitly differentiates itself from get_dataset by noting the result is 'far smaller'. This makes 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 tells you how to use the tool (pass a map of dimension codes to category index values), where to get those codes (from dataset_metadata), and what happens when you omit dimensions ('returned in full'). It also contrasts with get_dataset ('far smaller'), implying when this tool is preferable. However, it doesn't explicitly state when not to use it or list alternatives beyond get_dataset.

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 and destructiveHint. The description adds valuable context about scoping to the agent's identifier (anonymous IP, BYO key hash, account ID) and clarifies the relationship with remember/forget. 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 three sentences, front-loaded with the primary action, and every sentence contributes: the action, the use case examples, and the scoping/pairing. No redundant or filler content.

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

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

For a simple one-parameter tool without an output schema, the description covers the two modes (retrieve and list), scoping, and sibling tool relationships. It leaves out details like behavior for missing keys or return format, but these are minor for a straightforward memory lookup.

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

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

Schema coverage is 100% for the key parameter, but the description adds real semantic value: it explains the omit-to-list behavior and gives examples of what keys might represent (target ticker, address, notes). This goes beyond the schema's one-line definition.

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 dual function: retrieving a previously saved value by key, or listing all saved keys when the key is omitted. It explicitly names the resource (memory saved via remember) and distinguishes it from siblings remember and forget.

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

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

The description provides concrete use cases (e.g., user's target ticker, address, research notes) and the rationale 'without re-deriving it from scratch,' which implies when to use. It also pairs it with remember and forget, but does not explicitly exclude alternatives like dataset search tools.

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

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

The description discloses the mark_read side effect ('Set mark_read:true to flag returned events read so the next call only shows newer ones'), which directly contradicts the readOnlyHint=true annotation. Since the description describes a mutating operation while annotations claim read-only, this is a clear annotation 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 core action, and each sentence adds distinct value: return fields, filtering, mark_read behavior, and alternative access. No redundant or filler content.

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

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

Given the simple 5-parameter schema and presence of annotations, the description covers purpose, return payload, filtering, read-state behavior, and even provides an alternative HTTP endpoint. It doesn't elaborate on limit/unread_only, but those are fully documented in the schema. Overall quite 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 covers all 5 parameters, the description adds value by giving a concrete type example ('sec_8k'), clarifying the ISO timestamp format for 'since', and explaining the mark_read semantic in terms of subsequent calls. This goes beyond the schema's 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: 'Pull fired events from your subscription feed' and 'Returns the most recent alerts the evaluator has written to your persisted feed'. It distinguishes itself from sibling tools like list_subscriptions and recent_changes by focusing specifically on fired alerts from the persisted feed.

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

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

The description provides usage context, noting that 'Polls work fine' and gives an alternative HTTP endpoint for scripts/dashboards. It also explains filtering by type and since, and the mark_read behavior for advancing the feed. However, it doesn't explicitly contrast with sibling MCP tools or state when not to use it.

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

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

Annotations already indicate read-only, idempotent, and open-world hints, but the description goes further by explaining the fan-out to SEC EDGAR, GDELT→GNews fallback, and the PatentsView API sunset soft-fail. This adds substantial behavioral context beyond the annotations.

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

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

The description is dense but organized: starts with query examples, then core behavior, data sources, parameter details, return format, and alternative tool. Every section earns its place, though it could be slightly more compact without losing value.

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

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

Given the tool's complexity and lack of an output schema, the description covers input formats, return structure (changes[], total_changes, citation URIs), source grouping, fallback triggers, and failure modes. It is sufficiently complete for an agent to invoke 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?

Schema coverage is 100%, but the description adds meaningful detail: `since` accepts ISO dates or relative shorthands with examples, `value` can be a ticker or CIK, and `type` is restricted to 'company'. It also recommends typical monitoring values ('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 provides a change feed for a company over a time window, with multiple query examples ('What's new with X', 'latest on Y'). It also distinguishes from sibling entity_profile by explicitly directing users to that tool for static profiles, making the purpose unambiguous.

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

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

The description openly provides usage triggers and explicitly names an alternative: 'Use entity_profile instead when you want the static profile...'. It also describes when the tool may soft-fail (patents) and the fallback to GNews, setting clear expectations for usage.

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

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

Annotations already indicate idempotentHint=true and readOnly=false, so the description doesn't restate those. It adds useful context about key-value scoping by agent identifier and retention policies (persistent for authenticated users, 24 hours for anonymous), which is beyond the annotation signals. It doesn't explicitly mention overwrite behavior, but idempotency covers that.

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

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

Three tightly worded sentences: the first states the core purpose, the second provides usage triggers, the third covers storage scope and companion tools. No redundant phrases or irrelevant details.

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

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

For a simple two-parameter tool with no output schema, the description fully covers purpose, when-to-use, persistence behavior, and related tools. An agent can correctly select and invoke this tool without needing additional information.

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

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

Schema coverage is 100% and both parameters are self-explanatory. The description reinforces by giving key examples ('subject_property', 'target_ticker') and clarifying value is 'any text' (findings, addresses, preferences), which adds practical semantics beyond the schema field 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?

The description starts with a specific verb and resource: 'Save data the agent will need to reuse later.' It clearly distinguishes this tool from its siblings by explicitly naming recall and forget as complementary operations, making its role in the memory trio unambiguous.

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

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

It provides explicit guidance on when to use: 'Use when you discover something worth carrying forward' with concrete examples like resolved tickers and user preferences. It also contrasts authenticated vs anonymous sessions, helping the agent decide whether the memory will persist for the current 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?

The description goes well beyond the readOnly/idempotent annotations by disclosing source-labeling of identifiers, explicit reporting of unresolved identifiers, graceful degradation when GLEIF/OpenFIGI are unavailable, and internal cascading of lookups. This gives a clear model of expected behavior and reliability.

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

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

The description is long but front-loaded with natural-language query examples, then quickly moves to the core purpose and supported types. Every sentence provides operational detail—types, identifiers, fallback behavior—without fluff, and it is logically structured with 'SUPPORTED TYPES.'

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

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

With no output schema, the description compensates by specifying the exact identifiers returned for each type (CIK, ticker, LEI, FIGI, RxCUI, etc.), the source-labeling and `unresolved` behavior, and how it handles external service failures. It effectively covers inputs, outputs, and edge cases for a multi-type lookup tool.

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

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

The input schema already has 100% parameter coverage with examples (e.g., 'AAPL', '0000320193', 'ozempic'). The description repeats these examples and adds context about what resolution happens, but it does not introduce new parameter-level syntax or constraints beyond the schema, so the baseline score of 3 applies.

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

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

The description clearly states the tool 'resolve a user-spoken NAME to the canonical/official identifiers other tools require as input,' using a specific verb and resource. It also distinguishes itself from siblings by positioning it as the first-step name-to-ID converter, with examples covering typical user phrasings.

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

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

It provides an explicit 'Use FIRST whenever you have a name but need an ID' guideline, giving clear when-to-use context. It also details accepted input formats for both supported types, but it does not name specific sibling alternatives or state when not to use the tool, so it falls short of the full alternatives guidance.

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

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

Annotations already declare readOnlyHint, openWorldHint, and idempotentHint, so the safety profile is covered. The description adds valuable behavioral context beyond annotations: it probes each entity with ai_visibility_check, ranks by score, and returns a ranked list with score, confidence, and signal density. It does not mention potential rate limits or auth implications, but these are partially covered in the schema.

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

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

The description is concise and well-structured: four sentences cover purpose, mechanism, use case, and return value. It is front-loaded with the action, and every sentence earns its place without redundancy or fluff.

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

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

For a tool with 4 parameters and no output schema, the description provides a solid overview: what it does, how it works (probes with ai_visibility_check), when to use it, and what it returns (ranked list with score/confidence/signal density). It lacks explicit alternative references or limitations, but the schema and annotations fill the remaining gaps 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?

Schema description coverage is 100%, with all four parameters described in the input schema. The description reinforces the 'entities' parameter as 'your brand + N competitors' but does not add any new parameter-level semantics beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Compare AI visibility across multiple entities side-by-side.' It clearly distinguishes itself from the sibling tool ai_visibility_check by emphasizing the multi-entity comparison and competitive aspect, making its purpose unambiguous.

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

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

It provides an explicit use case: 'Useful for competitive AI-marketing audits' with an example question, which clearly signals when to use the tool. It does not explicitly state when not to use it or name alternatives, but the multi-entity framing versus the single-entity sibling ai_visibility_check implies the distinction.

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

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

Beyond the annotations (readOnly, idempotent, non-destructive), the description discloses rich behavioral details: it fans out across two services, returns a specific summary block, and handles partial failures gracefully with a noted 5-30s latency for first bundlephobia measurement. It also mentions that sources_failed will list any timeout, ensuring the agent knows what to expect.

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

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

The description is dense but well-structured: it starts with the core purpose, then gives use-case triggers, enumerates the exact return fields, states the ecosystem constraint, and ends with error/failure handling. Every sentence earns its place without redundancy or fluff.

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

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

With no output schema, the description compensates by explicitly listing all returned fields in the summary block, plus per-advisory details, links, and alternative versions. It also covers edge cases like partial failures and timeout behavior. This is a complete picture for an agent to use the tool correctly.

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

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

The input schema already fully documents both parameters with 100% coverage, including scoped package support and version defaulting. The description adds minimal extra parameter semantics, mostly reiterating what the schema says. The baseline of 3 applies because schema does the heavy lifting; the description doesn't need to compensate.

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

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

The description clearly states the tool's purpose: a composite check for 'should I add this npm package' combining deps.dev and bundlephobia. It explicitly mentions the specific verb ('check'), resource ('npm package'), and lists the outputs (summary block, advisories, links, alternatives). It distinguishes itself from siblings by focusing on dependency risk/cost 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 gives explicit when-to-use guidance: whenever an agent asks 'is X safe / popular / small' or 'what does adding lodash cost me'. It also states the NPM-only limitation and directs users to deps.dev:version directly for PyPI/Maven/Cargo/Go packages. This clearly delineates usage vs alternatives.

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

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

Beyond the read-only, open-world, idempotent annotations, the description reveals concrete behaviors: returns top-N passages with character offsets and similarity scores, uses BGE-base-en embeddings over 500-char overlapping windows, and enforces a 200K character cap with truncation flagging.

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 pack a clear purpose, usage guidance, and technical details with no fluff. It is slightly longer than minimal but every sentence earns its place, and key information is front-loaded.

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

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

With no output schema, the description explains what the agent gets back (top-N passages, offsets, similarity scores), the truncation behavior, and how to use it with a related tool. This is complete for a search tool of this complexity.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds some context (e.g., 'text you already pulled') but the parameters are already well-documented with examples and constraints in the schema, so the description adds little new parameter-specific meaning.

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

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

The description opens with 'Semantic search INSIDE a fetched record,' giving a specific verb and resource. It distinguishes from siblings by emphasizing 'inside' and explicitly pairing with ask_pipeworx_grounded, making the tool's unique role clear.

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

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

It states exactly when to use it ('when the record is too big to cram into the prompt') and how it complements ask_pipeworx_grounded ('fetch with the gateway, ground over the relevant passages'). This provides clear context and an alternative.

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

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

Goes well beyond annotations by disclosing account requirements (OAuth, anonymous/BYO cannot persist), phone verification and SMS caps, webhook auto-disable after 10 failures, and the one-time return of the signing secret. These operational details give the agent a clear picture of side effects and limitations.

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

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

The description is dense but well-structured: it starts with the main purpose and return value, then enumerates types and delivery channels. Every sentence carries unique information, with no redundant or filler content, making it appropriately sized for the tool's complexity.

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

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

For a tool with five subscription types, nested objects, and no output schema, the description is remarkably complete. It covers type-specific parameters, delivery options, authentication prerequisites, usage limits, and the return value (subscription id plus one-time webhook secret), leaving little 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?

Even though the schema covers 100% of parameters, the description adds substantial value with concrete examples for each type (e.g., items:['5.02'] for officer change, params:{topic:'fed'}) and detailed delivery channel semantics including webhook HMAC signing. This greatly exceeds the baseline expected from 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 'Create a proactive monitoring subscription to a live-data event stream. Returns the new subscription id,' which identifies the exact action and resource. It also outlines supported types and delivery channels, distinguishing it from sibling tools like list_subscriptions, unsubscribe, and recent_alerts.

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 strong contextual guidance: when to use for proactive monitoring, prerequisites like a Pipeworx OAuth account, and delivery channel options with constraints. However, it does not explicitly name alternatives or state when not to use, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false. The description adds meaningful context: results are 'drawn from the live catalog of thousands of tools' and include 'the exact tool + argument shape that answers it.' This tells the agent what to expect in the response beyond what annotations alone convey. It does not discuss latency or failure modes, but that is a minor gap.

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

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

The description is a single paragraph, but it is well-structured with an em-dash to separate the query examples from the main purpose. It front-loads sample queries, then explains return structure and invocation. It is dense but every sentence contributes meaning; it could be slightly trimmed for readability.

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

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

For a tool with only one optional parameter, no output schema, and strong annotations, the description is complete. It covers what the tool returns (category-bucketed example questions with tool+argument shapes), how to call it (no args or topic), and when to use it (first, when unfamiliar with Pipeworx). No significant information is missing.

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

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

The schema already covers 100% of the parameter, including an enum of valid topics and guidance to omit for a spread. The description's example values ('finance', 'pharma', 'betting') are redundant with the schema. Thus, it adds no new semantics, matching 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 identifies the tool as the 'onboarding entry point' for an agent, with a specific verb+resource: it returns category-bucketed example questions with exact tool and argument shapes. It distinguishes itself from siblings like discover_tools and ask_pipeworx by positioning itself as the first thing to use when you don't know what Pipeworx can do.

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

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

The description explicitly states when to use it: 'Use this FIRST when you do not yet know what Pipeworx can do for you, or to learn how to call the meta-tools.' It also gives clear usage patterns for both no-argument and topic-filtered calls. However, it does not explicitly mention alternative tools or when not to use it, so it falls short of the top bar.

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

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

The description discloses key behavioral traits: ownership is enforced, the row is deactivated (not deleted), and historical events remain available via recent_alerts. This adds valuable context beyond the annotations, which already mark the operation as non-destructive and idempotent, and it does not contradict them.

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

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

The description is two sentences long, with the first sentence clearly stating the action and the second explaining the lifecycle effect. Every word contributes meaning, with no filler or redundancy.

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

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

For a simple one-parameter tool with annotations, the description covers all essential aspects: what it does, ownership, deactivation rather than deletion, and the connection to recent_alerts. It references sibling behavior enough for the agent to understand the tool's place in the workflow.

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

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

The input schema fully describes the single 'id' parameter, including its type and origin (returned by subscribe). The description adds no additional semantic value beyond restating 'by id', so the baseline score of 3 for full schema coverage 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 uses the specific verb 'Cancel' with the resource 'subscription' and identifies the parameter 'id', clearly stating what the tool does. It distinguishes from sibling tools like 'subscribe' and 'list_subscriptions' by explicitly defining the cancel operation and ownership constraint.

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 the tool: it cancels a subscription, enforces ownership, and deactivates rather than deletes. This implies the appropriate use case and implicitly warns against expecting permanent deletion, though it does not explicitly name alternatives of exclusions.

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

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

The annotations mark read-only/idempotent; the description adds crucial behavioral details: the SEC/XBRL fast path vs grounded fallback, the exact verdict enum, and especially the distinction between could_not_verify (didn't happen, no evidence) and unsupported (no source exists). It also warns callers not to present could_not_verify as evidence.

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 multi-sentence but information-dense, front-loading trigger phrases and use case. All content is relevant to invocation and interpretation; while lengthy, it justifies its length with essential caveats. Slight wordiness prevents a 5.

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

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

Despite no output schema, the description fully covers return values (verdict, actual value, citation, reasoning) and both error-ish outcomes. The two-path routing and special verdict meanings are sufficiently explained for reliable use.

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

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

Input schema already fully documents both params (claim, tolerance_pct). The description adds practical guidance: tolerance_pct defaults to claim wording capped at 5%, suggests 1-2% for hallucination detection, and gives claim examples. This elevates above baseline 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 verifies natural-language factual claims against authoritative sources, with explicit trigger phrases. It distinguishes itself from general Q&A tools by specifying the claim-verification use case and the two verification paths.

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

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

It explicitly says 'Use whenever the agent needs to check whether something a user said is factually correct,' and explains it replaces multi-step sequential calls. It doesn't enumerate formal exclusions or name alternative tools, but the coverage claim ('ANY OTHER factual claim') implies universal applicability.

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