Merriam Webster

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

Annotations already declare readOnlyHint, idempotentHint, etc. Description adds that it probes Workers AI free and optionally Anthropic with BYO key, returns per-model {score, confidence, signals, raw_response} plus combined view—useful 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 with no waste: first sentence covers core action and output; second provides usage context and parameter clarification. 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?

Given the tool's complexity (multiple models, optional auth, structured output), description covers purpose, parameters, and typical use cases. Lacks error handling details but is sufficient for a non-destructive read 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 has 100% description coverage (baseline 3). Description adds value: explains default model, that '_apiKey' is required only for Anthropic, and 'context' helps disambiguate entities.

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 precise verb+resource ('probe LLMs for entity knowledge and score visibility'), and distinguishes from siblings (e.g., ask_pipeworx) by focusing on AI visibility across models.

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

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

Explicit usage contexts: AI-marketing audits, pre-launch brand checks, competitive monitoring. However, it does not explicitly state when not to use it or list alternatives among siblings.

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 a safe read-only, idempotent profile. The description adds useful behavioral context by disclosing that the tool routes to internal tools, fills arguments automatically, and returns structured answers with stable citation URIs. It doesn't cover limits or error behavior, but it meaningfully informs the agent beyond the annotations.

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

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

The description is front-loaded with the most important routing decision, then provides mechanism, trigger phrases, examples, and escalation guidance. It is slightly redundant — 'even if web search could also answer it' and 'START HERE' repeat the same point — but overall it is compact, scannable, and 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?

For a free-text question router with no output schema, this is unusually complete. It covers selection criteria, input semantics, routing behavior, alternatives, and return characteristics. An agent has everything needed to select and invoke the tool correctly.

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

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

The schema fully documents the 'question' parameter and its five aliases with 100% coverage. The description adds semantic depth by clarifying accepted input: current/historical real-world facts, specific entity/number questions, and natural-language phrasings with concrete examples like 'current US unemployment rate' and 'Apple's latest 10-K'.

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 'PREFER OVER WEB SEARCH' and states a concrete function: route natural-language questions to one of 5,710 tools across 1,494 verified sources, fill arguments, and return structured answers with stable pipeworx:// citation URIs. This clearly distinguishes it from web search and sibling research tools by specifying exactly what it 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?

The description gives explicit when-to-use triggers: phrases like 'what is', 'look up', 'get the latest', and specific domains such as SEC filings, FDA data, FRED/BLS stats, patents, clinical trials, and news. It also names an alternative — deep_research — and explains when to step up to it, while noting ask_pipeworx already handles breaking-news routes.

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

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

Annotations already declare read-only, idempotent, non-destructive behavior. The description adds valuable context: this is a live experimental router with candidate routing improvements toggled, currently identical to the stable version, and results are compared against the stable router. This goes beyond annotations. Minor gap: no detail on response contents, but 'same response shape' provides a reference.

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

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

The description is somewhat long but each sentence earns its place: beta status, identity, current state, usage, and a clear clarification that it is a full working router. It is front-loaded with the most important information and could be tightened only slightly.

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 router tool with six simple string params, no output schema, and strong annotations, the description provides enough context about behavior, current state, and usage. It does not detail return format, but 'same response shape' and the stable reference suffice.

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 each parameter described, mostly as 'Alias for question.' The description adds no parameter-specific meaning beyond 'same arguments as ask_pipeworx'. The schema already carries the semantic weight, 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 this is a 'Beta version of ask_pipeworx: identical universal router' routing to 5,710 tools with the same arguments and response shape. It clearly differentiates itself from the sibling ask_pipeworx by its experimental status while acknowledging they are currently identical.

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

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

The description gives a clear directive: 'Use it exactly like ask_pipeworx when you want the newest routing.' It also explains that no candidate is active right now, so it currently matches the stable router. However, it does not explicitly state when not to use it or list alternative tools like ask_pipeworx_grounded, so it lacks an explicit exclusion.

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

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

Annotations already mark readOnly/idempotent/non-destructive, and the description adds substantial behavioral detail beyond them: it reveals the internal routing/argument-filling, the grounding constraint, the exact success and refusal shapes, and the extra LLM-call cost. It also discloses failure modes such as data_truncated and llm_error, so the agent knows what to expect rather than assuming a plain answer.

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

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

The description is dense but every sentence earns its place: purpose, mechanism, return/refusal contract, use cases, and cost/alternative. The most important scoping information is front-loaded, and nothing is padding.

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

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

For a tool with no output schema, high complexity, and a critical hallucination-avoidance role, the description is complete: it covers what happens on success, every refusal reason, when to use it, and how it differs from the cheaper sibling. An agent can correctly invoke it and interpret its response without further lookup.

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

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

Schema description coverage is 100% for the question parameter, and the schema itself documents the natural-language input and accepted aliases. The description adds no tool-specific parameter detail beyond that baseline, so a 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 names a specific mode ('Hallucination-resistant answer mode for high-stakes reads'), states its core mechanism ('picks the right tool... fetches the data — then EXTRACTS the answer using ONLY what the tool result contains'), and differentiates it from the sibling ask_pipeworx by emphasizing grounded extraction with explicit refusals. This is far beyond a tautology and tells an agent what the tool is for.

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 explicit when-to-use conditions ('whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts') with concrete domains, and explicit when-not-to-use guidance ('prefer ask_pipeworx for casual lookups') plus a cost-based reason. This leaves no ambiguity about selection relative to its siblings.

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

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

Annotations (readOnlyHint, etc.) are not contradicted. The description goes far beyond annotations, detailing resolution process, response structure, resolver contract, safety mechanisms (low-confidence short-circuit, closed markets), tradeability warnings, and news fallback fields. Very transparent.

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-organized with sections (RESPONSE SHAPES, RESOLVER CONTRACT, etc.) and examples. Every sentence adds value for a complex tool. Slightly verbose but justified by content richness.

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, response fields, resolver behavior, safety checks), the description is very complete. It covers all critical aspects without an output schema. Thorough and actionable.

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

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

Schema coverage is 100% (all parameters described). The description adds significant value: examples for market parameter, depth enum explanation, and include_raw behavior. It enriches 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 title and description clearly state the tool researches a Polymarket bet by pulling Pipeworx data. It specifies multiple input types (slug, URL, question text) and distinguishes itself from sibling tools by focusing on bet research with data fan-out.

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

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

Explicit usage examples are given: 'should I bet on X', 'what does the data say about Y', 'is there edge in Z'. While it doesn't explicitly state when not to use, the guidance is clear and contextual. No alternative tool is mentioned, but siblings exist.

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

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

Annotations already indicate safe read-only, idempotent behavior. The description adds vital details: for companies, pulls latest 10-K data from EDGAR/XBRL with correct off-calendar fiscal year handling; for drugs, pulls FAERS, FDA approvals, trial counts. No contradictions.

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

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

Description is comprehensive but efficient. Each sentence provides useful information, front-loads example queries, and avoids redundancy. Slightly longer than minimal but justified by explanation of data sources.

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 lack of output schema, the description adequately covers return structure (paired data + citation URIs) and behavior for both entity types. Some details about output format might be helpful but are not essential.

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 both parameters with descriptions. The description enriches by giving concrete examples (tickers/CIKs for company, names for drug) and specifying min/max items, adding value beyond schema.

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

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

The description clearly states the tool performs side-by-side comparisons of 2-5 companies or drugs, pulling specific financial or regulatory data. It uses concrete trigger phrases and distinguishes from siblings like entity_profile.

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

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

The description explicitly advises to prefer this tool over sequential single-entity lookups, provides example queries, and explains when to use it (e.g., 'compare', 'vs', 'rank'). It also mentions replacing 8-15 sequential lookups.

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

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

The description explains what the call does internally (decomposes, routes in parallel, returns findings packet with verbatim evidence, confidence, source, fetched_at, stable citation, gaps[] and contradictions[]), which is useful beyond the readOnly/openWorld/idempotent annotations. It also discloses that large records are semantically excerpted and that 'standard'/'thorough' include contradiction scans, plus expected durations. It does not deeply explain auth errors or rate limits, but the annotations already cover the safety profile.

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

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

The description is information-dense but runs long and front-loads account/cost details before stating the core function. The first sentence is about signing up, which delays the agent's understanding of what the tool does. Every additional behavior is useful, but the structure could be tightened by moving usage conditions after the main 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 no output schema, the description provides a strong mental model of the returned findings packet (evidence, confidence, source, fetched_at, citation_uri, gaps[], contradictions[], hop field). It covers multi-step behavior, depth differences, latency, citation resolvability, and fallback alternatives. This is complete enough for an agent to invoke and interpret results correctly.

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

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

Schema coverage is 100% and the depth parameter already has an enum with descriptions. The description adds meaningful context about what each depth tier changes in terms of hops, gap recovery, contradictions, and paid access. It also clarifies that the question parameter should be a natural-language broad query, reinforcing the schema. This is slightly above baseline because it ties parameters to expected behavior and cost/tiering.

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 a specific verb ('conduct grounded multi-source research'), a precise resource (Pipeworx's 1,494 structured data sources routed in parallel across 5,710 tools), and explicitly distinguishes itself from open-web search. It also names sibling alternatives like ask_pipeworx and bet_research, which helps differentiate.

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 states when to use it (broad/multi-part questions over structured data), when not to use it (for a single lookup use ask_pipeworx), and also specifies an account prerequisite plus a fallback alternative when not signed in. It notes depth tiers and expected latency, so the agent can decide under constraints.

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 state readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral detail beyond annotations, especially the not-found fallback of returning spelling suggestions and the specific kinds of data returned.

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 compact, front-loads the core purpose, lists concrete return fields, mentions the fallback behavior, and includes a helpful example. Every sentence adds value with no unnecessary repetition.

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

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

This is a low-complexity read-only tool with only two parameters, one required, and no output schema. The description adequately compensates for the missing output schema by spelling out what is returned and what happens when the word is not found, making it complete enough for an agent to call correctly.

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

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

Schema description coverage is 100%, so the schema already fully documents both 'word' and '_apiKey'. The description restates the word parameter through an example but does not add meaningful semantic detail beyond the schema, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb and resource: 'Look up a word in the Merriam-Webster dictionary.' It enumerates concrete outputs—definitions, part of speech, pronunciation, etymology—and clearly differentiates from a thesaurus by naming the dictionary source and the kinds of information returned.

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 implied: use this tool when you need a dictionary definition, pronunciation, or etymology. However, it does not explicitly mention when not to use it or how it differs from the sibling 'thesaurus' tool, leaving the usage guidance to inference.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds that the tool returns 'top-N most relevant tools with names, descriptions, and full input schemas (with curated examples)' and that each result is 'ready to call directly, no second schema lookup needed.' There is no contradiction with annotations.

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

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

The description is a single paragraph of moderate length. It is front-loaded with the core purpose ('Find tools by describing the data or task'), then provides use case examples, and ends with explicit guidance. It is concise and each sentence adds value.

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

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

Given that there is no output schema, the description adequately explains what the tool returns: top-N tools with names, descriptions, and full schemas. It covers purpose, usage guidance, and return format. No gaps are apparent.

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

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

Schema coverage is 100%, so the schema already documents all parameters. The description adds meaning by explaining that query accepts aliases (task, q, description, search) and that limit controls the maximum number of results. This goes beyond the schema's brief descriptions.

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

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

The description clearly states the tool's purpose: 'Find tools by describing the data or task.' It enumerates specific domains (SEC filings, financials, FDA drugs, etc.) and distinguishes itself from sibling tools (which are domain-specific) by being a general discovery tool.

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

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

The description gives explicit guidance: 'Call this FIRST when you have many tools available and want to see the option set.' It also notes that results are ready to call directly, eliminating the need for a second schema lookup. This clarifies when to use versus 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 declare read-only, idempotent, open-world, non-destructive. The description adds value by detailing the fan-out across multiple sources, soft-fail behavior for patents (USPTO sunset May 2025), and specific return fields. 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 somewhat long but packs useful information. It front-loads example queries and uses bullet-like structure for outputs. Every sentence adds value, but could be slightly trimmed 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?

Given no output schema, the description comprehensively explains the return structure (cik, filings with URIs, fundamentals, patents, news, LEI) and covers edge cases like patent sunset. Parameter info is complete with schema coverage at 100%.

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

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

Schema coverage is 100% with descriptions for both parameters. The description reinforces meaning: type is only 'company', value is ticker or zero-padded CIK, and explains why names are not supported, adding context 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 provides a full cross-source profile of a US public company, with example queries and a list of data sources and outputs. It distinguishes itself from siblings like resolve_entity and ask_pipeworx by explicitly stating it should be preferred over chaining single-pack 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?

The description explicitly advises to 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups' for holistic views. It also specifies that names are not supported and directs to use resolve_entity first if only a name is available.

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 about why to delete beyond the destructiveHint annotation, explaining common use cases. However, it does not mention behavior on missing keys or irreversibility, which annotations already indicate as destructive.

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

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

Two concise sentences: first states purpose, second provides usage context. No wasted words, 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 tool with one parameter and no output schema, the description covers purpose, usage, and pairing. Lacks explicit mention of error handling or permanence, but annotations compensate for destructiveness.

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

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

Schema covers 100% of parameters with description 'Memory key to delete.' Description does not add extra meaning beyond the schema, meeting 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?

Description clearly states 'Delete a previously stored memory by key' with a specific verb and resource, and distinguishes itself from siblings by mentioning pairing with 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 tells when to use (stale context, done task, clear sensitive data) and implicitly suggests to use sibling tools for other operations via 'Pair with remember and recall.' Lacks explicit when-not-to-use 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, idempotentHint, and destructiveHint as false. The description adds process details ('fetches the page, extracts title/description/links, emits markdown') that reinforce the read-only, idempotent behavior. 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?

Three sentences: first states purpose, second explains process, third lists use cases. No fluff; every sentence adds value.

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

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

Given the simple tool (2 params, no output schema, strong annotations), the description covers purpose, process, output format, and use cases. Slightly lacking details on error scenarios or input validation.

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%: both 'url' and 'max_links' are described with defaults and limits. The description repeats this information without adding new meaning, so baseline 3 is appropriate.

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

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

The description uses a specific verb ('Generate') and clearly identifies the resource ('production-ready llms.txt file'). It distinguishes itself from sibling tools like 'ai_visibility_check' and 'scan_competitor_ai_presence' by focusing on generating the standard file format.

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

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

Explicitly lists three use cases (client indexing, own project, competitor audit) but does not state when to avoid this tool or mention alternatives. The context is clear but lacks exclusions.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. Description adds return field details and optional parameter behavior, 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?

Two sentences: first covers purpose and return fields, second gives usage guidance. No waste, 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 list tool with one optional param and full annotation safety, the description provides all necessary 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 coverage is 100%, and description does not add meaningful detail beyond the schema for the one parameter. Baseline 3 applies.

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

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

Clearly states 'List the caller's active subscriptions' and enumerates return fields, distinguishing 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?

Explicitly states when to use: 'to review what you're monitoring before adding more or to find an id to cancel.'

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 only give false hints, so the description carries the full burden. It discloses rate limits ('5 per identifier per day'), that it is free and doesn't count against quota, the claim_token flow for follow-ups, and that the team reads digests daily. This adds substantial behavioral context beyond the annotations.

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

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

The description is fairly lengthy but every sentence earns its place: purpose, usage conditions, exclusion, clarification, content guidance, token behavior, review cadence, rate limits, and quota impact. Information is front-loaded with the core purpose first, and the structure flows logically.

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 no output schema, the description adequately explains the return behavior (claim_token) and the follow-up mechanism. It covers cost, rate limits, content guidance, and scope boundaries. For the tool's complexity, the description 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?

Schema coverage is 100% with detailed parameter descriptions, but the description adds further semantics: it explains how claim_token should be used with an explicit example and clarifies that message content should reference Pipeworx tools/packs, not paste the end-user's prompt. This enriches the schema beyond its baseline.

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

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

The description opens with 'Tell the Pipeworx team something is broken, missing, or needs to exist,' which clearly states the tool's purpose. It enumerates specific feedback types (bug, feature, data_gap, praise) and distinguishes itself from sibling research/query tools by explicitly limiting scope to Pipeworx-served 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?

Provides explicit when-to-use conditions: wrong/stale data (bug), missing capability (feature/data_gap), or positive feedback (praise). It also gives a clear exclusion: do not use for tools from other MCP servers—file with that server instead—and offers a disambiguation ('Not sure? Pipeworx tool names are the ones this connection lists').

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

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

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint), the description reveals that data is self-aggregating, derived from CF analytics-engine, contains no PII, and is cached 5min-1h depending on window. This adds significant behavioral context.

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

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

The description is compact, front-loaded with the core purpose, and every sentence serves a purpose. No wasted words, and the structure efficiently conveys use cases and caveats.

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 simplicity of the tool (one optional parameter, no output schema), the description is complete: it explains the return structure, caching policy, and data source. No gaps remain for an AI agent to guess.

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

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

The schema already covers the single parameter (window) with full enum descriptions. The description adds value by explaining the trade-off between shorter and longer windows, providing semantic guidance 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 it returns top tools, top packs, and total call volume over recent windows. It uses specific verbs ('returns') and resource ('trending signals'), and distinguishes itself from sibling tools like 'discover_tools' by focusing on what other AI agents are calling.

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 explicit use cases (discovering hot sources, confirming canonical choice, seeing alignment) and explains how window choice affects results. It does not explicitly state when not to use it, but the context is clear enough for an AI agent to decide.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint=true, but the description adds critical behavioral details: monotonicity checks, partition-sum deviation thresholds (3pp), similarity thresholds (0.30 Jaccard), placeholder filters, fill check with book depth, and warnings not to trade when realizable_edge_pp <= 0. This goes well beyond the annotations.

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

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

The description is dense and informative, but could be more concise. It packs many details into a single paragraph without subheadings, which might overwhelm some agents. However, every sentence adds value, and core information is front-loaded. Loses one point for lack of structural 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?

Given no output schema, the description compensates by detailing response fields (opportunities[], partition_check, fill_check) and conditions for safe trading. It covers input modes, behavioral rules, threshold limits, and even what not to do. For a complex tool with two optional parameters, this is remarkably complete.

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

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

Both parameters (event, topic) have schema descriptions, but the tool description adds substantial meaning: it explains the mode each parameter activates, provides examples of valid values (URLs, slugs), and clarifies the different behaviors (single-event vs cross-event scanning, partition_check details). This significantly enhances the agent's 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 starts with a clear verb+resource+method: 'Find arbitrage opportunities on Polymarket via monotonicity violations + partition-sum checks.' This directly states the tool's purpose and distinguishes it from sibling tools like polymarket_edges, which focus on different aspects. The multiple modes are explained, covering all 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 explicitly guides when to use each mode: no args for trending scan, event for single-event, topic for cross-event. It recommends event mode and explains why cross-event catches patterns single-event misses. It also directs users with custom sizing to a sibling tool (polymarket_fill_risk), providing clear 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 extensively discloses behavioral traits: caching (1h KV level keyed on knobs), response structure (by_segment with diagnostics), what happens when segments are empty, slippage handling, and edge computation. This goes well beyond the annotations (readOnlyHint, idempotentHint) 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 comprehensive but overly verbose, with detailed model family explanations. It is front-loaded with purpose but could be more concise. Well-structured with clear sections, but length reduces readability.

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

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

Given 9 parameters with full schema coverage and no output schema, the description thoroughly explains the response structure (by_segment with diagnostics, Fed candidates, funnel counters) and caching behavior, making it complete for complex tool usage.

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

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

Schema coverage is 100% with parameter descriptions. The tool description adds value beyond the schema by explaining how parameters interact (e.g., min_kelly doesn't filter partitions, min_partition_leg_kelly applies to per-leg Kelly, tradeable-edge knobs).

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 Polymarket markets for opportunities where Pipeworx data disagrees with market price, explicitly targeting 'what should I bet on today' use case. It distinguishes from sibling tools by its focus on Pipeworx data and specific model segments.

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

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

The description provides clear context for when to use this tool (discovering betting opportunities) and describes three model segments with their use cases. However, it does not explicitly mention when not to use it or compare directly to sibling tools like polymarket_arbitrage or polymarket_edge_tracker.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds substantial behavioral context: response structure (tracked[], expired[], snapshot_dates[]), trend classification, decay calculation, and data gaps. 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 but verbose, containing over 150 words. While every sentence adds value, it could be more concise without losing information. Front-loading the purpose is good.

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 (time-series, multiple arrays), the description is highly complete. It details every field in the response, explains data gaps and limitations, and provides sufficient information for an agent to use the tool effectively.

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

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

Schema description coverage is 100%, with both parameters fully described. The description reiterates defaults and clamps, but adds no significant new meaning. Baseline score of 3 is appropriate.

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

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

The description clearly states the tool provides edge persistence and decay telemetry from daily snapshots, answering 'how long has this edge existed and is it shrinking?'. This distinguishes it from sibling tools like polymarket_edges (which likely lists current edges) by focusing on time-series 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?

The description explains the use case (comparing fresh vs. old edges) and includes limitations (60-day TTL, daily snapshots). It does not explicitly list alternative tools or when not to use it, but the context is clear enough for an agent.

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

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

Annotations already indicate readOnlyHint, idempotentHint, and destructiveHint false, so the description is not required to repeat these. However, the description adds significant behavioral context: it 'walks the ladder', computes fill details, and warns about forced directional risk and partial fills. This goes beyond annotations without contradicting them.

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

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

The description is relatively long but well-structured with clear sections (REQUIRES, SINGLE-MARKET, BASKET, USE THIS). It front-loads the core purpose and immediately states requirements. Every sentence provides useful information, though some minor repetition could be trimmed without loss.

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

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

Given the tool's complexity (two modes, 4 parameters, no output schema), the description thoroughly covers inputs, return values (listing each field like top_of_book, vwap_fill_price, slippage_pp, etc.), and important risks. It also explains the problem it solves (theoretical vs. realizable edge) and warns about the dominant loss mode in arb-bots. This is a near-complete specification.

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 substantial meaning beyond the schema. It explains how `size_usd` is interpreted differently in each mode (max spend vs. target proceeds vs. settlement notional), the default side logic for basket mode, and the meaning of each return field. This greatly aids correct parameter usage.

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

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

The description clearly states the tool's purpose as a 'Realizable-vs-theoretical edge check against live CLOB order-book depth' and explicitly distinguishes between single-market and basket modes. It provides specific actions (walks the ladder, returns top_of_book, vwap_fill_price, etc.), making it easy to understand what the tool does.

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

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

The description explicitly says 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500'. It also warns about when not to rely on theoretical values due to thin books, and mentions the risk of partial fills converting arb into unhedged positions.

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

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

Annotations already mark the tool as read-only, open-world, idempotent, and non-destructive. The description adds substantial behavioral clarity: compatibility flags and codes, unclassified legs never being paired, skipped cross-type/subtype counters, temporal alignment handling, and the caveat that pre-mapped pairs are not guaranteed tradeable. This goes well beyond what annotations provide.

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

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

The description is long and dense, but the length is justified by the tool's complexity and the need to explain safety fields, compatibility codes, and response characteristics. It is front-loaded with the core purpose and mode distinction, though the formatting is a single dense paragraph that could benefit from structured breaks.

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 no output schema and a fairly intricate response format, the description covers the key response elements (leg prices, top_spreads_pp, compatibility_warning/codes, temporal_alignment, skipped counters, low_confidence_pairs) in enough detail for an agent to interpret results correctly. It also communicates the important domain caveat that a returned pair is not necessarily a real arbitrage opportunity.

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

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

The input schema already documents all three parameters with 100% coverage, and the description adds meaningful mode semantics: topic acts as a shortcut while the other two fields override or customize venue-specific pairings. It clarifies relationships between parameters and enriches the schema without repeating it verbatim.

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

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

The description clearly states that the tool computes the cross-venue spread between Kalshi and Polymarket for matching questions, with an explicit focus on outcome prices and spread. It uses a specific verb and resource, but does not explicitly differentiate itself from sibling tools like polymarket_arbitrage, so it misses the top score.

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

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

The description provides clear context on when to use the two modes — topic shortcuts for pre-mapped macro topics and explicit ticker/slug for custom pairings. It also gives practical caution about pre-mapped topics frequently returning compatibility warnings. It does not explicitly name alternative sibling tools or state when not to use this tool versus another.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds scoping and pairing context, which is useful beyond annotations. 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 a single paragraph, front-loads the main action, and is fairly concise. Could be slightly shorter but 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?

No output schema, but the description explains what to expect (value or list of keys). The tool is simple, and the description provides adequate context for an agent.

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

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

Schema coverage is 100% and already describes the 'key' parameter well. The description reinforces the omitting behavior but adds little new. Baseline 3 is appropriate.

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

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

The description clearly states the tool retrieves a value by key or lists all keys, with specific verbs (retrieve/list) and resource (saved memories). It distinguishes from siblings like 'remember' and 'forget'.

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

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

Explicitly says to use for retrieving stored context and mentions pairing with remember/forget. Scoping info is provided. While it doesn't explicitly state when not to use, the context is clear.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. Description adds valuable behavioral context about the mark_read parameter, explaining that flagging events read will cause subsequent calls to show only newer ones. This goes beyond what annotations provide.

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

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

Description is three sentences, front-loaded with the main purpose. Each sentence adds distinct information (returns fields, filtering, mark_read behavior, polling suitability). 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?

Despite no output schema, description adequately explains return shape (fields: source, citation_uri, payload). It covers parameters, usage guidance, and alternative access method. For a tool with 5 optional parameters, this is comprehensive.

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

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

Schema coverage is 100%, so baseline is 3. Description adds meaning by explaining the semantics of 'type' (example 'sec_8k'), 'since' (ISO timestamp), and 'mark_read' (flags events as read). It does not add much for 'limit' or 'unread_only' beyond schema descriptions, but the added context is useful.

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

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

Description clearly states the tool pulls fired events from the subscription feed, specifies the returned fields (source, citation_uri, payload), and mentions filtering options. It distinguishes itself from sibling tools by focusing specifically on recent alerts from subscriptions.

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

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

Description indicates polling works fine and mentions an alternative endpoint (GET registry.pipeworx.io/alerts.json) for scripts/dashboards. It implies when to use this tool, but does not explicitly state when not to use or compare with siblings.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and non-destructive. The description goes beyond by detailing the multi-source fan-out (SEC EDGAR, GDELT→GNews, USPTO), parallel execution, soft-failure for USPTO, and the structured return format. 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 concisely structured: it opens with user-facing query examples, then explains the behavior, parameters, and alternatives. Every sentence adds necessary information without redundancy. Appropriate length for the tool's complexity.

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

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

Given the tool's moderate complexity and lack of output schema, the description covers return fields (changes[], total_changes, pipeworx:// URIs), the parallel call nature, and source-specific details. Minor gaps: no mention of result limits or pagination, but overall sufficiently complete for agent invocation.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the `since` parameter formats with examples and a recommended default, clarifying that `type` only supports 'company', and detailing acceptable `value` formats (ticker or zero-padded CIK). This practical guidance raises the score above baseline.

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

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

The description clearly identifies the tool as a change feed for a company over a time window, with specific example queries. It distinguishes itself from the sibling 'entity_profile' tool by contrasting temporal vs. static profiles. The verb-resource relation is explicit and unambiguous.

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

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

The description provides explicit when-to-use guidance, including when to prefer alternatives ('Use entity_profile instead when you want the static profile'). It also gives practical advice for parameters (e.g., 'Use "30d" or "1m" for typical monitoring') and explains the fallback behavior between GDELT and GNews.

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

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

Adds beyond annotations: key-value scoped by identifier, authenticated users get persistent memory, anonymous sessions 24h. No contradiction with annotations (readOnlyHint=false, destructiveHint=false, idempotentHint=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?

Four sentences, front-loaded with purpose. Every sentence adds value: what it does, when to use, how it works, pairing with siblings. 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?

Given 2 params, no output schema, 100% coverage, the description covers usage, persistence scope, and sibling tools. Completely adequate for the tool's simplicity.

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

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

Schema coverage 100% with descriptions. Description adds context that it's a key-value pair and gives examples for key formatting (e.g., 'subject_property', 'target_ticker'). Adds value beyond schema.

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

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

Clearly states the tool saves data for reuse across conversations/sessions. Provides specific examples (resolved ticker, target address, user preference) and distinguishes from siblings recall and forget by explicitly naming them.

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

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

Explicitly says 'Use when you discover something worth carrying forward' and 'so you don't have to look it up again.' Mentions pairing with recall and forget. Does not state when not to use, but context is clear enough.

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

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

The description adds significant behavioral context beyond the annotations: identifiers are labeled with their source, unresolved identifiers appear under 'unresolved' rather than being omitted, and LEI/FIGI enrichment degrades gracefully if sources are unavailable. It also reveals internal cascading through multiple endpoints, which explains the value of this tool. No contradiction with readOnly/idempotent hints.

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 not unnecessarily verbose. It front-loads example queries and the 'Use FIRST' guidance, then systematically covers supported types and edge cases. Some redundancy exists (e.g., repeating 'name' in multiple forms), but every sentence adds useful operational detail, making the length justified for a complex multi-type tool.

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

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

Given the tool's complexity (two entity types, multiple source systems, fallbacks), the description is exceptionally complete. It enumerates output fields (CIK, ticker, company_name, LEI, FIGI, RxCUI, ingredient, brand), explains input formats, and addresses failure modes like unresolved identifiers and service unavailability. No output schema exists, so this description effectively fills the gap.

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

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

Although the schema already describes both parameters (type, value), the description greatly enriches their semantics. For 'value', it specifies that company input can be ticker, CIK, ISIN, or name, and drug input can be brand or generic. It also explains the output variations per type, such as ISIN resolving to legal entity via GLEIF. This goes well beyond schema descriptions.

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

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

The description clearly states the tool's purpose: 'resolve a user-spoken NAME to the canonical/official identifiers other tools require as input.' It provides specific verbs and resources (ticker, CIK, LEI, RxCUI) and distinguishes itself from siblings by instructing 'Use FIRST whenever you have a name but need an ID.' This sets it apart from comparison or profile 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 gives explicit guidance: 'Use FIRST whenever you have a name but need an ID.' It also lists supported entity types and example queries that indicate when to invoke this tool. While it doesn't name specific alternatives to avoid, the 'Use FIRST' directive strongly implies precedence over other lookups, making the usage context 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 internal behavior (uses ai_visibility_check per entity, ranks results) and return format (ranked list with score, confidence, signal density). This adds significant detail beyond annotations, which already mark it as read-only, idempotent, and non-destructive. 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 with no waste. First sentence states core purpose, second explains process, third gives use case and return format. Information density is high and front-loaded.

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

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

Given the tool's complexity (4 parameters, no output schema, but rich annotations), the description covers purpose, usage, parameter nuances, and behavioral details. It lacks examples or error handling notes but is sufficient for an agent to select and use it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds extra meaning: 'First entry treated as subject for narrative; rest are competitors' and clarifies model options ('workers-ai' default, 'anthropic' requires _apiKey). This improves selection and invocation understanding.

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

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

The description clearly states the tool compares AI visibility side-by-side, using verbs like 'compare', 'probes', 'ranks', 'surfaces'. It specifies the resource (AI visibility of entities) and distinguishes from sibling tools like ai_visibility_check (single entity) and compare_entities (generic).

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 a concrete use case: 'competitive AI-marketing audits' and a sample question. It implicitly suggests when to use this over siblings (side-by-side vs single probe). However, it doesn't explicitly mention when not to use it or list 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 declare readOnly, openWorld, idempotent, non-destructive hints. The description adds valuable context: it calls external APIs, bundlephobia's first measurement can take 5-30s, partial failures degrade gracefully, and it lists exactly what is returned. 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 dense but every sentence carries meaning. It front-loads the main idea, then usage, then returns, then limitations. Slightly long but justified by the tool's complexity.

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

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

Given the tool's complexity (composite call, multiple sources), schema coverage 100%, and no output schema, the description fully covers purpose, usage, behavior, parameters, and return values. It explains partial failures and ecosystem limitations.

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

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

Schema coverage is 100% with descriptions for both parameters. Description adds extra value: clarifies scoped packages (e.g. '@types/node') are accepted, and version defaults to latest. This goes 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 a composite 'should I add this npm package' check, specifying it fans out across deps.dev and bundlephobia. It distinguishes itself from siblings by focusing on npm packages and providing a bundled check.

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

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

The description provides explicit usage guidance: 'Use whenever an agent asks...' with examples, and notes alternatives for non-npm ecosystems (PyPI/Maven/Cargo/Go) via deps.dev directly. It also warns about potential timing issues and partial failures.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint false. The description adds significant details: embedding model (BGE-base-en), similarity metric (cosine), chunking (500-char overlapping windows), character cap (200K chars with truncation flag). 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?

A single well-structured paragraph, front-loaded with the core action and purpose. Every sentence adds value: explains when to use, the output format, pairing hint, and technical details. No filler or repetition.

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

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

Despite no output schema, the description explains the return value (top-N passages with character offsets and similarity scores). It also includes the embedding model and chunking details, plus the pairing with ask_pipeworx_grounded for grounding. Complete for a semantic search 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% (all three parameters described in schema). The description adds usage examples for 'query' and reminds about the text max length, but does not add substantial new semantic meaning beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description clearly states it performs semantic search inside a fetched record, with concrete examples (SEC 10-K body, article). It mentions pairing with ask_pipeworx_grounded but does not explicitly contrast with other sibling tools like deep_research or recall, so it slightly lacks differentiation.

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

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

Explicitly says when to use: 'when the record is too big to cram into the prompt'. It also explains the benefit: saves context and returns only relevant passages. However, it does not state when not to use or provide alternatives beyond the mentioned pairing.

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 OAuth requirement, subscription creation behavior, delivery verification (SMS/email/webhook), rate limits (10/day SMS), and webhook signing secret one-time return. Annotations already indicate idempotentHint=true and readOnlyHint=false, but description adds useful 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?

Description is fairly long but well-structured: overall purpose, prerequisites, type details, delivery channels. Each sentence adds value; no filler. Slightly verbose with repeated type info, but overall concise given complexity.

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

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

Covers all types and delivery channels, authentication requirements, and limits. Despite no output schema, mentions return value. Complete for a subscription creation tool with complex parameter options.

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 value: concrete examples for each type's params (e.g., sec_8k with items codes, polymarket_edge with topic), delivery channel details with constraints, and specific JSON structures. Enhances understanding beyond schema.

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

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

Description clearly states verb 'Create', resource 'proactive monitoring subscription to a live-data event stream', and output 'Returns the new subscription id'. It distinguishes from siblings like list_subscriptions and unsubscribe by specifying creation of new subscriptions.

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

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

Provides explicit context: requires Pipeworx OAuth account, lists supported types with parameters, and details delivery channels with constraints. Lacks explicit when-not-to-use or alternatives, but context is comprehensive.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint true, and destructiveHint false. The description adds rich behavioral context beyond annotations: it returns category-bucketed examples with live catalog information, explains the optional focus parameter, and describes the tool's role as an onboarding guide. 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 a single paragraph but efficiently packs purpose, example inputs, return format, usage instructions, and context. It is front-loaded with the tool's synonyms and use case. Slightly long but every sentence is necessary. Could be more structured, but it's concise.

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

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

Given no output schema, the description thoroughly explains return format (category-bucketed examples with tool+argument shape). It covers parameter behavior, use cases, and even mentions the live catalog. The tool's role as a first-stop is fully conveyed. Context appears complete for an onboarding tool.

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

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

Schema covers the single 'topic' parameter with description and valid values (finance, pharma, etc.). Description adds meaning by explaining the effect of omitting vs. providing a topic ('full spread' vs. focus). It reinforces the schema's enum values. With 100% schema coverage, baseline is 3; the description adds moderate value.

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

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

The description clearly identifies the tool as an onboarding entry point for a connected agent to discover what questions to ask. It lists many example queries ('what can I ask', 'give me ideas') and describes the return format of category-bucketed example questions with tool+argument shapes. It distinguishes itself from siblings by explicitly stating 'Use this FIRST when you do not yet know what Pipeworx can do for you'.

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 guidance: first when unsure of Pipeworx capabilities or to learn meta-tools. It explains how to use it (no arguments for full spread, topic parameter for focus). It could be more explicit about when not to use, but the context is sufficient.

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

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

The annotations already mark the operation as read-only, idempotent, and non-destructive, and the description adds useful behavioral detail: results are grouped by sense, include part of speech and definitions, and misspelled or unknown words return close spelling suggestions. This goes beyond the annotations by describing the actual response behavior.

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

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

Three sentences carry all essential information with no filler: the action, the output shape, the fallback behavior, and a short call example. The most important information is front-loaded.

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

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

For a simple two-parameter lookup tool, the description fully covers invocation, return contents, and the not-found case. With no output schema, the description still gives the agent enough to interpret the result correctly.

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

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

Schema description coverage is 100%, and the description does not add meaning beyond the schema's parameter documentation. The word example is already present in the schema examples, and the _apiKey behavior is already fully described in its own schema description.

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

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

The description opens with a specific verb and resource: 'Look up a word in the Merriam-Webster thesaurus.' It then specifies concrete outputs (synonyms, antonyms, part of speech, definitions) and a fallback behavior, which makes the tool's purpose unmistakable and distinct from sibling tools like define.

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 makes the context clear: use this tool for thesaurus lookups when you need synonyms, antonyms, and word senses. However, it does not explicitly state when not to use it or name alternatives such as define for dictionary definitions, so the guidance is implied rather than fully explicit.

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

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

Annotations already indicate idempotency and non-destructive nature, but the description adds critical behavioral details: ownership enforcement and the deactivation vs deletion distinction. This provides clarity beyond the annotations.

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

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

The description is two sentences, front-loaded with the main action, and every word adds value. It is concise, clear, 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 one-parameter tool with no output schema, the description provides sufficient context about behavior (ownership, deactivation) and references sibling tool recent_alerts. It could mention the return behavior or error cases, but given the simplicity, it is mostly 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?

The schema covers the single parameter 'id' with a full description. The description adds no new information about the parameter beyond referencing it by 'id'. With 100% schema coverage, a baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Cancel a subscription by id') and the resource (subscription). It distinguishes itself from sibling tools like subscribe and list_subscriptions by specifying the effect (deactivation, not deletion).

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

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

The description implies when to use (to cancel a subscription) and provides important context: ownership enforcement and that historical events remain. However, it does not explicitly mention when not to use this tool, though the purpose is clear enough given the sibling context.

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

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

Annotations already declare read-only, idempotent, and non-destructive, so the description adds substantial beyond-annotation value: the dual-path routing, the full list of verdicts, and specifically the crucial semantic of could_not_verify (the check did not happen, not evidence either way) and unsupported (no source found). This prevents dangerous misinterpretation of failure modes.

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

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

Though longer than typical descriptions, every sentence earns its place: query examples, routing logic, verdict enumeration, error semantics, and efficiency rationale. It is front-loaded with the core purpose and the information is organized logically, so the length is justified for a tool with complex failure modes.

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 is complete for a fact-checking tool: it explains intent, routing, output verdicts with citations, error handling, and parameter examples. Since there is no output schema, the explicit verdict list and stated return of 'reasoning' fill that gap. It even anticipates edge cases like 'could_not_verify' and 'unsupported'.

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 provides complete descriptions for both parameters (100% coverage), so the baseline is 3. The description goes further by giving practical guidance for tolerance_pct, such as setting 1–2% for hallucination detection, which enriches the parameter meaning beyond the schema's factual definition.

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

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

The description opens with concrete user phrasings and explicitly defines the tool as natural-language claim verification against authoritative sources. It distinguishes itself from general Q&A tools by focusing on fact-checking and by noting it replaces 4–6 sequential calls, making the scope exact and unambiguous.

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

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

It states 'Use whenever the agent needs to check whether something a user said is factually correct' and then differentiates between company-financial claims (SEC/XBRL fast path) and all other claims (grounded pipeline). The 'replaces 4–6 sequential calls' note clarifies when this consolidated tool is preferable to chaining separate lookup/comparison steps.

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