Mdn Search

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

Annotations already indicate readOnlyHint, openWorldHint, idempotentHint, destructiveHint. Description adds details on default model, API key requirement, and return structure, enhancing transparency without contradiction.

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

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

Description is concise (three sentences), front-loaded with purpose, and every sentence adds essential information. No redundancy or fluff.

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

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

Given the tool has 4 parameters and no output schema, the description provides sufficient operational details (what it does, how to use, return structure). Minor gaps like error handling are acceptable.

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

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

Schema coverage is 100% with parameter descriptions. Description adds value by explaining the default model and the role of _apiKey for Anthropic probing, clarifying usage beyond schema.

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

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

The description clearly states the tool probes LLMs for knowledge about a business/brand/product/topic and scores visibility per model. It distinguishes from sibling tools that focus on other domains like ask_pipeworx or polymarket_*.

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

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

The description explains when to use (AI-marketing audits, pre-launch checks, competitive monitoring) and how to use (default model vs Anthropic with key). It doesn't explicitly state when not to use or alternative tools, but context is clear.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false. The description adds useful behavioral context about routing, argument-filling, stable pipeworx:// citation URIs, and the 'one fast call' expectation. This goes beyond the structured annotations without contradicting them.

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

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

The description is long but well-organized and front-loaded: it opens with the preference directive, then lists covered domains, examples, default-status, and escalation paths. Each block adds routing value, though the length is near the upper bound and some repetition exists between the domain list and the trigger-phrase list.

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 broad, default entry-point tool with no output schema, the description tells the agent what the tool does, when to use it, how it routes, what it returns, and when to escalate. The exact response shape is not specified beyond 'structured answer with stable pipeworx:// citation URIs', which is sufficient for invocation but leaves some ambiguity about the returned format.

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% because the single meaningful parameter, question, and its aliases are fully documented. The description reinforces the natural-language input via examples but does not add major parameter 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 states a clear verb and resource: answer factual questions by routing to one of 5,708 tools across 1,494 verified sources and returning structured answers with citations. It distinguishes itself from siblings by calling itself the default entry point and explicitly naming when to use ask_pipeworx_grounded and deep_research instead.

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 direction: 'PREFER OVER WEB SEARCH', 'START HERE for most questions', and 'Step up only when needed' with specific conditions for the grounded and research alternatives. It also explains breaking-news routing and provides a broad set of trigger examples.

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 behavioral context beyond annotations: candidate routing improvements are enabled live, no candidate is currently active, so behavior matches ask_pipeworx exactly, and there is no fallback because this is itself a working router. This fully discloses the experimental state.

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

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

The description is front-loaded with the key fact that it is a beta version of ask_pipeworx and gives necessary details about the live experimental state and the absence of an active candidate. It is somewhat dense with dates and parentheticals, but each sentence contributes meaningful information. Not overly long, though it could be slightly trimmed.

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

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

Given the tool's complexity and lack of an output schema, the description covers the essential operational context: current routing behavior, comparison against the stable router, and the fact that it is fully functional. It relies on prior knowledge of ask_pipeworx for the response shape, which is acceptable since ask_pipeworx is a sibling tool, but a direct note on the return format would make it complete.

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

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

Schema description coverage is 100%, with all aliases and the question parameter described in detail. The description adds no parameter-specific semantics beyond referring to 'same arguments' as ask_pipeworx, so it neither compensates for gaps nor burdens the schema. A baseline 3 is appropriate.

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

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

The description clearly identifies this as a beta universal router equivalent to ask_pipeworx, with the same 5,708 tools, arguments, and response shape. It explicitly contrasts with the stable ask_pipeworx sibling and states its experimental purpose. It is not a tautology and the scope is well defined.

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 an explicit trigger: 'Use it exactly like ask_pipeworx when you want the newest routing' and explains that results are compared against the stable router. It also clarifies that this is a full working router, not a fallback. It does not explicitly list exclusions or compare against ask_pipeworx_grounded, so it is not 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?

The description richly discloses behavioral traits beyond the annotations: it explains the refusal mechanism and all refusal_reason enum values, describes the success return shape, and states the cost characteristic (one extra LLM call). Annotations already declare readOnly, openWorld, idempotent, and non-destructive, which the description does not contradict. The added behavioral detail is substantial and actionable.

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: the mechanism, return shape, refusal reasons, usage guidance, and cost trade-off are all packed into a compact, front-loaded paragraph. The critical differentiator ('Hallucination-resistant answer mode') is first, and the usage guidance closes with a clear alternative. There is zero 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?

For a complex tool with rich implicit behavior (routing, extraction, refusal, evidence), the description covers the full operational picture: what it does, what it returns, when to refuse, and when to use the sibling ask_pipeworx instead. No output schema exists, so the description's detailed return contract and refusal_reason enum fully compensate. Nothing an agent needs to correctly call and interpret the result is missing.

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

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

Schema description coverage is 100% because every parameter maps to 'question' with aliases. The description goes beyond the schema by clarifying the expected input is a natural-language question, which is what the main parameter description already states, but the description adds the context that the question will be routed against 5,708 tools and 1494 sources, enriching the parameter's role. The schema already fully documents aliases, so the description's marginal value here is moderate.

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 a specific verb ('extracts the answer'), a resource (Pipeworx tool routing), and a distinctive constraint ('using ONLY what the tool result contains'). It distinguishes itself from ask_pipeworx by its hallucination-resistant, evidence-requiring behavior, so an agent can tell them apart without opening the schema.

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

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

The description explicitly states when to use this tool ('whenever an answer will be quoted, cited, or acted on... financial verdicts, legal claims, medical lookups, public statements'), when not to use it ('prefer ask_pipeworx for casual lookups'), and why (extra LLM call cost). This is explicit and leaves no ambiguity about selection.

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

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

Annotations already declare safe, idempotent, and read-only behavior. The description adds no behavioral context beyond the name, such as return format or pagination.

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?

Only one short sentence, which is concise but omits critical details. It is not bloated, but the minimal structure fails to fully serve its purpose.

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

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

With 0% schema description coverage and no parameter details, the description is severely incomplete. The tool retrieves browser compatibility data, but how to specify it (slug, locale) is unclear. An output schema exists but is not described.

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 0%, and the description does not explain the meaning or usage of 'slug' or 'locale' parameters. The agent must rely solely on the schema properties, which lack 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 states it provides 'Browser Compatibility Data block for a feature page,' which clearly identifies the resource (browser compatibility data) and implies a retrieval action. It distinguishes from siblings like 'search' by focusing on specific feature data.

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

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

No guidance on when to use this tool versus alternatives (e.g., 'search'). No exclusions, prerequisites, or context provided.

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

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

Annotations (readOnlyHint, etc.) are consistent and the description extensively details behavior: low-confidence short-circuit, closed market status, wide-spread handling, resolution-rule risk, parent event extractor, news fallbacks. No contradiction.

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

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

The description is long but well-organized with labeled sections (RESPONSE SHAPES, RESOLVER CONTRACT, etc.). The first sentence is clear and front-loaded. Every part adds essential information for a complex tool.

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

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

Despite no output schema, the description comprehensively documents return fields, edge cases (low confidence, closed markets, wide spreads, cancellation rules, parent events, news errors), making it fully actionable.

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

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

Schema coverage is 100% but the description adds significant value: explains market parameter can be slug, URL, or question text; depth enum with default; include_raw with usage guidance. Provides context beyond schema.

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

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

The description clearly states the tool researches Polymarket bets by pulling Pipeworx data. It specifies input types (slug, URL, text) and output (evidence packet + market-vs-model comparison). This distinguishes it from siblings like polymarket_edges, which focus on edge detection.

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

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

Explicit use cases are given ('should I bet on X', 'what does the data say about Y') and examples of classifier fan-outs. However, it doesn't directly contrast with sibling tools for when not to use, though the context implies.

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

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

Annotations declare readOnlyHint=true, idempotentHint=true, etc. Description adds context: parallel execution, handling of off-calendar fiscal years, sorting by primary metric, and replacement of 8-15 sequential lookups. No contradiction with annotations.

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

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

Description is somewhat verbose but each sentence adds value. It is front-loaded with usage examples and efficient in conveying key points. Slight room for tightening, but overall well-structured.

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

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

Despite no output schema, description explains return value: paired data plus citation URIs per entity. Covers all necessary aspects for agent understanding, including sorting behavior and coverage of financial data sources.

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%. Description adds meaning beyond schema: explains that 'company' type pulls revenue, net income, cash, debt from SEC EDGAR/XBRL, while 'drug' pulls FAERS data. For values, clarifies input format (tickers/CIKs for companies, names for drugs).

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

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

Description clearly defines the tool's purpose: side-by-side comparison of 2-5 companies or drugs in one parallel call. It includes specific verb examples ('compare', 'vs', 'versus') and distinguishes from sequential lookups. The description differentiates between entity types and the data each pulls.

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

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

Explicitly advises ALWAYS PREFER over sequential single-pack lookups when comparing entities. Provides concrete query examples and specifies when to use each entity type. Clearly differentiates from alternative sequential lookups.

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

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

Annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false) already frame the safety profile; the description adds substantial context beyond them: account/pricing prerequisites, timing expectations (15-60s, ~90s for thorough), honest failure behavior ('never invented', gaps[] for unanswered facets), the parallel routing to 5,708 tools, semantic excerpting, and the fact that current-news topics yield empty results. Directly addresses what openWorldHint implies by clarifying this is not open-web search. 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?

Long but dense — every sentence carries utility for this genuinely complex tool (pricing, alternatives, scope, return format, then depth semantics are re-explained slightly redundantly with the schema enum). Front-loads the critical gating factor (account requirement) and the primary alternative. Slightly over-long and internally duplicative on hop behavior, keeping it below 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?

Complete for a complex tool with no output schema: covers prerequisites (account, paid tier), what it returns (findings packet with verbatim evidence, confidence, source, fetched_at, citation, gaps[], contradictions[], hop field), timing, when-not-to-use, and edge behaviors (semantic excerpting, never-invented policy). Nothing an agent needs to invoke it correctly is missing.

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

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

Schema coverage is 100% (both question and depth are documented, depth has a rich enum). The description adds genuine value beyond the schema: depth:'thorough' requires a paid plan, and the hop/contradictions behavior per depth is elaborated ('standard re-angles unanswered gaps (gap recovery); thorough additionally chases the best leads'). Minor redundancy with the schema's depth documentation, so not a 5.

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

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

States a specific action (grounded multi-source research across Pipeworx's 1494 STRUCTURED data sources) with explicit scope boundaries — 'this is NOT open-web search'. Explicitly distinguishes from siblings: ask_pipeworx (single lookup), search, and current-news tools. An agent can immediately tell what it does and what it is not.

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?

Exceptionally explicit: 'Best for broad/multi-part questions over structured data', with named alternatives for specific cases — 'For a single lookup use ask_pipeworx', and for BREAKING/colloquial current-news 'prefer ask_pipeworx' with the reason (deep_research returns mostly empty gaps[]). Also gates on authentication: 'If you are not signed in, use ask_pipeworx instead'. Alternating use is fully specified.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description's safety is covered. The description adds valuable behavioral context: returns top-N most relevant tools with full schemas and examples, ready to call directly. No contradictions.

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

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

The description is concise: two sentences plus a list of domains. It front-loads purpose and usage. Every sentence adds value, with no waste.

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

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

Given the tool's complexity (6 parameters with aliases, no output schema), the description explains the return value (top-N tools with schemas) and usage context (call first). It covers all necessary aspects for a 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?

Schema coverage is 100%, so the description does not need to add much. It provides example natural language queries in the schema examples and references task descriptions. However, the description itself does not elaborate on parameter formats beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: finding tools by describing data or task. It lists specific domains and distinguishes from sibling tools like search and search_within by noting it returns tool definitions, not data. The verb 'discover' and resource 'tools' are 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 explicitly says when to use: 'when you need to browse, search, look up, or discover what tools exist for' and 'Call this FIRST... when you have many tools available.' It implicitly suggests not to use if you already have a specific tool in mind. No explicit when-not, but the guidance is clear and practical.

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 non-obvious behaviors: it fans out across multiple sources, returns specific fields, notes the USPTO API sunset (soft-failure), and describes fallback mechanisms (GDELT→GNews). 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 relatively long but front-loaded with example queries and a clear directive. Every sentence adds meaningful context; no filler. Slightly verbose but efficient given the complexity.

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

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

Despite lacking an output schema, the description enumerates all returned data groups (CIK, filings, fundamentals, patents status, news, LEI) and explains constraints (patents soft-fail, name restriction). It is largely complete for a holistic profile tool, though some structural details (e.g., JSON keys) are omitted.

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 value beyond the schema by providing example values, explaining that names are not supported (must use ticker or CIK), and noting the type parameter is currently limited to 'company'.

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

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

The description clearly states the tool's purpose: generating a full cross-source profile of a US public company. It gives concrete example queries and lists exactly what data is returned, distinguishing it from siblings like 'resolve_entity' and singling out that it should be preferred over chaining multiple lookups.

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

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

Explicit guidance is provided on when to use this tool (holistic view) and when not to (if only a name is available, use resolve_entity first). It also specifies the preferred method over chaining individual lookups.

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 idempotentHint=true. The description's 'Delete' matches but adds no behavioral detail beyond annotations. No contradiction.

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

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

Two succinct sentences: action stated first, then usage guidance. No wasted words.

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

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

Simple one-param tool with annotations covering behavior. Description adds usage context and sibling references. No output schema needed.

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

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

Schema covers parameter 'key' with description 'Memory key to delete'. Description does not add extra meaning beyond this.

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

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

The description clearly states the action (delete), the resource (memory), and the method (by key). It distinguishes from siblings 'remember' and 'recall' by mentioning them.

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

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

Explicitly states when to use (stale context, task done, clear sensitive data) and pairs with related tools 'remember' and 'recall'.

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, non-destructive. Description adds behavioral details: fetches page, extracts title/description/links, emits standard markdown. No contradictions. Could mention error handling, but acceptable.

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

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

Three sentences, front-loaded with purpose and audience, followed by process and use cases. No redundant or unclear language. Efficient.

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

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

Given simple parameters, no output schema, and safe annotations, the description fully covers what the tool does, how it works, and why to use it. No gaps.

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

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

Schema covers 100% of parameters with descriptions. Description provides example URL format and max_links default/max, adding slight value beyond schema. Baseline 3 justified.

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

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

Clearly states the verb (generate), resource (llms.txt file), and scope (for any URL). Distinguishes from siblings by its specific output format and use case for AI crawler indexing.

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

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

Explicitly lists three use cases (client site indexing, own project drafting, competitor auditing). Lacks explicit when-not-to-use or alternatives, but the context is clear and covers common scenarios.

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

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

Annotations already declare read-only, idempotent, non-destructive. The description adds that it returns specific fields and implies default scope (active subscriptions), which is useful beyond annotations.

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

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

Two concise sentences: first sentence states purpose and output fields, second sentence provides usage guidance. No unnecessary words, well front-loaded.

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

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

Given the simple tool (one optional parameter, no output schema), the description covers purpose, return fields, and usage adequately. It could mention return type but is sufficient.

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

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

Schema coverage is 100%, with the parameter include_inactive fully described. The description does not add extra meaning beyond stating 'active subscriptions' which aligns with the default.

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 'List the caller's active subscriptions' with a specific verb and resource. It also lists the returned fields, and distinguishes from siblings like subscribe/unsubscribe which perform different actions.

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,' providing clear context for when to use. It does not explicitly exclude other scenarios, but the sibling tools imply 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 are all false, so description carries the burden. It discloses the two-phase workflow (filing returns a claim_token, later use to read updates), rate limits ('Rate-limited to 5 per identifier per day'), and non-charging ('doesn't count against your tool-call quota'). Missing explicit mention of data handling or account requirements, but coverage is strong.

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 each sentence adds value: purpose, use cases, exclusions, scope, message guidance, claim_token mechanism, roadmap impact, rate limit, and cost note. It is front-loaded and logically organized, though a bit dense.

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, but the description explains the return behavior ('returns a claim_token', passing it back returns status and what changed). It also covers scope, rate limit, and team response cadence, making it complete for an agent to use 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 covers all parameters at 100%, so baseline is 3. Description adds extra meaning by advising 'Describe the issue in terms of Pipeworx tools/packs — don't paste the end-user's prompt' for the message param, and clarifies the claim_token usage flow beyond the schema's own wording.

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

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

Description clearly states the tool's purpose: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' The verb 'tell' with the resource 'Pipeworx team' is specific, and the use cases (bug, feature/data_gap, praise) distinguish it from siblings like ask_pipeworx or 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?

Explicitly specifies when to use: '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).' Also provides an exclusion: 'if the tool came from a different MCP server... file it with that server instead.' This is strong 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 indicate read-only, open-world, idempotent, non-destructive behavior. The description adds valuable context: data source (CF analytics-engine), no PII, cache duration (5min-1h). 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?

Three well-structured sentences. First sentence states core function, second lists use cases in bullet format, third adds technical details. No fluff, 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?

The tool is simple (1 param, no output schema). The description covers what is returned (top tools, packs, total calls), caching behavior, and data derivation. It does not specify output format but that is acceptable given the simplicity.

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

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

The single parameter 'window' has 100% schema coverage with enum values. The description adds semantic guidance on how to choose windows (short for hot now, long for steady-state), which is helpful beyond the raw enum.

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 ('returns') and the resource ('top tools, top packs, and total call volume'). It also provides the scope (recent window) and distinguishes from sibling tools by focusing on trending/aggregated data rather than specific queries.

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

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

Three explicit use cases are listed, guiding the agent on when to invoke the tool (discovering hot data sources, confirming canonical tool, assessing alignment). It does not explicitly mention when not to use it, but the context is sufficiently clear.

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

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

Annotations already indicate readOnlyHint=true, idempotent, etc. The description adds extensive behavioral context: scanning top 200 markets, walking child markets, partition checks, Jaccard similarity, placeholder filtering, fill check against live CLOB depth. No contradiction.

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

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

The description is detailed but well-structured with clear sections (SEMANTIC ANCHOR, PARTITION FILTER, FILL CHECK). Every sentence adds value, though could be slightly more concise.

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

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

Despite no output schema, the description explains response structure (opportunities[], partition_check, fill check info) and provides all necessary context for an agent to use the tool correctly.

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

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

Schema description coverage is 100% with both parameters described. The description adds value by explaining the effect of each mode (e.g., event slug vs topic seed question) and how outputs differ, but schema already covers basic 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 clearly states the tool finds arbitrage opportunities via monotonicity violations and partition-sum checks. It distinguishes two modes (event and topic) and explains the semantic anchor and partition filter, making it distinct from siblings like polymarket_edges.

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

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

Explicitly guides when to use each mode: 'Call with NO args for a trending_scan', 'event (recommended for a specific market)', 'topic (for cross-event scanning)'. Also provides fill check advice and references polymarket_fill_risk for custom sizing.

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

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

The description reveals extensive behavioral details beyond annotations: model families (crypto_price, news_momentum, partition_overround, concentrated_longshot), calculation methods (lognormal barrier, GDELT ratio, bias correction), filters (placeholder-slug, partition gaps), and output structure with diagnostics. It also discloses caching (1h KV). 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 thorough but verbose (400+ words). It is front-loaded with purpose and well-structured with numbered segments and bold labels, but includes very specific details (e.g., per-sport α values) that could be condensed. While organized, it is not concise for an AI agent to quickly parse.

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

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

Despite lacking an output schema, the description fully explains the response structure (by_segment, fed_candidates, _diagnostics) and per-opportunity fields (edge_pp_net, kelly_fraction, liquidity, etc.). It also covers all parameters and provides diagnostics for empty segments. This makes the tool self-contained for an AI 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?

All 9 parameters have schema descriptions (100% coverage), but the tool description adds valuable context: e.g., for `slippage_pp`, it explains subtraction from raw edge and provides Polymarket fee context; `min_kelly` is clarified as skip for too-small opportunities; `category_filter` lists exact segment names. This adds meaning beyond the schema, raising it above the baseline of 3.

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

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

The description uses specific verbs ('Scan', 'return opportunities') and resources ('Top Polymarket markets', 'Pipeworx data') to clearly state what the tool does. It distinguishes itself from sibling tools like polymarket_arbitrage by focusing on Pipeworx-driven mispricing and avoiding manual paging. The phrase 'Built for "what should I bet on today"' captures its core mission succinctly.

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

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

The description explains the tool is for discovering betting opportunities and mentions that Fed bets are surfaced but excluded from ranking due to unreliable signals. It also describes tradeable-edge knobs for filtering. However, it does not explicitly contrast with siblings like polymarket_arbitrage or polymarket_edge_tracker, leaving some ambiguity about when to prefer this tool over alternatives.

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

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

The description discloses extensive behavioral traits beyond annotations: it explains data source (daily snapshots), telemetry computation (trend, decay_pp_per_day), handling of expired opportunities, snapshot date gaps, and the meaning of negative edge values. Annotations already declare readOnly, idempotent, non-destructive; the description adds critical context on mutability state and data freshness. 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 front-loaded with the core purpose and structured with clear sections (RESPONSE, LIMITS). Every sentence adds value, but it could be slightly more concise. However, given the complexity of the tool, the detail is warranted.

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

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

Despite no output schema, the description fully explains the return values: tracked[] with detailed fields (edge_pp_net time-series, first_seen, trend, decay), expired[] with lifespan_days, and snapshot_dates. It also covers data gaps, TTL, and computation details. This provides complete information for an agent to understand and use the tool.

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

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

Input schema has 100% coverage (both parameters described). The description adds context (defaults, max days) and explains the response structure (tracked, expired arrays), which is not in the schema. This adds value beyond the schema, but the schema already provides the basics, so an incremental improvement justifies a 4.

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

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

The description clearly states it provides edge persistence and decay telemetry from daily snapshots, answering 'how long has this edge existed and is it shrinking?'. This distinguishes it from sibling tools like polymarket_edges (current edges) and polymarket_arbitrage, making the purpose specific and distinct.

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

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

The description explains when to use this tool, contrasting a fresh wide edge with a persisting one, and notes that decay indicates no one is willing to take the trade. It also documents data limitations (TTL, snapshot gaps) and that decay is computed from daily closes, not intraday. This provides clear context for usage without explicit alternatives, which are implicit given sibling tool names.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds significant behavioral context: walking the order-book ladder, returning specific fields (top_of_book, vwap_fill_price, slippage, etc.), and highlighting risks like forced_directional_risk. It provides transparency beyond annotations without 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 well-structured with section headers (REQUIRES, SINGLE-MARKET, BASKET, USE THIS) and front-loaded with core purpose. However, it is verbose (multiple paragraphs), and some sentences could be trimmed for conciseness without losing essential information.

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

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

Despite having no output schema and 4 parameters, the description is exceptionally complete. It covers both modes, return values, default behaviors, usage guidelines, and risk warnings. It compensates for the missing output schema by detailing output fields and their meanings.

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

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

With 100% schema description coverage, the baseline is 3. The description adds meaningful context: explaining the distinction between market and event modes, clarifying that size_usd in basket mode is settlement notional, and detailing the default side logic for baskets. This goes beyond the schema descriptions.

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

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

The description clearly states the tool's purpose as a realizable-vs-theoretical edge check against live CLOB order-book depth, with two distinct modes (single-market and basket). It distinguishes itself from sibling tools like polymarket_arbitrage and polymarket_edges by specifying when to use this tool before acting on their signals.

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

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

The description explicitly recommends using this tool before acting on polymarket_arbitrage or polymarket_edges trades above ~$500, and warns about risks like partial basket fills. It also states requirements (one of market or event). While it doesn't explicitly list when not to use, the guidance is clear and context-rich.

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 this as read-only and idempotent, but the description adds substantial behavioral depth beyond that: compatibility_warning and compatibility_codes can be non-empty even when pairs are returned, unknown metric_type/match_subtype legs are never paired, skipped counters expose dropped comparisons, and temporal_alignment clarifies whether events resolve in the same period. There is no contradiction with the annotations.

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

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

The description is long and dense, but it is well-structured with clearly labeled sections (TWO MODES, RESPONSE, SAFETY FIELDS, Codes) and the critical caveat ('pre-mapped ≠ tradeable') appears at the end. Every section adds necessary operational detail, though the enumerated code list and repeated warnings 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?

There is no output schema, so the description correctly takes on the burden of explaining the response shape: leg-by-leg prices, spread[].top_spreads_pp, compatibility fields, skipped_unclassified, low_confidence_pairs, temporal_alignment, and skipped counters. It even explains how to interpret flags and why some legs are never paired. An agent has enough context to invoke the tool and interpret its results correctly.

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

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

Schema coverage is 100% and each parameter already has a description, so the baseline is 3. The tool description adds real value by explaining how the parameters interact: topic auto-fetches the matching event on each venue, and kalshi_event_ticker/polymarket_event_slug override the topic-mapped side. It also provides concrete examples of ticker and slug formats, which schema descriptions alone do not fully convey.

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 precise, specific statement: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' It clearly distinguishes this from single-venue tools by emphasizing the cross-venue comparison, and it explains the two modes (topic shortcuts vs explicit ticker/slug pairing) so an agent knows exactly what resource the tool acts on.

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 usage context: when to use the 'topic' mode vs explicit pairing, and it warns that pre-mapped topics often return compatibility warnings and are not necessarily tradeable. It does not explicitly name sibling alternatives like polymarket_arbitrage or polymarket_edges, but the mode selection and caveats are clear enough to guide correct invocation.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds scoping context (by identifier) and pairing info, adding value beyond annotations.

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

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

Two sentences, front-loaded with purpose, no wasted words. Efficient and well-structured.

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

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

For a simple retrieval tool with good annotations and schema, the description completely covers purpose, usage, and behavior. No need for output schema.

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

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

Schema coverage is 100% with description of 'key'. The description adds the key behavior: omit to list all keys, which is not in schema but essential for usage.

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

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

The description clearly states it retrieves values saved via remember or lists all keys. It distinguishes itself from sibling tools (remember, forget) by specifying its retrieval function.

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

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

Explicitly says when to use: to look up context stored earlier. Mentions pairing with remember and forget, and scoping to identifier, providing clear guidance.

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

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

Adds valuable details beyond annotations, such as the return format (source, citation_uri, raw payload) and the side effect of mark_read. Annotations already indicate safety, and the description enhances without contradiction.

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

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

Four sentences, front-loaded with purpose, every sentence adds value. No unnecessary words; efficiently covers purpose, parameters, behavior, and alternatives.

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

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

Given no output schema, the description explains return fields and side effects. Covers all parameters, mentions REST alternative, and is sufficient for an agent to use correctly.

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

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

Schema coverage is 100%, but the description adds meaning: explains type filtering, ISO timestamp format for since, mark_read side effect, and unread_only behavior. It also mentions default limit and range, going beyond the schema.

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

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

The description clearly states the tool pulls fired events from the subscription feed, using specific verbs and resource identification. It distinguishes itself from siblings like 'list_subscriptions' by focusing on alert events rather than subscription management.

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

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

Provides clear context on when to use (reading recent alerts) and mentions an alternative REST endpoint. However, lacks explicit when-not or direct comparison to sibling tools for exclusion.

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

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

Annotations already indicate readOnlyHint, idempotentHint, etc. The description adds rich behavioral detail: fans out to SEC, GDELT→GNews fallback, USPTO soft-fail; return structure with grouped changes, total_changes, and citation URIs. No contradictions with annotations.

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

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

Single paragraph efficiently packs purpose, examples, multi-source behavior, parameter usage, return format, and sibling differentiation. Every sentence adds value; 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?

Despite no output schema, the description explains the return structure. Covers all needed aspects for an agent: what it does, when to use, parameters, expected output, and limitations. Complete for a tool of this complexity.

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

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

Schema coverage is 100% but the description adds value beyond schema: since parameter examples ('7d', '30d', '3m', '1y') and typical usage suggestion; value parameter examples (ticker or CIK); type parameter confirms only 'company' supported. Goes 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 retrieves a change feed for a company over a window, with multiple query examples ('What's new with X', 'latest on Y'). It distinguishes itself by name from sibling entity_profile, which provides static profile instead.

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

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

Explicitly provides when to use (dynamic changes) and when not to ('Use entity_profile instead when you want the static profile...'). Also gives typical monitoring recommendation ('Use 30d or 1m') and query pattern examples.

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

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

Annotations indicate idempotent and non-destructive, and the description adds persistence behavior (session vs authenticated), scoping by identifier, and 24-hour memory retention for anonymous sessions, which goes beyond annotations.

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

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

Four sentences, front-loaded with purpose, then usage, then technical constraints. No wasted words; every sentence adds value.

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

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

For a simple key-value store with 2 params and no output schema, the description comprehensively covers purpose, usage, persistence, scoping, and sibling tools.

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

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

Schema coverage is 100% with descriptions for key and value. The description adds context and examples but does not introduce new semantic meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description explicitly states the tool saves data for reuse across conversations and sessions, providing examples like resolved tickers, addresses, and preferences. It clearly distinguishes from sibling tools recall and forget.

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

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

The description explicitly advises when to use: 'when you discover something worth carrying forward' and pairs with recall/forget. It also notes scoping and persistence details, giving clear guidance.

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

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

Annotations declare safe read-only behavior, but the description adds valuable context about graceful degradation (GLEIF/OpenFIGI unavailable), source labeling for identifiers, explicit unresolved identifiers, and internal cascading lookups. This goes well beyond the structured 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 quite long but every sentence provides useful detail (examples, supported types, fallback behavior, output contents). It is front-loaded with concrete query examples and structured by type. However, it could be slightly condensed to reduce verbosity 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 absence of an output schema, the description fully covers return contents (CIK, LEI, FIGI, RxCUI, etc.), error/fallback behavior (unresolved identifiers listed explicitly), and source attribution. It leaves no significant behavioral aspect unexplained.

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 schema coverage is 100%, the description enriches the parameters substantially. For 'type' it explains each enum value's behavior, and for 'value' it details accepted formats (ticker, CIK, ISIN, name) and specific edge cases like ISIN-to-LEI mapping. This meaningfully exceeds the schema descriptions.

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

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

The description clearly states the verb 'resolve' with specific resources (names to canonical identifiers like CIK, LEI, RxCUI) and includes many usage examples. It distinguishes itself from sibling tools like entity_profile and search by positioning itself as the first step when a name needs an ID.

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

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

Provides explicit guidance: 'Use FIRST whenever you have a name but need an ID.' It also explains that it replaces 2-3 manual lookups. However, it does not explicitly state when NOT to use it or name alternative tools for different scenarios.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive. The description adds context: probes each entity with ai_visibility_check, ranks by score, and returns per-entity score, confidence, and signal density. No contradiction; description complements annotations well.

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

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

The description is moderately sized and front-loaded with the main action. Every sentence adds value, but could be slightly more structured (e.g., bullet points) for quicker scanning.

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

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

Despite no output schema, the description explains the return format (ranked list with score, confidence, signal density). It covers all four parameters, required and optional, and provides examples. Fully adequate for an agent to use the tool.

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

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

Schema coverage is 100%, and the description adds valuable context: first entity is 'subject' for narrative, models default to workers-ai, anthropic requires _apiKey. This clarifies usage beyond the schema descriptions.

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

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

The description clearly specifies comparing AI visibility across multiple entities, probing with ai_visibility_check, ranking results, and surfacing most/least recognized. It distinguishes from sibling ai_visibility_check by emphasizing multi-entity comparison and ranking.

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

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

The description gives a concrete use case (competitive AI-marketing audits) and an example question. It notes the first entity is treated as subject for narrative. However, it does not explicitly state when not to use this tool versus alternatives like ai_visibility_check or compare_entities, though it's implied.

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 true, destructiveHint false. The description adds valuable behavioral context: fans out across services, partial failures degrade gracefully, first measurement can take 5-30s, sources_failed will list timeouts. 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 relatively long but each sentence adds value. It front-loads the core purpose, then usage guidance, then behavioral details, then ecosystem limitation. Could be slightly more terse but still efficient.

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

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

Given the complexity of the tool (composite call across two services, multiple data points), the description thoroughly explains what it does, what it returns (summary fields, per-advisory detail, links, alternative versions), partial failure handling, and ecosystem limitation. No output schema, so describing return structure is essential and well done.

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 the detail that scoped packages are accepted for 'package' and that 'version' defaults to latest, but these are already covered in the schema descriptions. No additional parameter meaning beyond schema.

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

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

The description clearly states the tool's purpose: a composite check for npm packages combining deps.dev and bundlephobia data. It specifies the verb ('scan'), resource ('dependency'), and scope ('npm package'), distinguishing it from siblings like deps.dev:version or other research tools.

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

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

Explicit guidance on when to use: 'Use whenever an agent asks 'is X safe / popular / small' or 'what does adding lodash cost me''. Also states exclusion: 'NPM ecosystem only in v1; PyPI / Maven / Cargo / Go fall under deps.dev:version directly.' This helps the agent decide when not to use this tool.

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

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

Annotations already declare read-only, idempotent, non-destructive. Description adds 'MDN content' context but no additional behavioral traits beyond annotations.

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

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

Very concise single sentence, front-loaded with key action and resource. Could include a bit more detail without being verbose.

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

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

Given output schema exists and annotations cover safety, the description is minimally adequate but lacks details on pagination, locale usage, and result structure.

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

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

Schema description coverage is 75%, so baseline is 3. Description does not add parameter-level information beyond the schema.

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

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

Description states verb 'search' across specific resource 'MDN content', clearly distinguishing from sibling 'search_within' which likely searches within a subset.

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?

No guidance on when to use this tool versus alternatives like 'search_within' or other search-related tools. Context of use is implied but not explicit.

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

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

Annotations already declare readOnlyHint, idempotentHint, etc. Description adds technical details: BGE-base-en embeddings, cosine similarity, 500-char overlapping windows, 200K char cap with truncation and flagging. 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 fairly long but every sentence contributes functional information. It is front-loaded with core purpose. Could be slightly more terse, but highly informative.

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

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

Covers purpose, usage context, technical limits, algorithmic details, and comparison to sibling. Enough for an agent to decide and invoke correctly, especially given rich annotations and no output schema needed.

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

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

Schema has 100% description coverage. Description adds value by explaining the nature of 'text' (e.g., SEC 10-K body, article) and 'query' (natural-language examples). Also clarifies 'limit' implicitly as 'top-N passages.' Exceeds baseline 3.

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

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

The description clearly states 'Semantic search INSIDE a fetched record,' specifying the verb (search), resource (a fetched record), and scope. It distinguishes from sibling tools like 'search' and 'ask_pipeworx_grounded' by emphasizing intra-record search and pairing with grounding.

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

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

Explicit guidance: 'Use when the record is too big to cram into the prompt,' and contrasts with 'ask_pipeworx_grounded' as a companion tool. Also provides a verification use case via offsets.

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

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

Annotations indicate non-readOnly, idempotent, non-destructive. Description adds return of subscription id, persistence requirement, delivery channel behavior with rate limits (10/day sms), webhook signing and auto-disable after 10 failures.

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

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

Description is well-structured with bullet points, but slightly lengthy. However, every sentence adds value and no redundancy.

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

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

Given 3 parameters, no output schema, and nested objects, the description covers all types, delivery options, constraints (OAuth, rate limits, webhook signing), and return value. Completeness is high.

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%. Description enriches each parameter with detailed examples and constraints (e.g., sec_8k items, fred_series series_id, delivery phone verification).

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

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

Description clearly states the tool creates a proactive monitoring subscription and returns an id. It lists supported types and distinguishes itself from sibling tools like list_subscriptions and unsubscribe.

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

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

Provides context that OAuth account is required, but does not explicitly state when not to use or mention alternatives. However, the sibling list and examples imply appropriate scenarios.

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

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

Annotations already declare readOnly, openWorld, idempotent, non-destructive. Description adds behavioral context: returns example questions with tool+argument shapes, call with no args for full spread, optional topic filtering. No contradictions.

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

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

Description is slightly long but well-organized and front-loaded with purpose. Uses bullet-style enumeration of categories. No wasted sentences.

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

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

No output schema, but description fully explains return type (category-bucketed example questions with tool shapes) and usage scenarios. Complete for an onboarding tool.

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

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

Schema coverage is 100% with one optional parameter. Description explains topic values (finance, pharma, etc.) and behavior when omitted, adding meaning beyond schema.

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

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

The description clearly states the tool is an onboarding entry point that returns category-bucketed example questions with tool call shapes. It distinguishes from siblings like ask_pipeworx by specifying it's for exploring what to ask, not for answering.

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

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

Explicitly says 'Use this FIRST when you do not yet know what Pipeworx can do for you' and describes optional topic parameter. Does not explicitly list alternatives but context from sibling list suggests it's the discovery 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 readOnlyHint, idempotentHint, and destructiveHint. The description adds that it returns a summary for a given slug, but does not disclose additional traits like response format or potential 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?

Single, front-loaded sentence. Efficiently communicates core functionality, though could include brief mention of the locale parameter.

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 annotations and output schema, the description is minimally viable. However, it lacks explanation of the locale parameter and does not describe the return value beyond 'page summary'.

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 0%. The description only mentions slug with examples, but does not explain the 'locale' parameter. Without further detail, the agent may not understand that locale is optional or how it modifies the summary.

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 page summary by slug, with concrete examples showing the expected input. It is specific (verb 'summary' and resource 'page by slug') and distinct from siblings like 'search' or 'entity_profile'.

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

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

No guidance on when to use this tool versus alternatives like 'search' or 'entity_profile'. Lacks any when-to-use or when-not-to-use instructions.

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 non-destructive write (readOnlyHint=false, destructiveHint=false). Description adds value by detailing soft-delete (deactivation) and historical availability, enhancing transparency.

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

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

Two succinct sentences with no waste. Purpose, constraint, and behavior are front-loaded.

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

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

Given low complexity (one required parameter, no output schema), the description fully covers purpose, usage constraint, and post-call behavior.

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

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

Schema covers parameter 'id' with description. No additional parameter information in tool description; baseline 3 due to 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?

Clearly states 'Cancel a subscription by id', specifying the verb and resource. Distinguishes from sibling tools like subscribe and list_subscriptions.

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

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

Explicitly states ownership enforcement: 'you can only cancel your own subscriptions.' Also explains the deactivation behavior and references sibling tool recent_alerts for historical data.

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

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

Annotations already mark it read-only, idempotent, and open-world. The description adds critical context beyond that: the could_not_verify vs unsupported distinction, explaining that could_not_verify means the check did not happen and carries verification_error, which is essential for correct result interpretation.

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

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

Though lengthy, the description is well-structured and front-loaded with the core purpose. Each paragraph covers a distinct aspect: purpose, routing, return values, and error semantics, with no redundant 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?

Given the tool's complexity and absence of an output schema, the description thoroughly explains return values (verdict types, actual value with citation, reasoning) and special error cases, making it self-contained for callers.

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

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

The schema covers 100% of parameters, so the baseline is 3. The description adds meaningful guidance for tolerance_pct, explaining it overrides the implied tolerance, recommending 1–2 for hallucination detection, and defaulting to wording-implied capped at 5.

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

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

The description clearly states it performs 'natural-language claim verification against authoritative sources' and gives specific verb ('validate') and resource ('claim'). It distinguishes from sibling tools by focusing on factual verification and noting it 'Replaces 4–6 sequential calls'.

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

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

Explicitly states 'Use whenever the agent needs to check whether something a user said is factually correct.' It also explains the two execution paths (SEC EDGAR for company-financial claims, grounded pipeline for all others) and provides caller guidance on interpreting could_not_verify vs unsupported.

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