Gsa Perdiem

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

Annotations already declare readOnlyHint=true and idempotentHint=true; the description adds value by explaining the response format (per-model fields + combined view) and cost implications (free vs. BYO key), enriching behavioral understanding beyond annotations.

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

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

The description is concise (4 sentences), front-loaded with the primary action, and every sentence adds necessary context without redundancy.

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

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

Given no output schema, the description explains return values (per-model objects and combined view) adequately for a tool with 4 parameters and no nested objects.

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

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

Schema description coverage is 100%, and the description adds meaning beyond parameter descriptions by stating default model, free tier, and API key usage details.

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

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

The description uses a specific verb ('probe') and clearly states the resource ('LLMs for visibility'), resulting in a defined scope that distinguishes it from sibling tools.

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

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

The description explicitly lists use cases (AI-marketing audits, pre-launch brand checks, competitive monitoring) and explains API key usage, but does not mention when not to use or provide alternatives.

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

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

Annotations already establish read-only, open-world, and idempotent behavior. The description adds useful operational context by revealing it routes to 5,798 tools across 1,517 verified sources, fills arguments automatically, and returns an answer with stable pipeworx:// citation URIs. No annotation contradiction.

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

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

The opening is front-loaded with the most important guidance and the examples are valuable. However, the closing 'START HERE... Intended to be first-line search tool' sentence is repeated verbatim, which is redundant and weakens the structure.

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

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

For a complex routing tool with no output schema, the description covers input style, domains, trigger phrases, exclusions, and the structured citation output. It lacks only sibling-specific routing guidance and failure/fallback behavior, which is a minor gap given the amount of other context.

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

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

Schema description coverage is 100% and every parameter is explicitly labeled as an alias for the natural-language question. The description does not add parameter-level semantics, but with this schema coverage the baseline of 3 is appropriate.

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

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

Describes a router/answer tool for current and historical factual data, explicitly naming the domains it covers and the citation-URI output. It is clear about its purpose but does not differentiate itself from sibling ask_pipeworx_beta or ask_pipeworx_grounded, so it falls just short of full distinctiveness.

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?

Gives unusually specific when-to-use signals: prefer over web search, use for trigger phrases like 'what is' and 'look up', and start here for most questions. It also gives exclusions (live news, explicit source-specific requests, exploratory browsing), but it does not map those exclusions to sibling tools such as deep_research or the ask_pipeworx variants.

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

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

The description adds useful context beyond the readOnly/openWorld/idempotent annotations: it is a full working router, may have candidate routing improvements enabled, and currently matches ask_pipeworx because no candidate is active. This discloses the experimental and dynamic nature of the tool without contradicting the annotations.

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

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

Three sentences front-load the tool's identity and relationship to ask_pipeworx. There is minor redundancy between 'identical universal router' and 'currently matches ask_pipeworx exactly', but the length is justified by explaining the beta state and routing comparison.

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

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

For a tool with one semantic parameter, the description covers what it is, how to use it, its current state, and how it relates to the stable router. The response shape is described as identical to ask_pipeworx, which is adequate but leaves some dependency on that sibling's documentation.

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

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

Schema description coverage is 100%: the schema documents 'question' and all five aliases. The description only references 'same arguments' without adding new semantic detail, so it meets the baseline but does not elevate it.

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

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

The description identifies the tool as a 'Beta version of ask_pipeworx: identical universal router' and explains that it exposes the same 5,798 tools, arguments, and response shape. This clearly distinguishes it from the stable ask_pipeworx sibling, though it relies on the reader already understanding what ask_pipeworx does.

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

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

It explicitly says to 'Use it exactly like ask_pipeworx when you want the newest routing' and notes that results are compared against the stable router. It does not spell out when not to use it, but the beta/experimental framing and current-state note provide enough 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?

Beyond annotations, the description discloses that answers are extracted only from tool-result content, that refusals occur with specific reasons, and that the mode costs an extra LLM call. This is rich behavioral context that annotations like readOnlyHint and idempotentHint do not convey.

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

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

The description is dense but front-loaded: it opens with the defining trait, then explains routing, extraction, return contract, use cases, and cost tradeoff. Every sentence earns its place and no filler is present.

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

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

Even without an output schema, the description fully specifies the success return object, refusal envelope, refusal reasons, behavioral constraints, and selection guidance. 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?

The schema has 100% description coverage for all parameter aliases and the question field, so the baseline is 3. The description does not add parameter-specific meaning, but it does not need to because the schema already documents the input well.

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

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

The description states a specific verb and resource: an answer mode that routes to tools, fetches data, and extracts grounded answers using only the tool result. It explicitly distinguishes itself from ask_pipeworx by emphasizing hallucination resistance, evidence extraction, and structured refusals.

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

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

It gives explicit when-to-use guidance: 'Use whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts.' It also names the alternative and the tradeoff: 'prefer ask_pipeworx for casual lookups' due to the extra LLM call cost.

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

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

Annotations already indicate readOnly, openWorld, idempotent, and non-destructive, so the tool is safe. The description goes far beyond, detailing fan-out behavior, response shapes, resolver contract (match confidence, alternatives, suggestions), parent event extraction, news fields with fallback, safety for low-confidence matches, dead market handling, illiquid spread warnings, and resolution-rule risk. No contradictions with annotations.

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

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

The description is very long and dense, making it difficult to parse quickly. While it is structured with capitalized section headers, it contains excessive detail that could be external documentation. The core purpose and usage are front-loaded, but the verbosity hurts conciseness. Every sentence has value, but the overall size is too large for an efficient tool description.

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 (multiple classifiers, fan-out, resolver contract, safety), the description covers all critical aspects thoroughly. Without an output schema, the description fully explains return shapes. However, the sheer volume of information might overwhelm users; a more structured or layered approach could improve completeness. Still, it leaves no major 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 coverage is 100% with descriptions for all three parameters. The description adds significant value by explaining how to use the 'market' parameter (slug, URL, question text), the 'depth' parameter (quick vs thorough with defaults), and the 'include_raw' parameter (when to use true/false and size implications). It also elaborates on output behavior tied to these parameters.

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

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

The description clearly states the tool's purpose: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies input types (slug, URL, question text) and output (evidence packet + comparison). It distinguishes from siblings by framing the use case as 'should I bet on X', aligning with a single-bet research focus, unlike general query tools like ask_pipeworx or edge detectors like polymarket_edges.

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

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

The description explicitly states when to use: 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z".' It provides clear context and examples. However, it does not explicitly mention when not to use or compare to siblings, though the context implies differentiation. Still, it lacks direct exclusions or 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?

Adds behavioral traits beyond annotations: explains handling of off-calendar fiscal years, sorting by primary metric, and return of paired data with citation URIs. Discloses that it replaces 8-15 sequential lookups.

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?

Highly concise but information-dense. Front-loaded with example phrases. Every sentence adds value without redundancy.

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

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

Given no output schema, description adequately explains return values (sorted data, paired data, citation URIs). Covers sources and edge cases (off-calendar fiscal years).

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

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

Schema coverage is 100%, but description adds rich context: for type='company' it details specific financial metrics from SEC filings, for type='drug' it lists FAERS counts. Examples given for values.

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

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

Description clearly states 'side-by-side comparison of 2–5 companies or drugs in ONE parallel call' with specific data sources (SEC EDGAR/XBRL, FAERS). Distinguishes from siblings by explicitly advising preference over sequential 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?

Provides explicit example queries and states 'ALWAYS PREFER over sequential single-pack lookups when comparing entities.' Clearly defines when to use the tool.

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

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

Beyond the readOnly and idempotent annotations, the description discloses account and paid-tier requirements, expected latency, gap recovery behavior, contradictions scanning, citation fetchability, semantic excerpting of large records, and the guarantee that gaps are never invented. No annotation contradiction is present.

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

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

The description is long, but the tool is complex and the content is information-dense rather than padded. It is front-loaded with the account requirement and the sibling routing rule, and later paragraphs group related behavioral details coherently.

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

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

With no output schema, the description carries the burden of explaining return values, and it does so in detail: findings packet, verbatim evidence, confidence, source, fetched_at, citation_uri, gaps[], and contradictions[]. It also covers auth, pricing, latency, depth semantics, and alternatives, leaving no critical gap for correct invocation.

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

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

Schema coverage is 100%, so a baseline of 3 is appropriate, but the description adds meaningful detail on depth semantics such as gap recovery, lead chasing, and contradictions for standard/thorough. It also clarifies that the question parameter accepts broad, multi-part natural language.

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

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

The description states a specific verb and resource: grounded multi-source research across Pipeworx's 1517 structured data sources, with decomposition into facets and parallel routing to tools. It also explicitly distinguishes itself from open-web search and from the single-lookup sibling ask_pipeworx.

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

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

The description gives explicit when-to-use guidance: broad/multi-part questions over structured data. It also names the alternative ask_pipeworx for single lookups and for signed-out users, making the routing decision 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=true and idempotentHint=true, ensuring safety. The description adds behavioral detail: returns 'top-N most relevant tools with names, descriptions, and full input schemas (with curated examples) — each result is ready to call directly, no second schema lookup needed.' This explains exactly what the agent gets and how to use results.

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 efficient: one paragraph that starts with the core purpose, lists use cases, describes output, and gives a timing recommendation. Every sentence serves a purpose with no redundancy.

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

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

Given 6 parameters (1 required, 100% documented schema), no output schema, and full annotations, the description sufficiently covers what the tool does, when to use it, and what output to expect. No gaps remain.

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

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

Schema coverage is 100% with all parameters described. The description adds value by providing example queries ('look up FDA drug approvals', 'analyze housing market trends') and noting that 'query' accepts multiple aliases. This enhances understanding beyond the schema.

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

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

The description clearly states the tool's purpose: 'Find tools by describing the data or task.' It lists specific domains (SEC filings, FDA drugs, etc.) and distinguishes itself from sibling tools (e.g., bet_research, scan_dependency) by being a discovery meta-tool.

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

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

Explicit guidance: 'Use when you need to browse, search, look up, or discover what tools exist for:' followed by domain list, and 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' This clearly tells when to use it.

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

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

Beyond the read-only/idempotent annotations, the description discloses fan-out behavior across many sources, that an empty section is a real 'no data' rather than a bug, and that private companies return resolved:false with a notes line. It also documents resolved_from/resolved_to and sources_used/sources_failed, giving the agent accurate expectations for edge cases. No contradiction with annotations.

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

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

The description is front-loaded with trigger phrases and the 'ALWAYS PREFER' directive, and its lengthy source/return enumeration is warranted because there is no output schema. However, the entire payload is one dense run-on paragraph, making it harder to scan than necessary; it would benefit from bullets or spacing.

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

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

With no output schema, the description carries the full burden for return values, and it covers them in detail: CIK/name, filings, fundamentals, sources_used/sources_failed, no-data semantics, and resolution failures. It also addresses input variations and private-company behavior, leaving little ambiguity for a complex multi-source 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 baseline is 3, but the description adds operational nuance: 'zero-padded CIK', company-name resolution via SEC EDGAR, and private-company resolved:false behavior. It also clarifies that type='company' and type='ticker' are interchangeable, which adds practical meaning beyond the schema 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 opens with concrete user phrasings like 'Tell me about X' and states the deliverable as 'full cross-source profile of a US public company in ONE parallel call,' making the verb and resource explicit. It distinguishes itself from 'chaining single-pack SEC/XBRL/news lookups,' so an agent can tell this apart from more narrow entity-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?

It explicitly says 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view,' providing a clear trigger. It also covers accepted input forms and the private-company fallback, but it does not explicitly contrast with siblings like compare_entities or deep_research, so when-not guidance is not fully complete.

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?

Description adds context beyond annotations: mentions clearing sensitive data and staleness. Consistent with destructiveHint=true.

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 filler. 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?

Single-param tool with no output schema; description covers usage, purpose, and pairing with siblings. Annotations cover safety.

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 param 'key' with description 'Memory key to delete'. Description restates 'by key' without adding new meaning.

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

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

Description uses specific verb 'Delete' with resource 'memory by key'. It distinguishes from siblings 'remember' and 'recall'.

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

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

Explicitly states when to use: 'when context is stale, the task is done, or you want to clear sensitive data'. Also advises pairing with related tools.

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

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

The description adds behavioral context beyond annotations by explaining the fetch-extract-emit process and the output format. It aligns with annotations (readOnly, idempotent) with no contradictions.

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

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

The description is well-structured with a clear first sentence stating purpose, followed by process and use cases. It is slightly verbose but front-loaded and efficient.

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

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

The description fully explains the tool's functionality, output format, and use cases without needing an output schema. It is complete for the tool's complexity and parameter set.

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 schema already fully documents both parameters. The description adds minimal extra meaning beyond context, meeting the baseline for high coverage.

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

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

The description clearly states the tool generates an llms.txt file for any URL, specifying the output format and use cases. It distinguishes from siblings by being the only tool dedicated to llms.txt generation.

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 lists three specific use cases (client indexing, personal project drafting, competitor auditing) but does not explicitly state when not to use or compare to alternative tools like ai_visibility_check or scan_competitor_ai_presence.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds context about default behavior (active only) and return fields, which is helpful but not contradictory.

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 efficiently convey purpose, return fields, and usage guidance. No redundant or irrelevant 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?

Given the tool's simplicity (one optional parameter, no nested objects, clear annotations), the description covers purpose, usage, and return fields sufficiently. No missing critical information.

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

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

Schema coverage is 100% for the single parameter include_inactive, which is documented in the schema. The description implies the default (active) but doesn't add significant new 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 'List the caller's active subscriptions' and lists the return fields, clearly identifying the verb (list) and resource (subscriptions). It distinguishes from siblings like subscribe/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?

The description provides clear when-to-use context: 'Use this to review what you're monitoring before adding more or to find an id to cancel.' It lacks explicit when-not-to-use or alternative named tools, but given the siblings, it's adequate.

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

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

The description goes well beyond the sparse annotations (all false) by disclosing key behavioral specifics: filing without an account returns a claim_token, which can be reused to check resolution status; rate limit of 5 per identifier per day; free and not counted against tool-call quota; team reads digests daily; and the direction that signal affects roadmap. It also warns against pasting end-user prompts, shaping how the tool should be invoked. This meaningfully enriches the agent's understanding of side effects and lifecycle.

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

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

The description is longer than average but every sentence carries substantive information: purpose, usage triggers, scope exclusions, token mechanics, rate limits, and cost. It is front-loaded with the core purpose and then proceeds logically through usage conditions and operational details. While slightly verbose, it remains well-structured and free of fluff; a 4 reflects the efficient yet thorough organization.

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

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

Given the tool's moderate complexity (4 params, nested object, enum) and absence of an output schema, the description is highly complete. It explains the input scenarios, the claim_token return and subsequent usage, the rate limiting, and the human review process. Combined with the schema's full parameter documentation, the agent has sufficient context to select and invoke the tool correctly and to understand the follow-up workflow. No critical behavioral aspect is left 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?

The input schema already provides 100% coverage for all four parameters with descriptive text. The description adds semantic value by explaining the claim_token flow ('pass it back later as pipeworx_feedback({claim_token:"pwfb_…"})'), clarifying the meaning of type values through the 'Use when' mapping (bug/feature/data_gap/praise), and instructing that the message should be framed in terms of Pipeworx tools/packs. This supplements the schema with practical usage context, though it does not exhaustively discuss every parameter.

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

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

The description clearly states a specific verb+resource: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It enumerates concrete feedback types (bug, feature, data_gap, praise) and explicitly differentiates this tool from sibling tools by scope: 'ONLY for tools served by this Pipeworx connection,' contrasting with other MCP servers. This firmly establishes what the tool does and its unique role in the catalog.

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

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

Explicit when-to-use guidance is provided with concrete triggers: 'Use when a tool returns wrong/stale data (bug), when a tool you wish existed isn't in the catalog (feature/data_gap), or when something worked surprisingly well (praise).' It also gives a clear exclusion rule: feedback about non-Pipeworx MCP tools should be filed elsewhere, and provides criteria for identifying Pipeworx tools. This is model-appropriate usage guidance that fully distinguishes when to invoke this tool versus alternatives.

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

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

The description adds significant context beyond annotations: mentions derived from CF analytics-engine, no PII, cached 5min-1h, and the nature of the data (tools, packs, volume). Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, which description supports 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 concise (3 sentences plus a bullet list of use cases), front-loaded with purpose, and every sentence earns its place with no wasted words.

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

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

Given the tool has one parameter, no output schema, and rich annotations, the description adequately explains return values (top tools, top packs, total call volume) and caching behavior. It could mention pagination or size limits, but the provided information is sufficient for correct invocation.

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

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

Schema coverage is 100% with a single parameter 'window' having an enum and description. The description adds utility: 'Shorter windows surface what's hot right now; longer windows show steady-state demand', adding meaning beyond the schema.

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

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

The description clearly states 'Returns the top tools, top packs, and total call volume over a recent window', using specific verb and resource, and is distinct from sibling tools like discover_tools or ask_pipeworx.

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

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

The description explicitly lists three use cases (discovering hot data sources, confirming canonical tool, seeing alignment), but does not explicitly state when not to use or name alternatives, though the context makes it 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?

The description discloses detailed behavioral traits: monotonicity checks, partition sum checks, similarity threshold (Jaccard ≥0.30), placeholder filter, fill check with book depth analysis, and conditions like realizable_edge_pp ≤ 0 indicating no executable trade. This goes far beyond the annotations (readOnlyHint, idempotentHint) and provides comprehensive transparency.

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

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

The description is packed with information but well-organized: it starts with the main purpose, then explains each mode with details, and ends with response structure and fill check. While somewhat long, every sentence contributes value. Minor improvement could be more structured formatting (e.g., bullet points), but it remains 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?

Despite no output schema, the description thoroughly explains the response fields (opportunities[], partition_check, fill check results) and conditions for each. It also references the sibling tool for custom sizing. The description fully covers what an agent needs to understand and use the tool correctly.

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

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

Both parameters (event, topic) are described with examples and usage context in the description. The input schema already has good descriptions, but the tool's description adds meaning: explains that event accepts slugs or URLs, topic accepts seed questions, and what each mode does. Since schema coverage is 100% and the description enriches the semantics, this is highly effective.

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 finds arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It distinguishes three modes: no args for trending scan, event for per-event partition check, and topic for cross-event scan. This provides a specific verb-resource pairing and clearly differentiates usage scenarios.

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

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

The description provides clear guidance on when to use each mode: no args for a trending scan, event for a specific market, topic for cross-event scanning. It explains the rationale for cross-event mode and mentions the sibling tool polymarket_fill_risk for custom sizing. However, it lacks explicit 'when not to use' statements or direct comparisons with all sibling tools.

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

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

The description adds substantial behavioral context beyond annotations, detailing edge calculation, Kelly sizing, slippage handling, caching, diagnostics, and tradeable-edge filters. No contradictions with annotations.

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

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

The description is lengthy but well-structured with clear sections. Every sentence adds value given the tool's complexity, though it 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?

The description covers response structure, segments, diagnostics, caching, and parameter behavior in detail. Without an output schema, it fully compensates by explaining the fields and organization.

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), and the description enriches them with usage details, examples, and behavior explanations (e.g., min_partition_leg_kelly per-leg application).

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 scans top Polymarket markets to find opportunities where Pipeworx data disagrees with market price, using a specific verb and resource. It distinguishes itself from siblings by detailing unique model families and segments.

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

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

The description explicitly states the tool is for 'what should I bet on today' and elaborates on the model families, knobs, and filters. While it doesn't directly compare to sibling tools, the context clearly implies its distinct purpose.

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

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

Discloses data freshness (daily snapshots, cache-miss triggers), 60-day TTL, decay calculation from daily closes not intraday, snapshot gap behavior. Annotations already show readOnly/idempotent, so description adds rich operational context 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?

Front-loaded with core purpose, but includes detailed output format and edge cases that lengthen it. Some technical details could be streamlined, but overall efficient for the complexity of the tool.

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

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

No output schema, but description thoroughly explains return fields (tracked, expired, snapshot_dates) with subfields, limitations, and behavior (gaps, sign convention). Covers all key aspects an agent needs to interpret results.

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

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

Schema provides default and range for days, allowed values for window. Description adds default values and constrains days to 2-30, but schema already has clamp logic. Provides window options explicitly, adding slight value over 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?

Clearly states tool provides 'edge persistence and decay telemetry' from daily snapshots, answering how long an edge existed and if it's shrinking. Distinguishes from sibling polymarket_edges by focusing on historical trends vs current 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?

Explains when to use (to differentiate fresh vs old edges) and warns that old wide edges are suspicious. Does not explicitly contrast with alternatives like polymarket_edges, but context implies usage for temporal analysis.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive. The description adds significant behavioral context: it explains the ladder-walking mechanism, the verdicts (clean|degraded|cannot_fill), the forced directional risk, and the interpretation of size_usd for baskets. 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 well-structured with clear sections for single-market and basket modes, usage guidance at the end, and timely warnings. It is informative but somewhat lengthy; a few sentences could be trimmed without losing essential information. Still, it is efficient for the complexity.

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

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

Given 4 parameters, no output schema, and no nested objects, the description is complete. It explains both modes, details return fields (theoretical_sum, realizable_sum, capture_ratio, profit_usd, per-leg fill detail, thin_legs, max_clean_notional_usd, forced_directional_risk), and provides usage warnings. No output schema makes this thorough coverage essential, and it delivers.

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

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

Schema coverage is 100%, so baseline is 3. However, the description adds substantial meaning: it clarifies the difference between single-market and basket modes, explains the default side logic for baskets, and defines size_usd as 'settlement notional S (shares per leg)' for baskets. It also specifies default values and clamps, 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 performs a 'Realizable-vs-theoretical edge check against live CLOB order-book depth.' It distinguishes between single-market and basket modes, lists returned fields (top_of_book, vwap_fill_price, slippage_pp, etc.), and differentiates from sibling tools like polymarket_arbitrage and polymarket_edges by specifying pre-use context.

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

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

Explicitly states when to use: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500.' It explains the rationale—theoretical overround on thin books is not capturable, and partial basket fills convert arb into unhedged directional position—providing clear decision criteria.

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

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

Even with readOnlyHint=true, idempotentHint=true, and destructiveHint=false already covering the safety profile, the description adds exceptional behavioral context: the token-overlap matcher semantics, that compatibility_warning/codes[] can be non-empty even when pairs are returned, that null temporal_alignment means 'could not be computed' not 'aligned', the pairing_unverified flag always being set, and the gross-vs-net fee disclosure. 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 purpose and modes are front-loaded well, but the description is one dense, sprawling paragraph covering every compatibility code, per-entry flag, skip counter, and fee nuance. While complexity justifies much of this, it is over-stuffed and could be restructured (e.g., bulleting the safety codes, separating response format from behavioral warnings) to improve scannability. It earns its content but not its current form.

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

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

With no output schema, the description carries the full burden of explaining return values — and it does so thoroughly: leg-by-leg prices, spread[].top_spreads_pp semantics, compatibility_warning/codes[], temporal_alignment fields, fees_note, and skipped_* counters. Minor gaps exist (exact top_spreads_pp entry fields beyond flags are not enumerated), but for a complex two-mode tool with rich safety protocol, coverage is near-complete.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds real value beyond the schema: it explains that topic and explicit modes run the IDENTICAL matcher, that the two explicit params together form a pairing (overriding the topic-mapped side), and enumerates the 10 shortcut values with 'fed'/'btc' examples mirrored in schema examples. The richer mode-semantics context justifies one point 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 opening line states a specific verb+resource: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' This clearly separates it from siblings like polymarket_arbitrage (net edge) and polymarket_edges. The 2-25pp magnitude and outcome-scope detail sharpen what it computes. The purpose is unambiguous 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 mode selection explicitly: topic shortcuts for pre-mapped macros vs explicit kalshi_event_ticker + polymarket_event_slug for custom pairings. The closing caveat ('pre-mapped ≠ tradeable', 'most pre-mapped topics return compatibility_warning today') sets realistic usage expectations. It doesn't name sibling tools as alternatives, but the fees_note implicitly distinguishes this gross-spread tool from an arbitrage/edge tool, providing indirect routing.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds value by disclosing that lodging rates vary by month/season and that the tool returns both a monthly lodging ceiling and a flat M&IE rate. However, it doesn't explain behavior around missing cities, invalid state codes, or the exact response shape — with no output schema, a bit more behavioral detail would be useful.

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 plus an example. Every sentence earns its place: the first defines scope and output, the second gives a concrete usage example. No filler or redundant restatement of the name.

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

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

For a simple read-only lookup with 100% schema coverage and full annotations, the description covers the core semantics, output values, and an example. The only gap is the lack of an output schema means agents don't know the exact field names in the response (e.g., whether lodging ceiling is labeled 'lodging_rate' or 'monthly_ceiling'), but the description clearly describes the two values returned.

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 schema already documents all four parameters thoroughly. The description adds contextual meaning for city and state by tying them to the lookup, and mentions the year default implicitly through the example ('year: 2026'). However, it doesn't add meaning beyond what the schema already provides for _apiKey or year, 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 states a specific verb and resource: 'Get US federal per diem rates' for a city by name and state. It also distinguishes from rates_by_zip by specifying city/state lookup and describes the return values (monthly lodging ceiling and M&IE daily rate). The example call reinforces the purpose.

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

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

The description clearly says when to use the tool: to get per diem rates for a named city and state. It implies the alternative is rates_by_zip (sibling tool) for ZIP-based lookups, though it doesn't explicitly say 'use rates_by_zip for ZIP codes.' The example provides a concrete invocation pattern, which helps the agent understand usage context.

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

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

Annotations already declare readOnly, idempotent, open-world, and non-destructive behavior. The description adds valuable contextual behavior: lodging rates vary by month/season and M&IE is a flat daily rate. No contradiction with the annotations exists.

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

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

Three focused sentences cover the resource, the return semantics, and a concrete call example. Every sentence earns its place and the main purpose is front-loaded.

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

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

With no output schema, the description compensates by specifying the returned values precisely. It could additionally mention behavior for invalid or unsupported zip codes, but for a simple read-only lookup the information provided is largely 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?

The input schema has 100% description coverage for all three parameters, including the zip format, year default, and optional API key. The description adds only a concrete example and doesn't need to repeat parameter details, 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 specific verb and resource: "Get US federal per diem rates ... by zip code." It also clarifies what is returned: the monthly lodging ceiling and the flat M&IE daily rate. Though it doesn't explicitly contrast itself with the sibling rates_by_city tool, the zip-code qualifier makes the core distinction clear.

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

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

The intended use case is clear from "by zip code" and the example call, but there is no explicit guidance about when to choose rates_by_zip over rates_by_city or what to do when only a city name is available. This is implied rather than explicit routing among 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?

Description adds scoping behavior (by identifier) and listing behavior beyond annotations. No contradiction with annotations (readOnlyHint, idempotentHint, destructiveHint).

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

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

Three sentences, each essential: first states core functionality, second provides usage examples, third adds context. Concise and well-structured.

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

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

For a simple read-only tool with one optional parameter and no output schema, the description fully covers purpose, usage, parameter behavior, and related 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%, and the description adds meaning by explaining the effect of omitting the key parameter (list all keys), which adds value beyond the schema.

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

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

The description clearly states the tool retrieves values saved via 'remember' or lists all saved keys, with specific verb and resource. It distinguishes from sibling tools (remember, forget).

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

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

Explicitly states when to use (look up stored context), when to omit key (list all keys), and pairs with related tools (remember, forget). Provides clear guidance on scoping.

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. Description adds context about returned fields (source, citation_uri, payload), filtering behavior, and side effect of mark_read. No contradiction.

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

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

Description is concise (3 sentences) and front-loaded with primary purpose. Every sentence adds value: purpose, return fields, filtering, mark_read mechanism, and alternative access. No fluff.

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

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

For a read-only polling tool with good annotations and full schema coverage, the description is nearly complete. It mentions return fields and alternative endpoint. Lacks explicit bounds on limit and details on error handling, but adequate.

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

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

All 5 parameters have schema descriptions (100% coverage). Description adds practical context: type example 'sec_8k', since as ISO timestamp, mark_read flags events read, and limit default. This significantly enhances schema info.

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

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

Description clearly states it pulls fired events from subscription feed, mentioning filtering and mark_read. However, it does not explicitly differentiate from sibling tools like list_subscriptions or ask_pipeworx, which might also retrieve alerts.

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

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

Description implies usage for retrieving recent alerts and mentions polling is fine, plus notes an alternative HTTP endpoint. But it does not explicitly state when not to use or contrast with sibling tools.

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

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

Beyond annotations (readOnly, idempotent, not destructive), the description adds key behavioral traits: fan-out to multiple sources, fallback logic, and USPTO sunset limitation. It also describes the return structure (grouped changes, total count, citation URIs), which annotations lack.

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 yet concise, front-loaded with example queries. Every sentence serves a purpose: stating function, listing sources, explaining fallback, defining parameter semantics, and distinguishing from siblings. No wasted words.

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

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

Given the tool's complexity (multiple data sources, fallback, output without schema), the description covers all essential aspects: input examples, source behavior, return structure, and limitations. It fully equips 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 coverage is 100%, but the description adds valuable examples and usage hints (e.g., ISO date format, relative shorthand like '30d', ticker vs. CIK). It clarifies that 'type' only supports 'company' and provides typical values for 'since'. This exceeds baseline 3 by offering practical guidance.

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's a change feed for a company in a time window, listing example queries and specific data sources (SEC, GDELT/GNews, USPTO). It explicitly distinguishes from the sibling tool 'entity_profile' for static profiles, ensuring no confusion.

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

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

The description provides explicit when-to-use guidance (e.g., 'What's new with X') and directs users to 'entity_profile' for static profiles. It also details fallback behavior (GDELT→GNews) and notes USPTO soft-fail, giving clear context for usage.

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

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

Adds value beyond annotations by explaining persistence behavior (authenticated users permanent, anonymous 24h). Annotations already indicate idempotent and non-destructive; description complements 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?

Four sentences, front-loaded with purpose, then when-to-use, then behavioral details. No wasted words.

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

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

Given simple schema and no output schema, the description covers all necessary aspects: purpose, usage context, data persistence, and related tools. Complete.

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

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

Schema coverage is 100% and description repeats key-value pair, but does not add new semantics. Baseline score 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?

Clearly states the tool saves data for later reuse across conversations/sessions. Distinguishes from sibling tools recall and forget by naming them explicitly.

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 specific when-to-use guidance: when discovering something worth carrying forward (examples given). Also recommends pairing with recall and forget.

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

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

The description goes well beyond the readOnly/openWorld/idempotent annotations by disclosing cascaded lookups, graceful degradation of LEI/FIGI enrichment, explicit reporting of unresolved identifiers, and ambiguity handling via figi_candidates. No annotation contradiction exists.

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

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

The description is long but front-loaded with trigger examples and the 'Use FIRST' directive, and it is organized around SUPPORTED TYPES. Some parentheticals are dense, but nearly every sentence carries operational guidance, so the length is justified.

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

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

With no output schema, the description carries the return-behavior burden and does so thoroughly: it specifies source-labelled identifiers, unresolved fields, candidate lists for ambiguous matches, RxNorm citations, and graceful degradation. This is enough for an agent to call the tool correctly and interpret the result.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds important operational detail: accepted formats (ticker/CIK/ISIN/name), the requirement to pass only the entity name, and the bond-specific warning about trailing security-class words. This materially reduces misuse beyond the schema alone.

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

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

The description leads with concrete user phrasings and states exactly what it does: resolve a user-spoken name to canonical identifiers other tools require. It clearly positions itself as the first-step lookup tool but does not explicitly differentiate itself by naming a specific sibling, so it is clear but slightly under-distinguished.

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

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

It explicitly instructs to 'Use FIRST whenever you have a name but need an ID' and enumerates supported entity types, input formats, and enrichment behavior. It gives strong context for when to use the tool, though it does not state when-not-to-use it or point to specific alternative tools.

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

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

Annotations already provide readOnlyHint, idempotentHint, etc. The description adds behavioral details: it probes each entity with `ai_visibility_check`, ranks by score, and returns a ranked list with score, confidence, and signal density. No contradictions with annotations.

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

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

The description is three sentences, each carrying essential information: purpose, process, and use case. No redundant or filler content. Properly front-loaded with the main action.

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

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

Given no output schema and moderate complexity, the description covers purpose, process, and output items (score, confidence, signal density). It does not explain 'signal density' in detail, but the explanation suffices for agent understanding.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds extra semantics: for `entities`, it specifies the first entry is treated as 'subject' for narrative; for `models`, it explains omission defaults to workers-ai. This additional guidance improves usability beyond the schema alone.

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

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

The description clearly states the tool compares AI visibility across multiple entities, using `ai_visibility_check` internally, and ranks results by score. It distinguishes from siblings like `ai_visibility_check` by focusing on side-by-side competition.

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 highlights the tool's value for competitive AI-marketing audits ('does Claude know about us as well as our competitors?'), implying when to use it over single-entity tools. It does not explicitly list when not to use, 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?

Description adds behavioral details beyond annotations: fans out to two sources, first-time bundlephobia measurement can take 5-30s, partial failures graceful with sources_failed list. 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?

Single well-structured paragraph covering purpose, usage, behavior, and return values. Slightly long but each sentence adds value; front-loads core purpose.

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

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

Despite no output schema, description lists all return fields (summary block, advisory detail, links, alternative versions). Covers all necessary context for agent invocation.

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

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

Schema coverage 100% with descriptions for both parameters. Description adds context: scoped packages accepted, version defaults to latest if omitted, providing 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?

Description clearly states it's a composite check for npm package evaluation (safety, popularity, size). Distinguishes from siblings like scan_competitor_ai_presence by focusing on dependency analysis, not competitive presence.

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: when agent asks about safety/popularity/size of an npm package. Also notes limitations (NPM only, fallback for other ecosystems) and partial failure behavior.

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 read-only behavior. The description adds valuable behavioral details: returns top-N passages with offsets and similarity scores, mentions the embedding model (BGE-base-en), window strategy (500-char overlapping), and a 200K char cap with truncation flag. This exceeds what annotations provide.

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

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

The description is 5-6 sentences, front-loaded with the core purpose, and every sentence adds value. Slightly verbose in technical details (model name, window size) 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?

Despite no output schema, the description fully explains the return format (passages with offsets and scores) and behavioral constraints (truncation). Combined with high schema coverage and transparent annotations, this is entirely 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 enhances each parameter: 'text' gets context about max size, 'query' includes realistic examples, and 'limit' states default and range. This adds meaning 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 uses a specific verb+resource combination: 'Semantic search INSIDE a fetched record.' It clearly distinguishes from siblings by contrasting with 'ask_pipeworx_grounded' and implying this is for searching within a single document rather than broader 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?

Explicitly states when to use: 'Use when the record is too big to cram into the prompt' and provides an alternative: 'Pairs with ask_pipeworx_grounded: fetch with the gateway, ground over the relevant passages.' This gives clear context and exclusion criteria.

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

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

Discloses beyond annotations: requires OAuth account, returns subscription id, SMS 10/day cap, webhook auto-disabled after 10 failures, and details on signing secret. Annotations show readOnlyHint=false, idempotentHint=true, destructiveHint=false, and description adds rich behavioral context 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?

Well-structured with front-loaded purpose, then constraints, then type details, then delivery channels. Every sentence adds value, though slightly verbose with nested examples; could be tightened without losing clarity.

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 all relevant aspects: prerequisites, parameter formats, delivery options with technical constraints, rate limits, and failure behavior. No output schema, but description adequately addresses what the tool returns. Complete for a subscribe 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%, yet description adds substantial meaning: type-specific filter examples (e.g., sec_8k items codes, polymarket_edge topics), delivery details (SMS must match verified phone, webhook signing secret returned once). Significantly enhances 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 explicitly states 'Create a proactive monitoring subscription to a live-data event stream.' This is a specific verb+resource with clear distinction 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?

Describes prerequisites (Pipeworx OAuth account, anonymous/BYO cannot persist), lists supported subscription types with parameter examples, and explains delivery channels with important caveats. Lacks explicit when-not-to-use or alternative tool references, but provides strong contextual guidance.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, so the safety profile is clear. The description adds behavioral context about the tool returning live example questions with tool+argument shapes, but does not discuss limitations like rate limiting or response size. The description does not contradict annotations.

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

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

The description is moderately long but well-organized with parentheses and lists. It front-loads the key use cases and ends with usage tips. 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 fully explains the response structure (category-bucketed examples with tool+argument shapes). It covers the argument, behavior, and context for first use. For a simple onboarding tool, this is complete.

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

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

Input schema has 1 optional parameter with a description listing general categories. The description expands on this by providing the exact allowed topic values (finance, pharma, etc.) and clarifies the effect of omission. Schema coverage is 100%, so the description adds meaningful value beyond the schema.

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

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

The description clearly states the tool is the onboarding entry point for new users, providing example questions and capability overview. It uses specific verbs and resources like 'returns category-bucketed example questions' and distinguishes from siblings such as ask_pipeworx and discover_tools by explicitly stating to use this first.

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 FIRST when you do not yet know what Pipeworx can do for you, or to learn how to call the meta-tools.' It also explains when to pass a topic for focused results. While it doesn't list when NOT to use, the guidance is clear and actionable.

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

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

Annotations declare destructiveHint false and idempotentHint true. The description adds 'deactivated (not deleted)' and explains that historical events remain, providing additional behavioral context 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, no extraneous words, front-loaded with the core action. Every sentence adds value.

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

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

For a simple tool with one parameter and no output schema, the description fully covers purpose, behavior, ownership, and side effects. 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 coverage is 100% with a clear description for the 'id' parameter. The tool description does not add new information beyond what the schema provides, so baseline of 3 is appropriate.

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

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

The description clearly states the verb 'Cancel' and the resource 'subscription', and distinguishes from siblings like 'subscribe' and 'list_subscriptions' by specifying ownership enforcement and deactivation behavior.

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

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

It explicitly says ownership is enforced, telling the agent when it can be used (only for own subscriptions) and what happens (deactivated, not deleted, historical events remain). It does not explicitly contrast with other tools but provides enough context.

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

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

Beyond the annotations (read-only, idempotent, open-world), the description discloses critical edge-case behaviors: could_not_verify means the check did not happen and must not be shown as evidence, including verification_error{stage,detail}; unsupported means no source exists. It also explains routing to SEC EDGAR vs grounded pipeline and return value structure, adding substantial context not available in annotations.

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

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

The description is dense but every sentence carries essential information: user intents, use cases, routing logic, verdict values, citation behavior, and error disambiguation. It is front-loaded with the most common invocation patterns and ends with important caveats, avoiding redundancy and staying well-organized.

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

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

With no output schema, the description fully documents the return payload: verdict enum, actual value with citation, and reasoning, plus the special error semantics. It also covers parameter behavior, internal routing, and limitations (could_not_verify vs unsupported). For a 2-parameter, read-only tool, this is comprehensive and leaves no major gaps.

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

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

The schema already describes both parameters, but the description adds crucial semantics for tolerance_pct: how it overrides the implied wording tolerance, the recommended range (1–2%) for hallucination detection, and the default cap of 5%. This goes beyond the schema's basic type and example descriptions, making the parameter behavior much clearer.

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

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

The description opens with concrete natural-language queries ("Is it true that…", "fact check", "verify the claim that…") and states the tool verifies factual claims against authoritative sources. It clearly distinguishes itself from siblings by focusing on claim verification and explicitly covering both structured financial and general grounded paths.

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

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

It explicitly states when to use: whenever the agent needs to check if something a user said is factually correct. It also notes the tool replaces 4–6 sequential calls, implying a streamlined alternative. However, it does not explicitly name sibling tools to use instead for non-claim tasks, so it lacks a clear when-not/alternatives comparison.

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