Hathitrust

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

Annotations already mark it safe (readOnly, idempotent, non-destructive). Description adds cost context (free default model, BYO key for Anthropic) and behavior (returns per-model data with combined view).

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 yet thorough: first sentence defines core action, second covers defaults and options, third describes return format, fourth lists use cases. No wasted text.

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

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

No output schema, but description fully explains return structure (per-model fields + combined view). All 4 parameters documented in schema, use cases covered, no missing information.

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

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

Schema coverage is 100%, so baseline is 3. Description adds value by specifying default model, free usage, and the role of context in disambiguation.

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 probes LLMs for entity visibility and outputs a score (0-100) per model. Differentiates from sibling tools by focusing on AI-marketing audits and brand checks, not general knowledge retrieval.

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

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

Explicitly lists use cases: AI-marketing audits, pre-launch brand checks, competitive monitoring. Explains default model and optional API key for Anthropic, but does not contrast with sibling tools.

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

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

Annotations already signal safe read-only, idempotent, non-destructive behavior. The description adds valuable behavioral context on top: it explains that the tool routes to 5,596 tools across 1,465 sources, fills arguments on the user's behalf, and returns pipeworx:// citation URIs. It also tells the agent that grounded mode is a different behavior (verbatim evidence + confidence). 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 long but every part earns its place: it defines scope, gives trigger phrases, provides examples, and routes to alternatives. The primary guidance is front-loaded, and the examples are compact rather than exhaustive. The length is justified by the tool's extremely broad domain.

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

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

Given no output schema, the description still communicates what the agent can expect: a structured answer with stable citation URIs. It also clarifies what the tool is not for by pointing to grounded and deep_research, and it covers the breadth of data types and trigger phrases. This is complete enough for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100% and the parameter description already says 'question or request in natural language' and lists all aliases. The description adds further semantic context by giving realistic examples and clarifying that the parameter can be a broad real-world query ('current US unemployment rate', 'patents Tesla was granted last month'). This helps an agent formulate the question properly, but mostly reinforces 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 opens with a strong directive ('PREFER OVER WEB SEARCH') and clearly states what the tool does: takes a natural-language factual question, routes it to one of thousands of verified source tools, fills arguments, and returns a structured answer with citation URIs. It distinguishes itself well from sibling tools by mentioning ask_pipeworx_grounded and deep_research as alternatives.

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

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

Explicitly says 'USE whenever the user asks...' and gives concrete trigger phrases and examples. It also names the two key alternatives and the conditions for using them: ask_pipeworx_grounded for hallucination-resistant single answers, deep_research for broad multi-part questions. This gives clear routing guidance beyond any simple description.

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 disclose read-only, open-world, idempotent, and non-destructive behavior. The description adds genuinely useful behavioral information: the candidate state is currently inactive, the router matches ask_pipeworx exactly right now, and responses are compared against the stable router to inform merges. This goes beyond annotation but could go further by explaining what the returned response shape actually contains.

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 of the tool, then gives current runtime state, then usage guidance, then a reassuring clarification. It is compact and each sentence contributes meaning. The minor redundancy is that the description already says it currently matches ask_pipeworx exactly and later says the same thing again.

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

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

Given that there is no output schema, the description does enough by specifying that the response shape is identical to ask_pipeworx and by explaining what is different right now. It is complete enough for an agent to select and call it correctly. It could be stronger by briefly describing the type of response the router returns, but the pointer to ask_pipeworx plus the simple required parameter make the tool usable.

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

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

The schema covers 100% of parameters with descriptions, and all parameters are aliases for the single required 'question' field. The description adds no extra parameter semantics beyond noting the tool has the same arguments as ask_pipeworx, 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 plainly identifies a specific resource—the ask_pipeworx universal router—and clarifies that this beta version is functionally identical to the stable ask_pipeworx but with candidate routing improvements. It also distinguishes itself from the stable sibling by emphasizing its experimental, live-testing nature, so an agent knows exactly what the tool is.

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 the stable ask_pipeworx when the newest routing is desired, and be aware it currently matches stable behavior because no candidate is active. It also corrects a potential misunderstanding by insisting that it is not a fallback but a full working router. It does not, however, give a clear condition for when to prefer the stable ask_pipeworx or the grounded variant instead.

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 behavior beyond the annotations: it returns an explicit refusal object with enumerated refusal_reason values, says it uses ONLY the tool result, and notes it costs one extra LLM call. These are behavioral traits the agent needs to know and cannot infer from annotations or schema.

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

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

The description is information-dense but every sentence earns its place: what the mode does, how it is grounded, the return shape, the refusal contract, the usage guidance, and the cost tradeoff. It is front-loaded with the key concept and ends with a clear routing recommendation.

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 six parameters but only one required, no output schema, and rich behavior, the description fully covers the decision-relevant information: success and error shapes, refusal reasons, cost, and when to use it. Nothing material is missing for an agent to call and interpret the result correctly.

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

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

Schema coverage is 100%, so the description's lack of parameter-level detail is acceptable. The description does add that the question can be any natural language query and that it picks the right tool across 5,596 tools, but the schema already covers aliases. Baseline 3 is appropriate since the schema handles the heavy lifting.

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: it is a grounded, hallucination-resistant answer mode that routes to tools, fetches data, and extracts an answer only from the tool result. It explicitly contrasts with ask_pipeworx, making the distinction clear despite the similar name.

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 it: whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts. It also gives an alternative: prefer ask_pipeworx for casual lookups, and mentions the extra LLM call cost. This is a model of 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?

The annotations already indicate read-only, open-world, and idempotent behavior. The description goes far beyond by detailing fan-out logic, response shapes, resolution contract (market_match_confidence, alternatives, suggestions), parent event extraction, news fallback handling, safety mechanisms (low-confidence short-circuit, closed market detection, wide spread warnings), and resolution-rule risk analysis. This provides agents with comprehensive understanding of the tool's behavior.

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

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

The description is very detailed but quite lengthy, spanning multiple paragraphs. While it is well-structured with clear sections (RESPONSE SHAPES, RESOLVER CONTRACT, etc.), it could be more concise. The front-loading of purpose is good, but the volume of detail may overwhelm some agents.

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

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

Given the complexity of the tool (multiple data sources, fan-out, response handling, error states) and the absence of an output schema, the description is exceptionally complete. It covers input, output, edge cases (low confidence, closed markets, wide spreads), resolution rules, and fallback behavior, leaving 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?

Although schema coverage is 100%, the description adds significant value by explaining the market parameter's three allowed formats, the depth parameter's two options with default, and the include_raw parameter's impact on response size. It contextualizes how each parameter affects the tool's execution and output.

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: researching a Polymarket bet by pulling Pipeworx data. It specifies the types of input (slug, URL, question text) and the output (evidence packet, market-vs-model comparison). This distinguishes it from sibling tools, which are focused on other tasks like arbitrage, edge tracking, or general queries.

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

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

The description provides explicit usage guidance: 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z".' While it does not mention when not to use or alternative tools, the examples are 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?

The description adds 'Keyless' meaning no API key required, and explains the output: existence, count, and URLs. These details go beyond annotations (readOnlyHint, idempotentHint) by clarifying the no-auth aspect and the type of response.

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

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

The description is two sentences, front-loading the purpose ('Convenience check') and clearly stating the action and output. No extraneous information.

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

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

Given no output schema, the description adequately describes the return value (existence, count, URLs). However, it could mention handling of invalid identifiers or edge cases, but overall it is sufficiently complete for a simple check tool.

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

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

Schema coverage is 100% with descriptions for both parameters. The description does not add additional semantics beyond what the schema provides, so a baseline score of 3 is appropriate.

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

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

The description clearly states the tool's function: given an identifier, it checks for readable full-view scanned copies on HathiTrust and reports counts and URLs. It is specific and distinct from typical lookup tools by emphasizing 'convenience check' and 'keyless'.

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 uses 'Convenience check' which implies a lightweight use case, but it does not explicitly state when to use this tool versus siblings like 'get_record' or 'lookup_by_identifier'. No exclusions or alternatives are mentioned.

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

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

Discloses data sources (SEC EDGAR, FAERS), handling of off-calendar fiscal years, sorting behavior by primary metric, and output format with citation URIs. Annotations already cover read-only, idempotent, non-destructive nature, and description adds substantial 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?

Highly concise: 5 sentences packed with essential information. Front-loaded with example queries. No redundant or unnecessary text. Every sentence serves a clear purpose.

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

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

Given 2 parameters, no output schema, and existing annotations, the description fully covers tool behavior, data sources, sorting, and expected output. An agent can confidently decide when and how to invoke this 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?

Adds significant meaning beyond schema: explains that type='company' pulls latest 10-K data, type='drug' pulls FAERS data, and values examples are given. Schema coverage is 100% but description enriches understanding of what each parameter value entails.

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 side-by-side comparison of 2-5 entities, with specific examples of query patterns and data sources. Distinguishes from sequential lookups by emphasizing parallelism.

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 instructs to prefer this tool over sequential single-pack lookups when comparing entities. Provides clear context for when to use each type (company vs drug) with concrete data sources.

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 readOnlyHint and idempotentHint already present, the description adds high-value context: latency expectations (15–60s, ~90s for thorough), the paid gating on thorough, gaps[] for unanswered facets, and a must-not-invent guarantee. It describes the contradiction pass and output shape, but doesn't go into failure/error behavior.

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

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

The description is long but evenly dense — every sentence carries function or outcome. It front-loads the account requirement and the primary alternative exposure and closes with latency expectations. Occasional parenthetical condensation is a mild cost, but it remains scannable.

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 sensitivity, so the description must describe the return shape — and it does: verbatim evidence, confidence, source, fetched_at, pipeworx:// citation, gaps[]. Coverage is strong on prerequisites, latency, source scope, and variant behaviors. The one omission is a named structure of the returned object, but for this tool that is acceptable given the explicit field list.

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 fully describes both params, so the baseline is satisfied. The description adds semantic value by tying depth to facet counts, hop counts, payable tier, and contradiction-scan presence, and by telling the agent broad questions are acceptable for the question field.

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 performs grounded multi-source research over structured data in one call, decomposing the question into facets and routing to tools in parallel. It also differentiates itself from open-web search and from ask_pipeworx for single lookups.

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

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

Gives explicit when-to-use guidance ('Best for broad/multi-part questions over structured data') and when-not-to-use ('For a single lookup use ask_pipeworx instead'). Also explains the account prerequisite and directs unsigned-in users to a tier-independent alternative.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds that results come with full input schemas and curated examples, ready to call directly. No contradictions. Points deducted for not mentioning any implicit side effects or auth needs, but these are minor given the annotations.

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

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

The description is front-loaded with the main purpose, followed by examples and a succinct statement of return value. It is moderately long but every sentence serves a purpose. Minor improvement could be trimming the list of domains, 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?

Given no output schema, the description adequately covers return format (names, descriptions, schemas, examples). It explains the limit parameter's default and max, though not in description itself (in schema). The description is complete enough for an agent to use the tool effectively.

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

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

Schema description coverage is 100%, so the schema itself documents all parameters well. The description does not add significant meaning beyond noting 'top-N most relevant tools' and readiness. Baseline 3 is appropriate as the description does not deepen understanding of parameters 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 'Find tools by describing the data or task' and enumerates specific domains like SEC filings, FDA drugs, etc. This distinguishes it from sibling tools, which are task-specific (e.g., deep_research, 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?

Explicitly advises 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' Also lists use cases (browse, search, look up) and provides concrete examples, leaving no ambiguity about when to invoke.

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. Description adds rich behavioral detail: fans out across multiple sources, parallel call, specific fields returned, patent data sunset, and fallback mechanisms. No contradiction.

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

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

Description is dense but front-loaded with example queries and clear purpose. Every sentence adds value, though slightly verbose. Could be trimmed slightly without losing meaning.

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 complexity (multiple sources, no output schema), description covers: what is returned (cik, filings, fundamentals, patents, news, LEI), specific fields, fallback behavior, and limitations. Lacks details on output format but sufficient for agent understanding.

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

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

Schema covers both parameters fully (100%). Description adds critical nuance: explains value can be ticker or zero-padded CIK, explicitly states names not supported, and hints at future entity types. This adds meaning beyond the schema.

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

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

Description clearly states it provides a full cross-source profile of US public companies, lists specific data sources and returns, and explicitly distinguishes from chaining multiple single-pack lookups with 'ALWAYS PREFER'.

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 (holistic view), when not to use (names not supported, patent data may fail), and directs to resolve_entity for names. Provides example queries and fallback behavior.

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

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

Annotations already provide destructiveHint=true and idempotentHint=true. The description confirms 'Delete' but adds no additional behavioral context beyond that.

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

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

Two sentences, no wasted words. The purpose and usage are front-loaded and clear.

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

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

Simple tool with one parameter and no output schema. The description covers action, when to use, and sibling tools. No gaps for a memory deletion function.

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?

Single parameter 'key' is documented in the schema with 'Memory key to delete'. The description mentions 'by key' but adds no extra meaning beyond schema coverage of 100%.

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 'Delete a previously stored memory by key' – a specific verb and resource. It distinguishes itself by mentioning sibling tools '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?

Provides explicit scenarios: 'Use when context is stale, the task is done, or you want to clear sensitive data.' Lacks explicit when-not-to-use but still strong 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 (readOnlyHint, idempotentHint, destructiveHint) already declare safety. Description adds value by explaining the exact actions (fetches, extracts, emits) and output format, reassuring the agent about behavior 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?

Three efficient sentences: front-loads purpose, explains process, lists use cases. No wasted words, well-structured for quick comprehension.

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 2 parameters and no output schema, the description covers purpose, process, output format, and use cases adequately. Slight gap on error handling or limitations, but overall complete enough for its 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% with clear parameter descriptions. The description does not add new information about parameters beyond what the schema provides, so baseline 3 is appropriate.

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

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

The description clearly states the tool generates a production-ready llms.txt file for any URL, detailing the process (fetches page, extracts info) and output format. It distinguishes itself from siblings like 'scan_competitor_ai_presence' by focusing specifically on llms.txt generation.

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

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

Explicitly lists three use cases: getting a client's site indexed, drafting for own project, auditing competitors. While it doesn't mention alternatives or when-not-to-use, the positive guidance is strong and context-rich.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description does not need to repeat safety. It adds value by detailing the return content (full bibliographic metadata and flagged scanned copies), which goes beyond annotations.

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

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

The description is a single sentence with an example, front-loading the purpose and key details. No unnecessary words.

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

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

Given the annotations covering safety and idempotency, the description provides sufficient detail about the return value (metadata and scanned copies). No output schema exists, so the description adequately explains what the tool returns.

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

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

Schema coverage is 100% for the single parameter, which is already well-described in the schema. The description adds an example and mentions 'Keyless' (likely implying no auth needed), but this is not about parameter semantics. Baseline 3 is appropriate.

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

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

The description clearly states it gets a single HathiTrust catalog record by record number, listing the full structured metadata and scanned copies with access flags. It distinguishes from sibling lookup_by_identifier by specifying how to obtain the record number.

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 an example and mentions that record_number can be obtained from lookup_by_identifier, giving context for when to use it. However, it does not explicitly state when not to use it or list alternative tools for similar tasks.

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 value by listing returned fields and implying active subscriptions, no contradictions.

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

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

Two efficient sentences with no wasted words. Front-loaded with purpose, then guidance.

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?

Sufficient for a list tool with one optional parameter. Lists returned fields despite no 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 covers the single parameter with description. Description does not add additional meaning beyond schema, baseline 3 applies.

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

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

Description clearly states 'List the caller's active subscriptions' with specific verb and resource. Distinguishes from sibling tools 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?

Provides explicit usage context: 'Use this to review what you're monitoring before adding more or to find an id to cancel.' Could be improved by noting 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 indicate readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, confirming safe read-only behavior. The description adds behavioral detail by stating the tool returns 'every scanned copy, each flagged full-view or limited based on its rights code,' which is beyond what annotations provide. 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 two sentences, immediately front-loading the purpose and supported identifiers. Every word adds value (e.g., 'keyless', '18M+ volumes', 'full-view or limited'). No redundancy, ideal length for quick comprehension.

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 (two parameters, no output schema), the description adequately covers what it does and what it returns. It mentions rights-based access flags, which is useful. It doesn't need to explain return format since no output schema, but could briefly mention potential result count. Still, fairly complete for a straightforward lookup tool.

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

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

Schema description coverage is 100% (both id and id_type have descriptions). The description lists the identifier types (OCLC, LCCN, ISSN, etc.), which matches the schema enum, and adds context about the returned data. However, it doesn't significantly add new meaning beyond the schema; it reinforces what is already present.

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

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

The description clearly states the tool's purpose: looking up HathiTrust's digitized-book holdings by a standard identifier. It lists specific identifier types and what is returned (bibliographic records and scanned copies). This tool is distinct from siblings like search_within or get_record, and the description immediately conveys its specific use case.

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 mentions it is 'keyless' and covers 18M+ volumes, which implies ease of use, but it does not explicitly state when to use this tool versus alternatives like search_within or get_record. There is no guidance on when not to use it or which identifier type to prefer for different scenarios.

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

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

Annotations provide no safety hints (all false), so the description carries the burden. It discloses the claim_token flow, rate limit (5/day), free usage, no quota impact, and that the team reads digests daily. This goes well beyond the structured annotations and adds valuable operational 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?

Although long, every sentence earns its place. The description is front-loaded with purpose, then usage, exclusions, claim_token behavior, and limits. No filler or repetition; the length is appropriate for the tool's complexity.

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

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

With no output schema, the description must explain return behavior. It does: filing without an account returns a claim_token, and passing it back later returns status and resolution details. It also covers rate limits and scope, making the tool fully self-contained for an agent.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds extra nuance about the claim_token: filing without an account returns a token, and you can pass it back later to check status. This is not explicitly in the schema, so it deserves a 4.

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

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

The description opens with a specific verb+resource: "Tell the Pipeworx team something is broken, missing, or needs to exist." It enumerates feedback types (bug, feature, data_gap, praise) and clearly distinguishes this tool from sibling tools like ask_pipeworx or deep_research, which are query/research tools.

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

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

Provides explicit when-to-use guidance for each feedback category and an explicit exclusion: if the tool came from a different MCP server, file it there instead. It also offers a heuristic for identifying Pipeworx tools. This is a textbook example of usage guidance.

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

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

Annotations already mark it as read-only, idempotent, and non-destructive. The description adds value by disclosing caching behavior (5min-1h), data source (CF analytics-engine), and privacy (no PII), which are beyond annotations.

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

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

The description is structured with a clear opening, bulleted use cases, and additional context. It is front-loaded and each sentence adds value, though slightly verbose for a simple tool.

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

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

Given no output schema, the description adequately explains return structure (top tools, packs, call volume) and data fields (pack, tool, count). It also covers caching and privacy, making it complete for a read-only trending 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 description coverage is 100%, so baseline is 3. The description adds context on how window length affects output (hot vs steady-state), which enriches the parameter meaning beyond the schema.

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

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

The description clearly states the tool returns top tools, packs, and call volume, with a specific verb 'returns' and resource. It distinguishes itself from sibling tools like 'discover_tools' by focusing on what other AI agents are calling, not general discovery.

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

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

Three explicit use cases are given: discovering hot data sources, confirming a canonical tool, and alignment checking. While it doesn't explicitly state when not to use or alternatives, the guidance is clear and actionable.

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

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

Annotations already declare read-only, idempotent, non-destructive. Description adds critical behavioral details: the fill check against live CLOB depth, semantic anchor with Jaccard similarity, partition filter for placeholder slugs, and response structure. No contradiction with annotations.

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

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

The description is thorough but somewhat lengthy; however, it is well-structured with paragraphs and bolded key terms. Every sentence adds value, but for an AI agent a slightly more condensed version could improve parseability. Still very 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?

Given the tool's complexity (multiple modes, fill check, semantic anchor, partition filter) and lack of output schema, the description covers all relevant aspects: input behavior, response fields, and usage caveats. It is complete and leaves no critical 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 the description adds significant meaning: explains what event slug and topic string represent, provides examples, and clarifies how each parameter affects the scan (single-event vs. cross-event). This fully compensates and exceeds schema detail.

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

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

The description explicitly states the tool finds arbitrage opportunities via monotonicity violations and partition-sum checks. It clearly distinguishes three modes (no args, event, topic) and what each does, leaving no ambiguity about purpose.

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

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

Provides explicit guidance on when to use each mode: no args for trending scan, event for specific market with slug, topic for cross-event scan. Also warns when not to trade (if realizable_edge_pp ≤ 0) and references polymarket_fill_risk for custom sizing, effectively differentiating 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?

The description fully discloses behavioral traits beyond annotations: detailed model logic, caching (1h at KV level), edge calculation net of slippage, warning on 24h move, Fed bet exclusion rationale, and diagnostic output. Annotations (readOnlyHint, idempotentHint) are consistent and enhanced.

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

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

The description is long but well-structured with sections for model families, knobs, and response structure. Every sentence provides value for a complex tool. Could be slightly more concise, but the detail is justified given the tool's sophistication.

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 (three model families, nine parameters, no output schema), the description is exceptionally complete. It explains the output format (by_segment, diagnostics, fed_candidates) and the logic behind each component, enabling the agent to understand what the tool returns and why segments might be empty.

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

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

Schema coverage is 100% and the description adds significant value beyond parameter descriptions: explains edge net of slippage, min_kelly vs min_partition_leg_kelly distinction, tradeable-edge knobs, and defaults. This helps the agent use parameters effectively.

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 and returns opportunities where Pipeworx data disagrees with market price, distinguishing it from sibling tools like polymarket_arbitrage or polymarket_edge_tracker. It is specific about the verb 'scan' and resource 'Polymarket markets', with explicit model families.

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 targets 'what should I bet on today' and explains each model family's purpose. It does not explicitly state when not to use the tool, but the sibling names and context provide alternatives. The knob descriptions guide usage, e.g., min_liquidity for filtering thin books.

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

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

Annotations already indicate readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description adds valuable behavioral context: it explains snapshot creation on cache-miss, gap meaning, decay computation from daily closes (not intraday), and the 60-day TTL. 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 well-structured, starting with the core purpose, then detailing response fields (tracked, expired, snapshot_dates), and ending with limits. However, it is dense and could be slightly more concise; every sentence is valuable but the length is borderline.

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

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

Given no output schema, the description fully explains the return value structure (tracked, expired, snapshot_dates) and their components. It also covers limitations and data origins (snapshot TTL, gaps). This is complete for a telemetry tool of moderate 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% with parameter descriptions. The description adds further meaning: explains 'days' as lookback (default 14, max 30) and 'window' as snapshot family (default '1wk'), plus context on snapshot writing behavior. This enriches understanding beyond the schema.

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

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

The description clearly states the tool provides 'edge persistence and decay telemetry' from daily snapshots, answering a specific question about how long an edge has existed and whether it is shrinking. This distinguishes it from sibling tools like 'polymarket_edges' (likely current edges) and 'polymarket_arbitrage'.

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 explains when to use this tool (to check edge persistence) and implies when not (e.g., for current edges use polymarket_edges). It also provides context on why a fresh edge differs from an older one, and includes a 'LIMITS' section that further guides usage.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description adds behavioral context: walks order book ladder, returns specific fields, and describes risks like thin_legs and forced_directional_risk. No contradiction with annotations.

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

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

The description is lengthy but well-structured with bold headers and separate sections for single-market and basket modes. Every sentence adds necessary detail, though could be slightly more concise. Minor deduction for 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, so description must detail return values. It lists all returned fields for both modes, covers edge cases (thin_legs, forced_directional_risk), and explains the verdict system. Comprehensive for a complex 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 description coverage is 100%, so baseline is 3. The description enriches parameter meanings: explains size_usd interpretation for buys vs sells, basket mode size as settlement notional, and default side logic. 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 clearly states the tool's purpose: 'Realizable-vs-theoretical edge check against live CLOB order-book depth.' It distinguishes between single-market and basket modes, and explains when to use it relative to sibling tools like polymarket_arbitrage and 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?

Explicit guidance: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500.' It explains the rationale (theoretical overround uncapturable on thin books, partial fills lead to unhedged positions) and lists required parameters.

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

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

Annotations already indicate readOnlyHint, openWorldHint, idempotentHint, and non-destructive. The description adds significant behavioral context: it explains what the tool computes (spread), when compatibility warnings fire (e.g., non-equivalent bet shapes, semantic mismatch), temporal alignment constraints, and detailed handling of skipped comparisons. 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 comprehensive but somewhat verbose. It front-loads the purpose but includes lengthy explanations of safety fields and warnings that could be more concise. Some sentences are long and dense, reducing readability. However, every sentence provides useful information for correct tool usage.

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 cross-venue spread analysis and the lack of an output schema, the description covers all essential aspects: modes, parameter semantics, response structure (with top_spreads_pp and leg-by-leg prices), safety fields (compatibility_warning, temporal_alignment, skipped counters), and practical limitations. It is complete for an intelligent agent to decide when and how to 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% with descriptions for each parameter. The tool description adds value by explaining the two modes, providing the list of pre-mapped topic values, and clarifying that explicit tickers override topic mappings. While the schema already describes the parameters, the description provides usage context beyond basic syntax.

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: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' It distinguishes two modes (topic shortcuts vs explicit tickers), providing specific verbs and resources. This differentiates it from sibling tools that focus on single-venue analysis (e.g., polymarket_edges) or arbitrage within one venue.

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 explains when to use the tool (to compare same question across venues) and provides detailed conditions for valid results, including temporal alignment and compatibility warnings. It warns that pre-mapped topics are not always tradeable, guiding appropriate use. It also explains skipped cross types, helping agents avoid misinterpretation.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds context about scoping (anonymous IP, BYO key hash, or account ID) and mentions pairing with remember/forget, which provides additional behavioral insight 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?

Three sentences, front-loaded with core function, no unnecessary words. Every sentence adds value: purpose, usage examples, and pairing with other tools.

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 optional parameter, no output schema, and rich annotations, the description covers all necessary context: what the tool does, when to use it, and how it relates to sibling tools. It is complete for its 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% with a single optional parameter 'key' described. The description adds that omitting the key lists all keys, but this is already evident from the schema's optional nature. No additional parameter semantics are provided beyond what the schema offers.

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

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

The description clearly states the tool's purpose: 'Retrieve a value previously saved via remember, or list all saved keys (omit the key argument).' It specifies the verb and resource, and distinguishes itself from siblings like remember and forget.

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

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

The description provides concrete usage scenarios: 'Use to look up context the agent stored earlier — the user's target ticker, an address, prior research notes — without re-deriving it from scratch.' It also notes scoping and pairing with other tools, but lacks explicit when-not-to-use guidance.

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

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

Adds value beyond annotations by explaining feed behavior, mark_read side effect (marks events read for subsequent calls), and return payload. Annotations already cover safety (readOnly, idempotent, not destructive).

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

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

Four sentences, front-loaded with purpose. Every sentence provides useful information. No redundancy or filler.

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

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

Given no output schema, description explains return fields and alternative access URL. Covers filtering, mark_read, and polling suitability. Could mention pagination limits, but schema already provides limit parameter with default and range.

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 context for mark_read (explains side effect) and since (ISO timestamp, fired_at). No enums or nested objects, but clarity is adequate.

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 'Pull fired events from your subscription feed' and specifies returned fields (source, citation_uri, payload). Distinguishes action from siblings but lacks explicit differentiation.

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

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

Provides filtering options (type, since) and mark_read behavior. Mentions polling and alternative URL access. Does not explicitly compare to sibling tools 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?

Beyond the annotations (readOnlyHint, idempotentHint, etc.), the description discloses key behaviors: fan-out to multiple sources, GDELT-to-GNews fallback, USPTO API sunset soft-fail, and return structure with 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 well-structured, front-loaded with example queries, and each sentence contributes meaningful information. It is somewhat lengthy but justified given the complexity of the multi-source fan-out.

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 adequately explains the return structure (changes[] grouped by source, total_changes, citation URIs). It covers main behaviors and edge cases like fallbacks and soft-fail, making it sufficiently complete for a complex 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?

With 100% schema description coverage, the description adds value by elaborating on 'since' parameter formats (ISO date or relative shorthand) and providing typical usage examples. It also clarifies that 'type' only supports 'company', going beyond the schema.

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

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

The description uses multiple example queries to convey the tool's purpose: returning a change feed for a company in a recent window, fanning out to SEC EDGAR, GDELT/GNews, and USPTO. It explicitly distinguishes from the sibling tool 'entity_profile', making the purpose unmistakable.

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

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

The description provides clear guidance on when to use this tool versus 'entity_profile' (static profile vs. change feed). It also explains the fallback logic and soft-fail for USPTO. However, it does not explicitly list situations where this tool should not be used.

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

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

Annotations already provide idempotentHint and destructiveHint; description adds key behavioral context: persistence duration (24 hours for anonymous, permanent for authenticated) and scoping by identifier.

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 and front-loaded: states purpose, then usage guidance, then behavioral details. Every sentence adds value with no redundancy.

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

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

Given the simple input schema and no output schema, the description fully covers what the tool does, when to use, and how it behaves, making it complete for an AI agent.

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

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

Schema covers both parameters with descriptions; description adds context about scoping and examples for keys, though schema already has examples.

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 saves data for later reuse across conversations/sessions, using specific verbs and distinguishing from sibling tools 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 discovering something worth carrying forward) and provides examples, plus directs to pair with recall and forget.

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

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

Annotations declare readOnly/openWorld/idempotent, and the description enriches this by disclosing that identifiers are labelled with their source, unresolved identifiers are explicitly listed under `unresolved`, and that LEI/FIGI enrichment 'degrades gracefully' if upstream services fail. It also mentions cascading internal lookups and the ISIN-to-LEI mapping for non-US issuers, providing significant behavioral 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 a long, dense paragraph but is front-loaded with purpose and examples. Every sentence adds value, though it could benefit from bullet points for the supported types. The length is justified given the tool's complexity, but the structure is not optimal for quick scanning.

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

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

Without an output schema, the description carries the full burden of explaining return behavior. It thoroughly covers what to expect: identifiers labelled with source, ownership hierarchy (parent/ultimate-parent/children), the `unresolved` field, and graceful degradation. This gives a complete mental model for a tool with multiple entity types and external dependencies.

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

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

Schema coverage is 100%, so the baseline is 3. The description goes beyond schema by adding ISIN as an accepted input for company type (with explanation of the mapping to legal entity via GLEIF), giving concrete examples ('AAPL', '0000320193', 'ozempic'), and clarifying that drug accepts brand or generic names. This adds useful context that the schema alone does not fully convey.

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

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

The description opens with concrete user queries and states the core function: 'resolve a user-spoken NAME to the canonical/official identifiers other tools require as input.' This is a specific verb (resolve) plus resource (entity identifiers) and clearly distinguishes from siblings by emphasizing the cross-source identity spine and multiple entity types.

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

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

It explicitly instructs 'Use FIRST whenever you have a name but need an ID,' which is a strong when-to-use directive. It also notes the tool 'replaces 2-3 manual lookups,' implying it should be the initial step. However, it does not explicitly name alternatives or state when not to use it, such as when the user already has an identifier.

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. Description adds value by explaining the probing mechanism (calls ai_visibility_check), ranking process, and output structure (score, confidence, signal density). 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 sentences, front-loaded with purpose. Every sentence adds value: purpose, method, use case. No unnecessary words.

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

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

No output schema, but description fully explains return values (ranked list with score, confidence, signal density). Covers input behavior, probe mechanism, and result format. Complete for a comparison tool.

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

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

Schema has 100% description coverage, so baseline is 3. Description adds context: first entity is treated as subject, models default to workers-ai, context disambiguates. Provides usage nuance beyond schema.

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

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

Description clearly states it compares AI visibility across multiple entities using ai_visibility_check, ranks by score, and identifies most/least recognized. Distinguishes from sibling tools by focusing on AI presence 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?

Provides a clear use case example ('does Claude know about us as well as our competitors?') and context for competitive audits. Does not explicitly mention when not to use or list alternatives, but the purpose is well-defined.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false. The description goes beyond by detailing the composite nature (fans out to two external sources), partial failure behavior with graceful degradation, and a specific timing caveat for bundlephobia (5-30s on first measurement). This adds substantial context that annotations cannot convey.

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

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

The description is dense but well-structured, front-loading the core purpose in the first sentence. It efficiently conveys usage, behavior, and output details without unnecessary words. A slight improvement would be to break into separate sentences for readability, but overall it is concise and informative.

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

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

Given there is no output schema, the description fully compensates by listing the return fields (summary block with specific keys, advisories, links, alternative versions). It also covers edge cases like partial failures and the sources_failed list. The tool is complex, but the description leaves no major gaps for an AI agent to understand what it 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% with clear descriptions for both parameters (package and version). The description merely repeats the schema content (scoped packages accepted, version defaults to latest). No additional semantic value is added beyond what the input schema already provides, so a baseline score of 3 is appropriate.

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

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

The description clearly defines the tool's purpose: a composite check for 'should I add this npm package?' that combines data from deps.dev and bundlephobia. It specifies the verb ('scan') and resource ('dependency' aka npm package), and distinguishes from siblings by noting the NPM-only ecosystem constraint.

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

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

Explicitly states when to use: 'whenever an agent asks is X safe / popular / small or what does adding lodash cost me'. Also provides clear exclusion: for other ecosystems (PyPI, Maven, etc.), use deps.dev:version directly. This gives excellent guidance on 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 safety and idempotency. Description adds specific behavioral traits: BGE-base-en embeddings + cosine over 500-char windows, 200K char cap with truncation and flagging. 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 (~120 words), well-structured with key information front-loaded. Every sentence adds value without redundancy.

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

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

Despite no output schema, describes return format accurately (top-N passages with offsets and scores). Covers input constraints, internal algorithm, and fallback behavior (truncation). Pairs with sibling tool. Complete for the tool's 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%. Description reinforces limits (max 200K chars for text) and provides example queries for the query parameter, adding value beyond schema.

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

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

Clearly states 'Semantic search INSIDE a fetched record' and explains the function: given previously fetched text and a natural-language query, returns top passages with offsets and scores. Distinguishes from sibling ask_pipeworx_grounded.

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: 'Use when the record is too big to cram into the prompt — search_within saves context, returns only the passages that matter'. Also explains pairing with ask_pipeworx_grounded.

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 beyond annotations: auth requirements, rate limits (SMS cap 10/day), webhook auto-disable after 10 failures, and one-time secret return. 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?

Information-dense but well-structured with front-loaded purpose, examples, and delivery details. Slightly long but justified by complexity.

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

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

Covers all aspects: supported types, parameter formats, delivery channel details, prerequisites, return value, and failure behaviors (webhook auto-disable). Adequate despite lack of 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?

Adds meaningful context to all 3 parameters through examples and natural language explanations, though schema coverage is already 100%.

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 'Create a proactive monitoring subscription to a live-data event stream', specifying the action (create) and resource (subscription). Distinguishes from siblings like list_subscriptions and unsubscribe.

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

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

Provides detailed when-to-use info including prerequisites (Pipeworx OAuth account) and supported types/delivery channels, but lacks explicit when-not-to-use or comparisons with 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 indicate readOnlyHint, openWorldHint, idempotentHint, and destructiveHint being false. The description adds behavioral context by revealing that the tool returns example questions with tool and argument shapes, and describes the categories. 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 front-loaded with the core purpose and usage, but it is somewhat lengthy with many examples. While every sentence adds value, it could be slightly more concise. Still, the structure is logical and easy to follow.

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 thoroughly explains the return format (category-bucketed questions with tool and argument shapes). It also provides comprehensive instructions on when to use this tool, including the optional topic parameter. 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% (one parameter with description). The description adds value by clarifying the usage of the 'topic' parameter with specific examples ('finance', 'pharma', etc.) and the behavior when omitted, which is not fully captured in 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 explicitly states the tool's purpose as an onboarding entry point that returns category-bucketed example questions. It uses specific verbs ('Returns category-bucketed example questions... with the exact tool + argument shape') and clearly distinguishes itself from sibling tools like 'ask_pipeworx' by being the first contact point.

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

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

The description provides explicit usage guidance: 'Use this FIRST when you do not yet know what Pipeworx can do for you, or to learn how to call the meta-tools.' It also explains when to pass a topic argument and when to omit it, making the usage context very clear.

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

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

Annotations already indicate non-read-only, idempotent, and non-destructive. The description adds that the row is deactivated (not deleted) and historical events remain, which is valuable behavioral context beyond annotations.

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

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

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

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 single parameter and no output schema, the description covers ownership, effect (deactivation), and persistence of history. Could mention success signal but not essential. Fairly complete.

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

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

Schema coverage is 100% and the schema already describes the 'id' parameter as 'subscription id (uuid) returned by subscribe'. The description adds no further semantic detail, so baseline 3 is appropriate.

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

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

The description clearly states the verb 'Cancel' and the resource 'subscription by id', distinguishing from 'subscribe' (creates) and 'list_subscriptions' (lists). It also mentions deactivation vs deletion, adding specificity.

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

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

The description explicitly states ownership enforcement ('you can only cancel your own subscriptions'), which guides when to use. It does not directly contrast with sibling tools but implies this is for canceling, not listing or creating.

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

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

The description goes far beyond annotations by explaining the internal pipeline (SEC EDGAR fast path vs. grounded pipeline), the exact verdict types, and the crucial semantics of 'could_not_verify' vs. 'unsupported.' It discloses that 'could_not_verify' is not evidence, which is critical behavioral context that annotations cannot convey.

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

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

The description is quite long but front-loaded with trigger phrases and purpose. Every sentence adds value, covering usage, output, and error semantics. It is structured well but could have been slightly more concise without losing critical information.

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

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

Given the tool's complexity and absence of an output schema, the description thoroughly explains all necessary aspects: when to use, how claims are routed, expected outputs, and edge-case semantics. It fully compensates for the lack of an output schema by detailing verdicts, citations, and error handling.

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

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

Schema coverage is 100%, so the baseline is 3. The description does not add parameter-specific details beyond what the schema already provides; the examples in the schema are equally informative. However, the description does add behavioral context about how different claim types are processed, which indirectly guides parameter usage.

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

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

The description clearly states the tool's purpose: natural-language claim verification against authoritative sources, with specific trigger phrases and a defined scope. It distinguishes itself from sibling tools by emphasizing fact-checking of user statements and the claim that it replaces multiple sequential calls.

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

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

The description explicitly says 'Use whenever the agent needs to check whether something a user said is factually correct,' which provides clear usage context. It also outlines two distinct paths (company financial vs. other claims), but it does not explicitly name alternatives or list when not to use the tool, leaving some ambiguity.

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