Ilostat

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

Beyond annotations (readOnlyHint, idempotentHint, openWorldHint), the description adds critical detail: costs for Anthropic calls are passed to user, return structure includes per-model and combined view, and that default model is free. 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 three sentences, front-loaded with the core action and key details. Every sentence adds essential information without redundancy or unnecessary elaboration.

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

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

Despite no output schema, the description fully explains return values (per-model details and combined view). It covers purpose, parameters, usage, and return structure, making it complete for an agent to invoke 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 covers all 4 parameters with descriptions. The description adds value by clarifying default model, that _apiKey is only needed for Anthropic, and that context disambiguates entities. Adds meaning beyond schema.

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

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

The description clearly states the tool probes LLMs for knowledge about an entity and scores visibility (0-100). It specifies verb 'probe', resource 'LLMs', and distinguishes from sibling tools by its unique function of AI visibility auditing.

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 use cases (AI-marketing audits, pre-launch brand checks, competitive monitoring). It mentions default model is free and that Anthropic requires own key, but does not explicitly exclude alternatives or state when not to use.

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

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

The annotations already communicate read-only, idempotent, and non-destructive behavior. The description adds useful behavioral context beyond the annotations: the tool routes internally across 5,596 tools, fills arguments automatically, and returns structured answers with stable citation URIs. It could mention response failure modes or cases with no matching data, but together the annotations and description give an agent a strong model of how the tool behaves.

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 more verbose than the typical tool entry, but almost every sentence earns its place: it gives the preference rule, the supported data domains, the routing mechanism, citation behavior, invocation cues, concrete examples, and a clear when-not-to-use alternative. It could be tightened by trimming the example list slightly, but it remains well organized 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?

There is no output schema, but the description still explains the return value: a structured answer with stable citation URIs. It also covers when to use it, why it should be preferred over web search, how to invoke it (natural-language question), what type of requests it handles, and the main alternative when it should not be used. Given the simple single-required-parameter shape, this is complete enough for an agent to confidently select and invoke the tool.

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

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

Schema coverage is 100% because every parameter is an alias for the required natural-language question, so the schema already documents the meaning well. The description provides illustrative example inputs and says the user can ask 'what is', 'find', 'get the latest', etc., but it does not add much parameter-level information beyond that. Baseline 3 is appropriate here.

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 exactly what the tool does: it routes a factual question to the right backing tool among thousands of verified sources and returns a structured answer with pipeworx:// citation URIs. It also names the general scope and gives concrete examples, making it easy for an agent to recognize relevant requests. It clearly distinguishes itself from web search and from deep_research for non-factual synthesis requests.

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

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

The description explicitly says 'PREFER OVER WEB SEARCH' and 'START HERE for most questions', and gives specific trigger phrases and example queries. It also includes an explicit when-not-to-use condition: synthesis, speculative analysis, or opinion requests are better served by deep_research. This is unusually good 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 cover read-only, open-world, idempotent, and non-destructive behavior. The description adds useful context beyond those annotations: candidate routing improvements are live only when under test, the last candidate was retired, and this tool is intentionally not a wrapper or fallback path but the experimental edge of a full router.

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 core identity and is dense without being padded. It carries some fast-changing status detail, such as the retirement date and live-candidate state, which is relevant but makes it slightly longer than the absolute minimum.

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 100% schema coverage, strong annotations, and the explicit pointer that this shares ask_pipeworx's arguments and response shape, the agent has enough context to call and interpret the tool. It does not independently describe the response format, but the pointer to ask_pipeworx compensates in this sibling-rich context.

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

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

Schema description coverage is 100%, and each parameter is documented as an alias for question. The description confirms that the arguments match ask_pipeworx, but does not add any per-parameter meaning beyond what the schema already provides, 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 clearly identifies this as a beta variant of ask_pipeworx, an identical universal router spanning the same 5,596 tools, same arguments, and same response shape. It also distinguishes it from the stable sibling by framing it as the experimental routing edge.

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

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

It gives explicit direction: use it exactly like ask_pipeworx when you want the newest routing, and results are compared against the stable router. It also removes ambiguity by stating that no candidate is active right now, so behavior currently matches ask_pipeworx exactly, and that this is a complete working router with no fallback.

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

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

Beyond the annotations (readOnly/open/idempotent), the description discloses key behaviors: it refuses instead of hallucinating, returns verbatim evidence, has a controlled refusal_reason enum, and ignores anything outside the tool result. It also exposes the extra LLM call cost, which is exactly the kind of behavioral context an agent needs.

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 efficiently organized: definition, mechanism, success/refusal return shapes, use contexts, and cost trade-off. Every sentence earns its place, with the purpose front-loaded and actionable guidance right after technical details.

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

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

With no output schema present, the description fully describes both success and refusal return shapes including top-level fields and all refusal_reason values. It also covers routing context, grounding constraints, common use cases, and cost comparison to the sibling, giving an agent everything needed to select and call the tool safely.

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 documents the single question parameter and all six aliases, with 100% schema coverage. The description references 'question' only through the general use case and does not add semantic detail about parameter formatting, so a baseline score of 3 is appropriate; schema carries the weight.

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-led definition: 'Hallucination-resistant answer mode for high-stakes reads,' then explains the exact mechanism (query routing, execution, extraction only from tool results). It clearly distinguishes from sibling ask_pipeworx by emphasizing the grounded extraction and refusal behavior, so an agent can tell them apart.

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

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

Provides explicit when-to-use guidance: 'Use whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts,' with concrete examples. It also names the alternative and the tradeoff: 'prefer ask_pipeworx for casual lookups' because this costs one extra LLM call.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. Description goes far beyond by detailing resolution behavior including low-confidence short-circuiting, closed market handling, wide-spread market flags, and resolution-rule risks. 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 verbose but well-structured. It front-loads the core purpose and then systematically covers safety, response shapes, and edge cases. Every sentence adds value; however, some internal repetition (e.g., low-confidence match details) could be streamlined.

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

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

Despite having no output schema, the description thoroughly explains response shapes (market, analysis, evidence), resolver contract, parent_event extractor, and news fields. It covers all major behavioral aspects an agent needs 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 coverage is 100% and description adds significant meaning beyond the schema: explains market can be slug, URL, or question text; depth enum values are clarified; include_raw parameter is explained with size implications and use cases. Adds clear 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 starts by clearly stating the tool researches a Polymarket bet by pulling Pipeworx data. It gives specific examples of input types and use cases. The tool is distinct from sibling tools like polymarket_arbitrage or polymarket_edges which focus on different aspects.

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 the tool ('should I bet on X', etc.) and provides examples of different query types and classifier categories. Does not explicitly mention when not to use it, but 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 declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds key behavior: parallel call, data sources (SEC EDGAR/XBRL for companies, FAERS/FDA for drugs), sorting by primary metric, and citation URIs. No contradictions with annotations.

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

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

The description is relatively long but well-structured: it starts with user-intent phrases, then core function, data details, and efficiency claim. It front-loads the key purpose. Could be slightly more concise but remains effective.

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

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

With no output schema, the description explains return values: paired data and citation URIs. It also covers data sources and sorting. It is sufficiently complete for an agent to understand what the tool returns and how it behaves.

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 parameters are well-defined. The description adds context beyond schema by explaining what data is pulled for each type and the sorting behavior. Since schema already provides good descriptions, the added value is moderate but meaningful.

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 does side-by-side comparison of 2–5 companies or drugs. It starts with natural language examples like 'compare X and Y' and emphasizes it replaces multiple sequential lookups, distinguishing it from sibling tools like entity_profile and ask_pipeworx.

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

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

The description explicitly says when to use (comparison queries, 'X vs Y', etc.) and advises preferring over sequential lookups. It covers constraints (2–5 entities, type company/drug) but does not explicitly state when not to use (e.g., for other entity types or more than 5 items), leaving some ambiguity.

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

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

The description adds value beyond annotations by explaining the output (ordered dimensions and valid codes) and how the key positions correspond to dimensions. Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, and the description does not contradict any of these.

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 informative and well-structured, with the purpose stated upfront. It includes necessary details without being overly verbose, but slightly longer than the minimum needed.

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

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

Given the tool's simplicity (1 parameter, no output schema, safety annotations present), the description fully equips the agent: it explains what the tool returns, how to use the result for get_data, and provides an example. No gaps remain.

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

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

The single parameter dataflow_id is fully described in the schema (100% coverage). The description reinforces its meaning by providing context ('ILOSTAT dataflow id from list_dataflows'), an example, and the format, adding value beyond the schema.

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

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

The description clearly states the tool gets the structure (Data Structure Definition) of an ILOSTAT dataset, including ordered dimensions and valid codes. It distinguishes itself from sibling tools by explaining its role in building the SDMX key for get_data.

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

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

The description explicitly says to use this to learn how to build the SDMX key for get_data, explains key positions and wildcards, and instructs to 'Always call this before get_data.' While it doesn't explicitly list when not to use, the context is clear and provides a concrete example.

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 cover the safety profile (readOnlyHint, idempotentHint, not destructive), and the description goes well beyond them: gaps[] are present only when the data couldn't answer (never invented), contradictions[] for 'standard'/'thorough', citations are only emitted when the underlying source can actually serve the pipeworx:// URI, large records are semantically excerpted (not head-truncated), and latency 15–60s ('thorough' up to ~90s) is explicitly disclosed. Nothing about behavior is left to inference.

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 content is dense but front-loaded: the critical account/adjustment gate comes first, then scope, then behavioral details, then usage patterns. Every sentence earns its place. It is a long block of prose, with slight redundancy around the paid plan and depth counts that the schema already states.

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

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

With no output schema present, the description carries the full burden of explaining the return value and does so completely: findings packet of verbatim evidence + confidence + source + fetched_at + a stable pipeworx:// citation, plus gaps[] and contradictions[] arrays. Auth, timing, scope, and output contract are all covered — nothing required to call the tool correctly is missing.

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

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

Schema description coverage is 100% and the schema's depth enum already documents facet counts, hops, and the paid requirement. The description adds minimal parameter nuance beyond the schema (mainly the per-tier latency expectations), so the baseline 3 is appropriate. It does not need to compensate because the schema is already rich.

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

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

The description states a specific verb and resource: grounded multi-source research across Pipeworx's 1465 structured data sources in ONE call, decomposing a question into facets and routing them in parallel to 5,596 tools. It explicitly says 'I am NOT open-web search' and contrasts with ask_pipeworx for single lookups, so an agent can tell it apart from every one of the 34 sibling tools.

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

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

Provides explicit when-to-use guidance ('Best for broad/multi-part questions over structured data...') and names the alternative ('For a single lookup use ask_pipeworx'). It even adds a conditional: 'If you are not signed in, use ask_pipeworx instead — it works on every depth tier.' This fully resolves the routing decision.

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 that it returns tool definitions with full schemas and that each result is ready to call directly, adding 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 front-loaded with purpose, includes many examples, and is reasonably concise. Each sentence adds value, though it could be slightly trimmed.

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

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

No output schema, but description explains return value (tool names, descriptions, schemas) and that results are callable directly. Mentions top-N. Lacks details on ranking but sufficient for understanding.

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

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

Schema coverage is 100%, so baseline is 3. Description mentions natural language query and lists examples, but does not add significant meaning beyond the schema descriptions.

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

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

Description clearly states the tool finds tools by describing data or task, with specific verb 'Find tools' and resource. It distinguishes itself from siblings as a meta-discovery tool, explicitly saying 'Call this FIRST' when needing to see the option set.

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

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

Provides explicit guidance: use when needing to browse, search, look up, or discover tools for specific domains, and call FIRST to see options. Does not include when-not-to-use but context is clear.

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

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

Despite annotations already indicating read-only and non-destructive behavior, the description adds rich detail: fans out across multiple sources, includes fallback mechanisms (GDELT→GNews), notes USPTO sunset, and lists exact return fields. No contradictions with annotations.

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

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

The description is long but front-loaded with example queries and every sentence adds value (data sources, fallbacks, return fields). Slightly verbose due to listing all return elements, but still efficient for the complexity covered.

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 sources, fallbacks, limitations), the description is thorough. It explains what is returned, how it works (parallel call), handles edge cases (patent soft-fail, name unsupported), and covers all key aspects without requiring an output schema.

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

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

Schema description coverage is 100%, with both 'type' and 'value' parameters already well-documented in the schema. The description reinforces the same constraints (e.g., names not supported) but adds no new parameter semantics beyond examples. Baseline of 3 is appropriate.

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

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

The description clearly states it provides a 'full cross-source profile of a US public company,' with specific data elements listed. It distinguishes itself from chaining single-pack lookups and sibling tools like 'resolve_entity' by emphasizing it should be preferred for holistic views.

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 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups' for holistic views and specifies input requirements: ticker or CIK, not names, with pointer to use 'resolve_entity' for names. This provides clear when-to-use and 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 indicate destructiveHint=true, but the description adds context about clearing stale/sensitive data, providing value beyond annotations without contradiction.

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

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

Two sentences, front-loaded with the core action, and no wasted words. Every sentence earns its place.

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

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

For a simple delete tool with one parameter, complete annotations, and no output schema, the description fully covers purpose, usage, and safety 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 the description does not add additional parameter details beyond what the schema already provides.

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

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

The description states 'Delete a previously stored memory by key' with a specific verb and resource, and distinguishes from siblings like 'remember' and 'recall'.

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

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

Explicitly states when to use ('context is stale, task is done, clear sensitive data') and mentions pairing with sibling tools 'remember' and 'recall'.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description doesn't need to restate those. It adds context about fetching pages and extracting content, but does not disclose potential rate limits, error behavior for invalid URLs, or size limits beyond the max_links parameter. The description adds some value but not significant beyond what annotations cover.

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

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

The description is concise (5 sentences) and front-loaded with the main purpose. Every sentence adds value: what it does, how it works, output format, and use cases. No wasted words, though it could be slightly tighter by merging the use cases.

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 only 2 parameters, rich annotations, and no output schema, the description clearly explains the tool's purpose, behavior, and output. It mentions fetching, extracting, and emitting markdown, which is sufficient for an agent to understand what to expect. Slightly more detail on error handling would lift it to a 5.

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 'url' and 'max_links' well-described in the input schema. The description adds minimal extra detail (e.g., 'any URL', 'default 25, max 50') but these are already implied by the schema. Following the guideline, 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 generates a production-ready llms.txt file for any URL, specifying the verb (generate), resource (llms.txt file), and context (for AI crawlers). It distinguishes itself from sibling tools like 'ai_visibility_check' by focusing on creation of a specific file format, not just checking AI presence.

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

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

The description provides explicit use cases: getting a client’s site indexed, drafting your own llms.txt, or auditing a competitor. However, it does not explicitly state when not to use the tool or suggest alternatives among siblings, missing a small opportunity for completeness.

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, openWorld, non-destructive. Description adds key behavioral traits: syntax for key, wildcard mechanism, large data caution, and return format (decoded series with labels and per-period values). No contradiction.

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

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

Slightly long but well-structured with front-loaded purpose. Each sentence adds value, including example and caution. No redundancy.

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

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

Given 6 parameters, 100% schema coverage, and no output schema, the description is complete: explains key format, provides examples, notes default max_series (200), and describes return format. No gaps.

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

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

Schema coverage is 100%, but description adds critical meaning: explains dot-separated SDMX dimension filter order, gives explicit examples, and clarifies that omitting key fetches all. This goes beyond the schema descriptions.

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

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

The description specifies a clear action (pull observations) and resource (ILOSTAT dataset). It distinguishes from sibling tools like dataflow_structure and list_dataflows by focusing on data retrieval with a specific key syntax.

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

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

Provides clear context on when to use (after obtaining dataflow_id) and when to omit key (all series, with caution). Lacks explicit mention of alternatives but the sibling list shows no direct duplicate, so the guidance is adequate.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the description doesn't need to repeat those. It adds useful behavioral context: the domain (ILO datasets), result structure (id and English name), and query behavior (case-insensitive substring). 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?

Extremely concise: two sentences plus an example. Every sentence earns its place—purpose, guidance, and context are front-loaded. No unnecessary fluff.

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

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

For a list/search tool with high-quality annotations and full schema coverage, the description is complete. It explains the domain, how to filter, and how results connect to sibling tools. No gaps given the complexity.

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

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

Schema coverage is 100%, so the schema explains the parameters. The description adds value by giving examples and clarifying that query is a case-insensitive substring filter, and advising to use it for filtering. This enhances understanding beyond the schema.

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

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

Description clearly states it browses/keyword-searches ILOSTAT datasets, specifying the resource (ILO datasets) and the verb (list/search). It distinguishes from sibling tools like get_data and dataflow_structure by noting that the result's id is used for those tools.

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

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

Explicitly advises to always pass query unless the full list is needed, and provides concrete examples. While it doesn't state when NOT to use the tool versus alternatives, the context about filtering is clear and actionable.

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

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

Annotations already declare readOnlyHint and other traits. Description adds value by listing return fields and clarifying the default behavior (active only) and the effect of the include_inactive parameter.

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

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

Two sentences, no unnecessary words, front-loaded with purpose and return fields.

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

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

Given no output schema, description lists return fields. Covers purpose, usage, and parameter behavior adequately for a simple list tool.

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

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

Schema coverage is 100%, so description does not need to add parameter details. The description implies default behavior (active) but no additional semantics 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 'List the caller's active subscriptions', specifies return fields (id, type, etc.), and distinguishes from siblings like 'subscribe' and 'unsubscribe'.

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

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

Explicitly advises to use this tool before adding more subscriptions or to find an id to cancel, providing clear when-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?

With all annotation hints set to false, the description takes on the full burden of behavioral disclosure. It reveals that filing returns a `claim_token` when no account is present, explains how to later pass it back to read resolution status, discloses rate limits ('Rate-limited to 5 per identifier per day'), and notes it is free and does not count against tool-call quota.

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

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

The description is concise for the amount of information it conveys, with a clear front-loaded purpose followed by use cases, scope restrictions, and operational details. Every sentence serves a distinct function—no filler or repetition—and the structure logically progresses from what to when to how.

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 there is no output schema and annotations are sparse, the description fully compensates by explaining the claim_token flow, what counts as valid feedback, the scope boundary (only Pipeworx tools), and the team's daily digest process. This gives an agent everything needed to correctly use the tool and interpret its response.

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

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

The input schema already provides 100% coverage with descriptions for type, context, message, and claim_token. The description adds valuable extra context for claim_token, specifically how to invoke it as a follow-up read (`pipeworx_feedback({claim_token:"pwfb_…"})`), which goes beyond the schema's static 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 'Tell the Pipeworx team something is broken, missing, or needs to exist,' which clearly states the action (send feedback) and resource (Pipeworx team). It explicitly lists use cases (bug, feature/data_gap, praise) and distinguishes itself from sibling tools by restricting to 'tools served by this Pipeworx connection.'

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: 'Use when a tool returns wrong/stale data (bug), when a tool you wish existed isn't in the catalog (feature/data_gap), or when something worked surprisingly well (praise).' It also gives an exclusion rule for other MCP servers and instructs users to 'file it with that server instead,' plus a fallback for uncertainty.

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, non-destructive behavior. The description adds value by disclosing the data source (CF analytics-engine), no PII, and caching duration (5min-1h). 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 concise, front-loaded sentences with zero waste. Each sentence adds distinct value: output, use cases, and behavioral context.

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 one parameter, strong annotations, and no output schema, the description fully covers tool behavior, use cases, and data derivation, leaving no gaps.

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

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

The only parameter (window) is fully covered by schema with enum and description. The description adds extra meaning about shorter vs longer windows, aiding selection.

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

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

The description clearly states the tool returns top tools, packs, and call volume over a recent window. It uses specific verbs and resources, and the purpose is distinct from sibling tools.

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

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

Three explicit use cases are provided, covering discovery, confirmation, and alignment. It gives clear context on when to use the tool.

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

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

Discloses internal logic (monotonicity violations, partition checks), fill check with CLOB depth, semantic anchor (Jaccard similarity), partition filter (placeholder fraction), and output structure. Annotations already indicate read-only/idempotent, and description adds substantial behavioral context beyond 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 lengthy but well-structured with clear sections for each mode and internal checks. Every sentence adds value, though could be slightly more concise without losing content.

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

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

Comprehensively covers purpose, usage, behavior, parameters, output (including response fields), and safety (fill check). No output schema, but the description details the response structure. Mentions related tool for custom sizing.

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

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

Schema coverage is 100%, but the description adds significant meaning: example inputs, behavior in each mode, and response details. It explains how event and topic parameters trigger different algorithms and output formats.

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

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

The description clearly states the tool's purpose: finding arbitrage opportunities via monotonicity violations and partition-sum checks. It distinguishes between two modes (event and topic) with specific examples, and differentiates from siblings like polymarket_fill_risk.

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

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

Provides explicit guidance on when to use each parameter: event for a specific market, topic for cross-event scanning. Also explains when not to trade via fill check and mentions related tool for custom sizing.

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

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

Annotations are consistent and description adds extensive behavioral detail: caching strategy, segmentation logic, edge calculations, slippage assumptions, diagnostics for empty segments, and Fed data limitations. No contradiction.

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

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

The description is dense and comprehensive but overly verbose; every sentence adds value but could be more streamlined. It front-loads purpose but then includes very detailed technical explanations that might overwhelm.

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, no output schema, and complex response structure, the description covers all necessary aspects: model families, filters, diagnostics, caching, and limitations. It leaves minimal ambiguity.

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?

Every parameter description adds substantial context beyond schema, including expected values, rationale (e.g., why min_kelly exists), and practical examples (e.g., slippage_pp explains Polymarket fees). Schema coverage is 100% but description enriches meaning significantly.

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. It distinctly separates from sibling tools like polymarket_arbitrage by focusing on Pipeworx signal and segment taxonomy.

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 it is built for 'what should I bet on today' discovery and explains when to use tradeable-edge knobs. Lack of direct 'when not to use' is minor; overall usage 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 (readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false) already indicate a safe read-only operation. The description adds rich behavioral context: how decay is computed on absolute edge_pp_net, the meaning of negative values, the snapshot mechanism (cache-miss only), and the limitation that decay numbers come from daily closes, not intraday. No contradictions with annotations.

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

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

The description is detailed but well-structured: a one-sentence purpose statement, followed by the response format with bullet-like clarity, and ending with limitations. While it could be slightly shortened, every sentence adds necessary value. The structure is front-loaded and logical.

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

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

Despite having no output schema, the description thoroughly documents the response fields (tracked with time-series and computed trends, expired with lifespan, snapshot_dates). It covers limitations, parameter defaults, and the snapshot mechanism. For a tool with two optional parameters and simple inputs, the description is completely adequate for an AI agent to understand and use the tool correctly.

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

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

The input schema provides 100% description coverage for its two parameters (days: lookback default 14 clamp 2-30; window: which window family). The description adds nuance: days default 14 max 30 (consistent with clamp), and explains window as 'snapshot family' with examples. This adds marginal value beyond the schema, justifying a score above baseline 3.

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

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

The description opens with 'Edge persistence and decay telemetry built from daily polymarket_edges snapshots,' which clearly states the tool's purpose as a derived analysis tool. It then answers a specific question ('how long has this edge existed and is it shrinking?'), effectively distinguishing itself from sibling tools like 'polymarket_edges' which likely provides raw snapshots.

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 parameter guidance (days lookback defaults and max, window families) and explains the output components (tracked, expired, snapshot_dates) and their meaning. It implies when to use this tool (for persistence/decay analysis vs. current edges) and notes limitations (60-day TTL, daily closes). It could have been more explicit about when not to use it, but context is clear.

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

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

Annotations indicate read-only, idempotent, non-destructive behavior; description adds detailed behavioral context: walks order book ladder, returns specific fields (top_of_book, slippage, verdict), and warns about partial fills and unhedged positions. 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?

Single paragraph but well-structured: purpose first, then required params, then modes, then outputs, then usage. Every sentence adds value. Slightly long for a 4-param tool, but complexity justifies length.

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

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

No output schema, but description covers return fields for both modes, including per-leg details and risk metrics. Explains types of returns (verdict, capture_ratio, thin_legs). Sufficient for agent to interpret results.

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

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

Schema coverage is 100%, but description adds significant value: explains REQUIRES one of `market` or `event`, clarifies side defaults per mode, and describes size_usd interpretation (max spend vs target proceeds vs settlement notional). This goes 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?

Description clearly states it performs a realizable-vs-theoretical edge check using live CLOB order-book depth. It distinguishes between single-market and basket modes, and explicitly connects to sibling tools (polymarket_arbitrage, polymarket_edges).

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

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

Explicitly states when to use: before acting on polymarket_arbitrage signals or edge trades above ~$500. Explains risks (theoretical overround not capturable, partial fills cause directional risk), providing clear guidance on avoiding the tool for small trades or when not needed.

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

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

Annotations indicate read-only, idempotent, non-destructive. Description adds critical behavioral context: safety fields (compatibility_warning, temporal_alignment), skipped cross types, and the fact that real spreads are rare. 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?

Thorough but slightly verbose; every sentence provides useful information, but could be tightened. Front-loaded with main purpose and 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?

Despite no output schema, description covers all essential aspects: purpose, parameters, response format, safety fields, limitations, and temporal alignment. Fully contextualizes 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%, but description adds meaning beyond basic definitions: explains the interplay between topic and explicit tickers, lists all pre-mapped topics, and clarifies override behavior. 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?

The description explicitly states it computes cross-venue spreads between Kalshi and Polymarket, distinguishes from siblings like polymarket_arbitrage by focusing on the same resolving question across venues, and clearly describes two modes (topic shortcuts and explicit tickers).

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

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

Provides explicit guidance on when to use (comparing same question across venues), the two modes, and important caveats (pre-mapped topics often not tradeable, compatibility warnings). Helps agent decide versus alternatives.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. Description adds scoping and pairing info but doesn't contradict.

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 front-loaded action, 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?

Complete for a single-parameter tool with good annotations; describes purpose, usage, and scope.

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 adds clear meaning: omit key to list all.

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 retrieves a saved value or lists all keys, distinguishing it from siblings remember and forget.

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

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

Explicitly says when to use (look up stored context) and pairs with remember/forget, but doesn't explicitly state when not to use.

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

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

Annotations declare readOnly, openWorld, idempotent, non-destructive. The description adds important behavioral details: mark_read affects next call, polling is safe, feed is persisted. 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?

Concise with 4 sentences. Front-loads the purpose and key features. Could slightly tighten the external endpoint mention but overall efficient.

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

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

No output schema, but description explains return fields (source, citation_uri, raw payload). Covers all key optional parameters and polling behavior. Complete for the tool's complexity.

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

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

Schema coverage is 100%. The description adds meaning beyond the schema: type and since are explained, mark_read's side effect is described, and limit is implicitly covered. Adds value over raw 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 'Pull fired events from your subscription feed' and lists specific fields returned (source, citation_uri, raw payload). It distinguishes itself from sibling tools like subscribe/unsubscribe by focusing on reading alerts.

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

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

Provides usage context: filtering by type/since, setting mark_read, and mentions polling. It also notes an external endpoint for scripts/dashboards. However, it does not explicitly exclude other tools when a different behavior is needed.

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

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

Beyond annotations (read-only, idempotent), the description discloses that it fans out to SEC EDGAR, GDELT with GNews fallback, and USPTO (soft-fails). It also explains the return structure (changes grouped by source, total_changes, citation URIs). This adds valuable 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 a single dense paragraph but contains no fluff. It efficiently conveys the purpose, query pattern, sources, parameter details, and return structure in a compact form. Could be slightly improved with bullet points, but overall 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 the complexity of aggregating multiple sources, the description covers the purpose, parameters, data sources, fallback logic, return structure, and an alternative tool. Without an output schema, it provides a high-level summary of the return format, which is adequate for agent understanding.

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

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

The input schema already has 100% coverage with descriptions for all three parameters. The description reinforces this with additional examples (e.g., "7d", "30d" for `since`) and clarifies that `value` can be a ticker or CIK. This adds meaningful usage hints beyond the schema.

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

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

The description clearly states the tool retrieves a change feed for a company over a specified window, with example queries like "What's new with X" or "latest on Y." It distinguishes itself from sibling tool entity_profile by advising to use that for static profiles instead.

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

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

The description explains when to use this tool (for recent changes/delta) and when to use entity_profile (for static profile). It provides guidance on the `since` parameter format (ISO date or relative shorthand) and mentions the tool fans out to multiple sources in one parallel call.

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

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

Discloses key behaviors: key-value pair, scoped by identifier, retention policies (authenticated persistent, anonymous 24h). No contradictions with annotations (idempotentHint=true, destructiveHint=false).

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?

Concise paragraph with front-loaded main action. Every sentence adds necessary information; no redundancy.

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

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

For a simple storage tool with no output schema, the description fully covers purpose, usage, behavior, and relations to other tools (recall, forget).

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 value with examples and context (e.g., key naming convention, value purpose). Slight boost for helpful examples but no additional constraints.

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

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

The description clearly states the tool's purpose: 'Save data the agent will need to reuse later.' It provides concrete examples (e.g., ticker, address), and distinguishes it from siblings like recall and forget.

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

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

Explicitly tells when to use ('when you discover something worth carrying forward'), and how it pairs with recall and forget. Also notes scope and persistence differences.

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

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

Even with annotations (readOnly, idempotent), the description adds substantial behavioral context: internal cascade through multiple lookup endpoints, graceful degradation when GLEIF/OpenFIGI are unavailable, explicit labeling of unresolved identifiers, and source attribution for each identifier. This goes far beyond the annotations and sets clear expectations.

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

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

The description is longer than ideal but well-structured: starts with examples and a clear directive, then breaks down supported types with details. Every sentence contributes meaningful information—there is no fluff. While not as tight as a two-sentence summary, the length is 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 absence of an output schema, the description compensates by explaining what identifiers are returned (CIK, ticker, LEI, FIGI, RxCUI, etc.), how they are labeled, and what happens when resolution fails (explicit 'unresolved' list). It covers both entity types and edge cases (e.g., ISIN-to-LEI mapping, non-US issuers), making it complete for a tool of this complexity.

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

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

Schema coverage is 100%, but the description enriches parameter understanding considerably. For 'value', it details accepted formats (ticker, CIK, ISIN, name) and gives examples. For 'type', it explains the two supported types and their resolution sources. This goes beyond the schema's terse descriptions, making inputs and their interpretation clear.

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

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

Description explicitly states the tool resolves user-spoken names to canonical/official identifiers, with a clear verb ('resolve') and resource ('entity'). Examples like 'ticker for...' and 'CIK for...' make it unambiguous. It also distinguishes itself from siblings by positioning it as the first step for other tools that require IDs.

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?

Direct usage instruction is provided: 'Use FIRST whenever you have a name but need an ID.' It further clarifies that it replaces 2-3 manual lookups and handles multiple entity types. The description implies this is the go-to tool for identifier resolution, while not being suitable for other tasks like comparing entities—differentiating it from 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 indicate read-only, idempotent, non-destructive behavior. The description adds value by detailing the internal probe mechanism (calling ai_visibility_check per entity), ranking process, and output fields (score, confidence, signal density), enriching the behavioral model.

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 extremely concise (two sentences) and front-loaded: the first sentence states the core purpose, and the second adds use case and output details. Every sentence is substantive with no redundancy.

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

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

The description covers the tool's purpose, mechanism, and output structure, which is sufficient given the rich annotations and 100% schema coverage. However, it lacks explicit mention of constraints like the entity array length (2-8) and error scenarios, which are minor gaps.

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

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

While schema coverage is 100%, the description adds semantic value beyond the schema: it clarifies that the first entity is treated as the 'subject' for narrative, that 'models' can be omitted for default worker-ai, and that 'context' disambiguates common names. This helps the agent understand parameter roles.

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

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

The description clearly states the tool compares AI visibility across multiple entities side-by-side, using a specific verb ('Compare') and resource ('AI visibility across multiple entities'). It distinguishes itself from sibling 'ai_visibility_check' by emphasizing multi-entity comparison and ranking.

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

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

The description provides explicit use-case context ('competitive AI-marketing audits') and implies when to use it. However, it does not explicitly state when not to use it or name alternatives beyond the implicit 'ai_visibility_check' for single entities.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, so the tool is safe and idempotent. The description adds valuable behavioral context: partial failures degrade gracefully, bundlephobia first measurement can take 5-30s, sources_failed list if timed out, and specific return fields are detailed.

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 is front-loaded with the core purpose. It is dense with information and efficiently covers ecosystem scope, usage, edge cases, and return details. Could be slightly more structured with bullet points, but it remains effective and 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 the tool's complexity (two external services, partial failure handling, ecosystem limitation, specific return fields), the description is thorough. It explains the composite nature, the services used, the return blocks (summary, advisories, links, alternatives), and the graceful degradation. No output schema exists, so the description adequately covers return values.

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 both 'package' and 'version' already well described in the schema. The description adds minor value by mentioning scoped packages as an example for 'package' and reiterating the default behavior for 'version', but does not significantly enhance semantics beyond the schema.

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

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

The description clearly states the tool's purpose: a composite check for npm packages across deps.dev and bundlephobia to answer questions about safety, popularity, and size. It distinguishes from siblings by explicitly noting the NPM ecosystem limitation and directing other ecosystems to deps.dev:version.

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

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

Explicit usage guidance is provided: 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me".' It also clarifies what is not covered (PyPI, Maven, etc.) and where to go for those, offering 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?

Annotations already indicate read-only, open-world, idempotent, and non-destructive behavior. The description adds significant behavioral details: use of BGE-base-en embeddings, cosine similarity, 500-char overlapping windows, 200K char cap, truncation flagging, and return format (passages with offsets and scores). 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 well-structured: starts with core purpose, then usage guidance, then technical details. Every sentence adds value with no redundancy. Front-loaded with the key action.

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

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

For a tool with 3 parameters, no enums, no output schema, the description covers: what it does, when to use it, technical embedding details, input limits, and return format (passages with offsets and scores). No gaps for typical agent decision-making.

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

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

Schema coverage is 100%, so baseline is 3. The description adds contextual meaning: 'text' is described as the document to search, 'query' as a natural-language query with examples (e.g., 'supply-chain risk'). This enriches the schema descriptions beyond the basic field names.

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

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

The description clearly states the verb ('semantic search'), the resource ('a fetched record'), and the scope ('INSIDE'). It distinguishes from sibling tools like 'ask_pipeworx_grounded' by noting how they pair. The specific verb-resource combination is unambiguous.

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

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

Explicitly states when to use ('record is too big to cram into the prompt') and how it pairs with 'ask_pipeworx_grounded'. Provides clear context for selecting this tool over alternatives.

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

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

The description fully discloses behavioral traits beyond annotations: it specifies a write operation (create), idempotency hint is consistent, and it details account requirements, type-specific filters, delivery options with rate limits and verification needs. 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 front-loaded with the main action and returns value. It is information-dense but could be more structured (e.g., bullet points) for readability. Every sentence adds value, but length slightly reduces conciseness.

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

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

Given the tool complexity (3 parameters, nested objects, no output schema), the description covers all necessary aspects: action, return value, prerequisites, type options, and delivery details. It is complete for an agent to invoke 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?

Despite 100% schema coverage, the description adds significant value by explaining each type's parameters with concrete examples (e.g., sec_8k items codes, polymarket_edge topics) and delivery options with constraints. This greatly enriches 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 creates a proactive monitoring subscription and returns a new subscription ID. It differentiates from siblings like 'unsubscribe' and 'list_subscriptions' by focusing on creation and including unique details like supported types and delivery channels.

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 context for when to use, including account requirements (Pipeworx OAuth), supported subscription types with detailed parameters, and delivery channel constraints (phone verification, daily cap). It does not explicitly exclude alternatives but offers sufficient guidance.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint as true and destructiveHint as false, which description does not contradict. Description adds behavioral context: it returns example questions with exact tool+argument shapes drawn from a live catalog, and outlines the two calling modes (with/without topic). This provides useful detail 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 moderately verbose but well-structured, starting with key purpose and usage, then listing categories, then clarifying calling conventions. Every sentence adds value, though some could be shortened without loss of 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 the tool's discovery purpose and lack of output schema, the description fully explains what to expect (category-bucketed example questions with tool+argument shapes) and how to use it effectively. It addresses both default and focused usage, and mentions the live catalog source, making it complete for agent decision-making.

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

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

Schema coverage is 100% with a description for 'topic', but the tool description adds meaningful context: explains that omitting topic yields full spread, and lists example focus areas (finance, pharma, etc.). This significantly aids understanding beyond the schema's basic 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 clearly states it's the onboarding entry point for agents that just connected, returning category-bucketed example questions with exact tool+argument shapes. It distinguishes from siblings by advising to use this FIRST and mentions learning how to call meta-tools like ask_pipeworx and 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?

Explicit guidance to use this tool first when unsure of Pipeworx's capabilities or to learn meta-tool calling patterns. Specifies calling with no arguments for full spread or passing a topic to focus. While it doesn't explicitly exclude alternatives, the context clearly implies when to use it.

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

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

Discloses that the row is deactivated (not deleted) and historical events persist, adding value beyond annotations. Annotations already indicate non-destructive and idempotent, so no contradiction.

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

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

Two sentences that are front-loaded and efficient. Every word adds value, no fluff.

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

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

For a simple tool with one parameter and no output schema, the description fully covers purpose, ownership constraint, and side-effect behavior.

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

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

Only one parameter with schema description covering it fully. Description adds no extra meaning beyond the schema, so baseline 3 is appropriate.

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

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

Describes the action ('Cancel a subscription by id') with a specific verb and resource. Clearly distinguishes from sibling tools like 'subscribe' by being its inverse.

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?

States ownership enforcement ('you can only cancel your own subscriptions'), which guides when to use. Provides context about historical events staying available, but does not explicitly mention when not to use 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, and non-destructive. The description adds rich behavioral context beyond this: explains the structured vs. grounded routing, discloses the meaning of 'could_not_verify' (not evidence either way), and clarifies the 'unsupported' verdict. This is exactly the kind of supplementary context that makes the tool safe to invoke.

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

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

The description is longer than average but each sentence carries critical operational detail, especially the 'IMPORTANT for callers' section distinguishing error outcomes. The use of dashes and clear sectioning makes it scannable, though a slight tightening of wording would push it to a 5.

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

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

Despite the lack of an output schema, the description fully explains the verdict values, the two processing paths, the meaning of every outcome, and the error semantics. It covers usage, edge cases, and externally observable behavior comprehensively for a tool of this complexity.

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

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

Schema coverage is 100% and both parameters are already described in the schema. The description adds value by providing concrete examples for the 'claim' parameter and explaining how 'tolerance_pct' overrides the claim-wording-implied tolerance and its use for hallucination detection. This goes beyond mere schema repetition.

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 claim verification tool with specific verbs like 'fact check' and 'verify the claim that'. It distinguishes itself by detailing the two processing pathways (SEC EDGAR fast path and grounded pipeline) and explicitly states it replaces multiple sequential calls, making its unique role clear among siblings.

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

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

Provides explicit guidance: 'Use whenever the agent needs to check whether something a user said is factually correct.' It also differentiates when the fast path vs. grounded pipeline is used. However, it does not explicitly name alternative sibling tools or state 'when not to use', so it stops short of a 5.

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